如何通过JSON文件配置.NET Core 2.0依赖注入的接口与类映射？

Great question! .NET Core 2.0 doesn't have native built-in support for directly configuring dependency injection (DI) interface-to-class mappings via JSON out of the box, but you can absolutely build this functionality yourself using the framework's configuration system and reflection. Here's a complete example to achieve what you're asking for:

Step 1: Define the JSON Configuration Format #

First, create a JSON file (let's call it service-config.json) that defines your interface-implementation mappings along with their service lifetimes. You need to use fully qualified type names (including namespaces and assembly names) so reflection can locate the types correctly:

{
  "ServiceMappings": [
    {
      "Interface": "YourNamespace.ISomeService, YourAssemblyName",
      "Implementation": "YourNamespace.SomeService, YourAssemblyName",
      "Lifetime": "Transient"
    },
    {
      "Interface": "YourNamespace.IAnotherService, YourAssemblyName",
      "Implementation": "YourNamespace.AnotherService, YourAssemblyName",
      "Lifetime": "Scoped"
    }
  ]
}

Note: If your interfaces and implementations are in the same assembly as your startup code, you can omit the assembly name part (e.g., YourNamespace.ISomeService), but including it avoids ambiguity.

Step 2: Create Configuration Binding Classes #

Next, define POCO classes to bind your JSON configuration to, using .NET's options pattern:

public class ServiceMappingOptions
{
    public List<ServiceMapping> ServiceMappings { get; set; } = new List<ServiceMapping>();
}

public class ServiceMapping
{
    public string Interface { get; set; }
    public string Implementation { get; set; }
    public string Lifetime { get; set; }
}

Step 3: Parse the JSON and Register Services #

Update your existing code to read the JSON configuration, parse the mappings, and register the services dynamically:

// Build configuration from the JSON file
var configBuilder = new ConfigurationBuilder()
    .AddJsonFile("service-config.json", optional: false, reloadOnChange: true)
    .Build();

var services = new ServiceCollection();
services.AddOptions();

// Bind the JSON configuration to our options class
var serviceMappings = configBuilder.GetSection("ServiceMappings").Get<List<ServiceMapping>>();

// Loop through each mapping and register the service
foreach (var mapping in serviceMappings)
{
    // Resolve the interface and implementation types using reflection
    var interfaceType = Type.GetType(mapping.Interface);
    var implementationType = Type.GetType(mapping.Implementation);

    if (interfaceType == null)
        throw new InvalidOperationException($"Could not locate interface type: {mapping.Interface}");
    if (implementationType == null)
        throw new InvalidOperationException($"Could not locate implementation type: {mapping.Implementation}");
    if (!interfaceType.IsAssignableFrom(implementationType))
        throw new InvalidOperationException($"{mapping.Implementation} does not implement {mapping.Interface}");

    // Register the service based on the specified lifetime
    switch (mapping.Lifetime.Trim().ToLowerInvariant())
    {
        case "transient":
            services.AddTransient(interfaceType, implementationType);
            break;
        case "scoped":
            services.AddScoped(interfaceType, implementationType);
            break;
        case "singleton":
            services.AddSingleton(interfaceType, implementationType);
            break;
        default:
            throw new InvalidOperationException($"Unsupported service lifetime: {mapping.Lifetime}. Use Transient, Scoped, or Singleton.");
    }
}

// Keep your existing options configuration if needed
services.Configure<SomeServiceOptions>(configBuilder.GetSection("SomeServiceOptions"));

// Build the service provider
var serviceProvider = services.BuildServiceProvider();

Important Notes #

• Type Resolution: Make sure your fully qualified type names are correct. If your types are in a different assembly, you must include the assembly name (e.g., MyProject.ISomeService, MyProject).
• Error Handling: The example includes basic error checking, but you might want to add logging instead of throwing exceptions in production code.
• Options Pattern: You can still use your existing SomeServiceOptions configuration alongside this dynamic DI registration—they work perfectly together.

内容的提问来源于stack exchange，提问作者beekeeper