Ecng.Configuration

A lightweight and efficient configuration management library for .NET applications, providing typed access to configuration sections, application settings, and a flexible service registry.

Overview

Ecng.Configuration wraps and extends the .NET System.Configuration framework, offering:

• Type-safe access to configuration sections and groups
• Service registry pattern for dependency injection and service location
• Event-driven notifications for service registration
• AppSettings helpers with type conversion
• Thread-safe operations for concurrent access

Installation

This library requires:

• .NET Standard 2.0+ or .NET 6.0+
• System.Configuration.ConfigurationManager package

<PackageReference Include="System.Configuration.ConfigurationManager" />

Key Features

1. Configuration Sections

Access configuration sections by type or name with built-in caching for performance.

Access by Type

using Ecng.Configuration; // Get a custom configuration section by type var section = ConfigManager.GetSection<MyCustomSection>(); // Section will be null if not found if (section != null) { // Use the section var value = section.SomeProperty; }

Access by Name

// Get section by name var connectionStrings = ConfigManager.GetSection<ConnectionStringsSection>("connectionStrings"); // Or without type parameter var section = ConfigManager.GetSection("mySection");

Example Configuration File

<configuration> <configSections> <section name="mySection" type="MyNamespace.MyCustomSection, MyAssembly"/> </configSections> <mySection someProperty="value" /> </configuration>

2. Configuration Section Groups

Organize related configuration sections into groups.

// Get a section group by type var group = ConfigManager.GetGroup<MyConfigurationGroup>(); // Get a section group by name var systemWeb = ConfigManager.GetGroup<SystemWebSectionGroup>("system.web");

3. Application Settings

Simple access to AppSettings with type conversion support.

// Get a setting with default value int timeout = ConfigManager.TryGet<int>("RequestTimeout", 30); // Get a boolean setting bool enableLogging = ConfigManager.TryGet<bool>("EnableLogging", false); // Get a string setting string apiUrl = ConfigManager.TryGet<string>("ApiUrl", "https://default-api.com"); // Direct access to all AppSettings var allSettings = ConfigManager.AppSettings; foreach (string key in allSettings.AllKeys) { Console.WriteLine($"{key} = {allSettings[key]}"); }

Configuration File:

<configuration> <appSettings> <add key="RequestTimeout" value="60" /> <add key="EnableLogging" value="true" /> <add key="ApiUrl" value="https://api.example.com" /> </appSettings> </configuration>

4. Service Registry

A lightweight service locator pattern for managing application services without heavy DI frameworks.

Register Services

// Register a service with default name (type's AssemblyQualifiedName) var securityProvider = new CollectionSecurityProvider(securities); ConfigManager.RegisterService<ISecurityProvider>(securityProvider); // Register a service with a custom name ConfigManager.RegisterService<ILogger>("FileLogger", new FileLogger()); ConfigManager.RegisterService<ILogger>("ConsoleLogger", new ConsoleLogger());

Retrieve Services

// Get a service by type (using default name) var provider = ConfigManager.GetService<ISecurityProvider>(); // Get a service by name var fileLogger = ConfigManager.GetService<ILogger>("FileLogger"); var consoleLogger = ConfigManager.GetService<ILogger>("ConsoleLogger"); // Try to get a service (returns default if not found) var optionalService = ConfigManager.TryGetService<IOptionalFeature>(); if (optionalService != null) { // Service is available }

Check Service Registration

// Check if a service is registered if (ConfigManager.IsServiceRegistered<IMessageAdapter>()) { var adapter = ConfigManager.GetService<IMessageAdapter>(); } // Check by name if (ConfigManager.IsServiceRegistered<ILogger>("FileLogger")) { // Use the file logger }

Conditional Registration

// Register only if not already registered ConfigManager.TryRegisterService<IDefaultService>(new DefaultServiceImpl()); // This won't override the existing registration ConfigManager.TryRegisterService<IDefaultService>(new AnotherImpl());

Get All Services of a Type

// Get all registered services of a specific type var allLoggers = ConfigManager.GetServices<ILogger>(); foreach (var logger in allLoggers) { logger.Log("Application started"); }

5. Service Registration Events

React to service registration with event handlers or subscriptions.

Global Event Handler

// Subscribe to all service registrations ConfigManager.ServiceRegistered += (type, service) => { Console.WriteLine($"Service registered: {type.Name}"); }; // Now register a service ConfigManager.RegisterService<IMyService>(new MyServiceImpl()); // Output: Service registered: IMyService

Type-Specific Subscription

// Subscribe to a specific service type registration ConfigManager.SubscribeOnRegister<ISecurityProvider>(provider => { Console.WriteLine($"SecurityProvider registered with {provider.Count} securities"); // Initialize or configure the provider }); // When this service is registered, the callback will be invoked ConfigManager.RegisterService<ISecurityProvider>(new CollectionSecurityProvider(securities));

6. Service Fallback

Provide a fallback mechanism to create services on-demand when they're not registered.

// Set up a service fallback handler ConfigManager.ServiceFallback += (type, name) => { // Create services dynamically based on type if (type == typeof(ILogger)) { return new DefaultLogger(); } if (type == typeof(ICache)) { return new MemoryCache(); } // Return null to indicate service cannot be created return null; }; // Now getting an unregistered service will use the fallback var logger = ConfigManager.GetService<ILogger>(); // Creates DefaultLogger

7. Access Underlying Configuration

For advanced scenarios, access the underlying .NET Configuration object.

