Best Practices for Reading Configuration in .NET Class Libraries: From ConfigurationSettings to ConfigurationManager

Evolution of Configuration Reading

In the early stages of .NET development, programmers commonly used ConfigurationSettings.AppSettings.Get("MySetting") to read application configuration. While this approach was straightforward, Microsoft has explicitly marked it as deprecated with the evolution of the .NET framework, recommending developers migrate to more modern configuration reading methods.

Modern Configuration Reading Solutions

The currently recommended approach for configuration reading is using ConfigurationManager.AppSettings["MySetting"]. This class resides in the System.Configuration namespace, providing type-safe and performance-optimized configuration access.

Configuring System.Configuration in Class Library Projects

For C# class library projects, the System.Configuration.ConfigurationManager class is not available by default. Manual addition of reference to the System.Configuration assembly is required:

// Add reference in project
// Right-click project → Add Reference → Assemblies → Framework → Select System.Configuration

// Add using statement in code file
using System.Configuration;

// Read configuration values
string configValue1 = ConfigurationManager.AppSettings["countoffiles"];
string configValue2 = ConfigurationManager.AppSettings["logfilelocation"];

Configuration File Structure Example

The typical structure of appSettings section in an app.config or web.config file is as follows:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="countoffiles" value="7" />
    <add key="logfilelocation" value="abc.txt" />
  </appSettings>
</configuration>

Special Considerations for Class Library Configuration

Class library projects themselves do not contain configuration files; their configuration depends on the host application's configuration file. When a class library is referenced by an ASP.NET Web application, it reads from web.config; when referenced by a Windows Forms application, it reads from app.config (which becomes applicationname.exe.config after compilation).

Practical Applications of Configuration Values

Configuration values can be used in various scenarios such as database connection strings, file paths, application settings, etc.:

public class DatabaseService
{
    private readonly string _connectionString;
    
    public DatabaseService()
    {
        _connectionString = ConfigurationManager.AppSettings["ConnectionString"];
    }
    
    public void ConnectToDatabase()
    {
        // Use configured connection string
        using (var connection = new SqlConnection(_connectionString))
        {
            connection.Open();
            // Perform database operations
        }
    }
}

Error Handling and Default Values

In practical applications, appropriate error handling should be implemented for configuration reading:

public string GetConfigurationValue(string key, string defaultValue = "")
{
    try
    {
        var value = ConfigurationManager.AppSettings[key];
        return string.IsNullOrEmpty(value) ? defaultValue : value;
    }
    catch (Exception ex)
    {
        // Log error
        System.Diagnostics.Debug.WriteLine($"Configuration reading error: {ex.Message}");
        return defaultValue;
    }
}

Performance Optimization Recommendations

For frequently accessed configuration values, caching is recommended to improve performance:

public static class AppConfig
{
    private static readonly ConcurrentDictionary<string, string> _cache = new ConcurrentDictionary<string, string>();
    
    public static string GetValue(string key)
    {
        return _cache.GetOrAdd(key, k => ConfigurationManager.AppSettings[k] ?? string.Empty);
    }
    
    public static void ClearCache()
    {
        _cache.Clear();
    }
}

Migration Strategy

For existing projects migrating from obsolete ConfigurationSettings to ConfigurationManager:

1. Add System.Configuration reference
2. Add using System.Configuration statement to relevant files
3. Replace ConfigurationSettings.AppSettings.Get("key") with ConfigurationManager.AppSettings["key"]
4. Test all configuration reading functionality to ensure proper operation

Cross-Platform Compatibility

In .NET Core and .NET 5+, the configuration system has undergone significant changes, introducing a more flexible configuration provider model. However, for traditional .NET Framework projects, ConfigurationManager remains the standard approach for reading app.config and web.config.

Security Considerations

Configuration files may contain sensitive information such as passwords in connection strings. Recommendations include:

• Use encryption for sensitive configurations in production environments
• Avoid hardcoding passwords in configuration files
• Consider secure storage solutions like Azure Key Vault
• Exclude configuration files containing sensitive information from version control

Conclusion

Migrating from deprecated ConfigurationSettings to ConfigurationManager is an essential step in .NET development. By properly adding System.Configuration references and adopting the new API, developers can ensure code modernity, maintainability, and performance. Configuration reading in class library projects relies on the host application's configuration files, a design that enables more centralized and unified configuration management.