// Get the underlying Configuration object var config = ConfigManager.InnerConfig; if (config != null) { Console.WriteLine($"Configuration file: {config.FilePath}"); // Access sections directly foreach (ConfigurationSection section in config.Sections) { Console.WriteLine($"Section: {section.SectionInformation.Name}"); } }

Complete Usage Example

Here's a complete example showing typical usage in an application:

using Ecng.Configuration; using System; namespace MyApplication { public class Program { static void Main(string[] args) { // 1. Configure service fallback (optional) ConfigManager.ServiceFallback += CreateDefaultServices; // 2. Subscribe to service registrations (optional) ConfigManager.SubscribeOnRegister<ILogger>(logger => { logger.Initialize(); }); // 3. Register core services ConfigManager.RegisterService<ILogger>(new FileLogger("app.log")); ConfigManager.RegisterService<IExchangeInfoProvider>( new InMemoryExchangeInfoProvider() ); // 4. Register multiple implementations with names ConfigManager.RegisterService<ICache>("Memory", new MemoryCache()); ConfigManager.RegisterService<ICache>("Distributed", new RedisCache()); // 5. Read application settings var timeout = ConfigManager.TryGet<int>("Timeout", 30); var apiUrl = ConfigManager.TryGet<string>("ApiUrl"); // 6. Get configuration section var customSection = ConfigManager.GetSection<CustomAppSettings>(); // 7. Use services throughout your application RunApplication(); } static void RunApplication() { // Retrieve services when needed var logger = ConfigManager.GetService<ILogger>(); logger.Log("Application started"); var provider = ConfigManager.GetService<IExchangeInfoProvider>(); var exchanges = provider.GetExchanges(); // Use named service var cache = ConfigManager.GetService<ICache>("Memory"); cache.Set("key", "value"); } static object CreateDefaultServices(Type type, string name) { // Provide default implementations if (type == typeof(ILogger)) return new ConsoleLogger(); return null; } } // Example interfaces public interface ILogger { void Initialize(); void Log(string message); } public interface IExchangeInfoProvider { IEnumerable<Exchange> GetExchanges(); } public interface ICache { void Set(string key, string value); string Get(string key); } }

Thread Safety

All operations in ConfigManager are thread-safe:

• Configuration sections and groups are cached on first access
• Service registry operations use locking to prevent race conditions
• Multiple threads can safely register and retrieve services concurrently

// Safe to call from multiple threads Parallel.For(0, 100, i => { var service = ConfigManager.GetService<IMyService>(); service.DoWork(); });

Best Practices

1. Register Services at Application Startup

// Register all services during application initialization public static void ConfigureServices() { ConfigManager.RegisterService<ILogger>(new Logger()); ConfigManager.RegisterService<IDataService>(new DataService()); // ... register other services }

2. Use Type-Safe Access

// Prefer type-safe access over string-based access var section = ConfigManager.GetSection<MySection>(); // Good var section = (MySection)ConfigManager.GetSection("mySection"); // Less safe

3. Provide Defaults for AppSettings

// Always provide sensible defaults var timeout = ConfigManager.TryGet<int>("Timeout", 30); // Good var timeout = ConfigManager.TryGet<int>("Timeout"); // May return 0

4. Check Service Registration Before Use

// For optional services, check registration first if (ConfigManager.IsServiceRegistered<IOptionalFeature>()) { var feature = ConfigManager.GetService<IOptionalFeature>(); feature.Execute(); }

5. Use Named Services for Multiple Implementations

// Register different implementations with descriptive names ConfigManager.RegisterService<IRepository>("User", new UserRepository()); ConfigManager.RegisterService<IRepository>("Product", new ProductRepository()); // Retrieve specific implementation var userRepo = ConfigManager.GetService<IRepository>("User");

Common Patterns

Singleton Services

// Register singleton services var singletonService = new MySingletonService(); ConfigManager.RegisterService<IMySingletonService>(singletonService); // Every call returns the same instance var service1 = ConfigManager.GetService<IMySingletonService>(); var service2 = ConfigManager.GetService<IMySingletonService>(); // service1 == service2

Factory Pattern with Fallback

// Use fallback as a factory ConfigManager.ServiceFallback += (type, name) => { if (type == typeof(IDataService)) { // Create with dependencies var logger = ConfigManager.GetService<ILogger>(); return new DataService(logger); } return null; }; // First call creates and registers the service var service = ConfigManager.GetService<IDataService>();

Configuration-Driven Service Selection

// Select service implementation based on configuration var loggerType = ConfigManager.TryGet<string>("LoggerType", "Console"); ILogger logger = loggerType switch { "File" => new FileLogger(), "Console" => new ConsoleLogger(), "Database" => new DatabaseLogger(), _ => new ConsoleLogger() }; ConfigManager.RegisterService<ILogger>(logger);

Migration from .NET ConfigurationManager

If you're migrating from using ConfigurationManager directly:

// Before: var setting = ConfigurationManager.AppSettings["MySetting"]; // After: var setting = ConfigManager.AppSettings["MySetting"]; // Or with type conversion: var typedSetting = ConfigManager.TryGet<int>("MySetting", 0); // Before: var section = (MySection)ConfigurationManager.GetSection("mySection"); // After: var section = ConfigManager.GetSection<MySection>("mySection");

Limitations

• Configuration file must exist and be valid at application startup
• Configuration sections are cached on first load (not reloaded automatically)
• Service registry is in-memory only (not persisted)
• Not a replacement for full dependency injection frameworks (suitable for simpler scenarios)

See Also

• System.Configuration documentation
• ConfigurationManager class

License

Part of the StockSharp/Ecng framework.