.NET Core DI，将参数传递给构造函数的方法

Question

具有以下服务构造函数

public class Service : IService
{
     public Service(IOtherService service1, IAnotherOne service2, string arg)
     {    
     }
}

.NET Core IOC机制传参有哪些选择

services.AddSingleton<IOtherService , OtherService>();
services.AddSingleton<IAnotherOne , AnotherOne>();
services.AddSingleton<IService>(x =>
    new Service(
        services.BuildServiceProvider().GetService<IOtherService>(),
        services.BuildServiceProvider().GetService<IAnotherOne >(),
        ""));

还有其他方法吗？

Answer 1

工厂委托的表达式参数（在本例中为x）是一个IServiceProvider。

使用它来解决依赖关系：

_serviceCollection.AddSingleton<IService>(x => 
    new Service(x.GetRequiredService<IOtherService>(),
                x.GetRequiredService<IAnotherOne>(), 
                ""));

工厂委托是延迟调用。每当要解析类型时，它都会将完成的提供程序作为委托参数传递。

Answer 2

如果您对新服务感到不自在，可以使用 Parameter Object 模式。

所以把字符串参数提取成自己的类型

public class ServiceArgs
{
   public string Arg1 {get; set;}
}

构造函数现在看起来像

public Service(IOtherService service1, 
               IAnotherOne service2, 
               ServiceArgs args)
{

}

和设置

_serviceCollection.AddSingleton<ServiceArgs>(_ => new ServiceArgs { Arg1 = ""; });
_serviceCollection.AddSingleton<IOtherService , OtherService>();
_serviceCollection.AddSingleton<IAnotherOne , AnotherOne>();
_serviceCollection.AddSingleton<IService, Service>();

第一个好处是，如果您需要更改服务构造函数并向其添加新服务，则不必更改 new Service(... 调用。另一个好处是设置更简洁。

对于具有一个或两个参数的构造函数，这可能太多了。

Answer 3

实现此目的的推荐方法是使用 Options pattern - 请注意，这适用于任何 .NET Core/5 应用程序，而不仅仅是 ASP.NET Core。但有些用例是不切实际的（例如，当参数仅在运行时已知，而不是在 startup/compile-time 时）或者您需要动态替换依赖项。

当您需要替换单个依赖项（无论是字符串、整数还是其他类型的依赖项）或使用仅接受 string/integer 参数且需要运行时的第 3 方库时，它非常有用参数.

您可以尝试 CreateInstance<T>(IServiceProvider, Object[]) 作为捷径，而不是手动解决每个依赖项：

_serviceCollection.AddSingleton<IService>(x => 
    ActivatorUtilities.CreateInstance<Service>(x, "");
);

传递给服务构造函数的参数（传递给 CreateInstance<T>/CreateInstance 的 object[] 参数）允许您指定应该直接注入的参数，而不是从中解析服务提供商。它们出现时从左到右应用（即，第一个字符串将替换为要实例化的类型的第一个字符串类型参数）。

ActivatorUtilities.CreateInstance<Service>在很多地方都使用了解析服务，替换了这个单次激活的默认注册之一。

例如，如果您有一个名为 MyService 的 class，并且它具有 IOtherService、ILogger<MyService> 作为依赖项并且您想要解析服务但替换IOtherService 的默认服务（比如 OtherServiceA）和 OtherServiceB，你可以这样做：

myService = ActivatorUtilities.CreateInstance<Service>(serviceProvider,
    new OtherServiceB());

然后 IOtherService 的第一个参数将被 OtherServiceB 注入，而不是 OtherServiceA - 但其余参数将来自服务提供商。

当您有很多依赖项并且只想专门处理一个依赖项时（即，将特定于数据库的提供程序替换为在请求期间配置的值或为特定用户配置的值，这是您只在运行时才知道的东西and/or 在请求期间 - 而不是在应用程序处于 built/started).

时

如果性能是一个问题，您可以使用 ActivatorUtilities.CreateFactory(Type, Type[]) to create a factory method instead. GitHub reference and benchmark。

这在类型解析非常频繁时很有用（例如在 SignalR 和其他高请求场景中）。基本上，你会通过

创建一个 ObjectFactory

var myServiceFactory = ActivatorUtilities.CreateFactory(typeof(MyService), new object[] { typeof(IOtherService), });

然后缓存它（作为变量等）并在需要时调用它：

MyService myService = myServiceFactory(serviceProvider, myServiceOrParameterTypeToReplace);

这一切也适用于基本类型 - 这是我测试过的示例：

class Program
{
    static void Main(string[] args)
    {
        var services = new ServiceCollection();
        services.AddTransient<HelloWorldService>();
        services.AddTransient(p => p.ResolveWith<DemoService>("Tseng", "Whosebug"));

        var provider = services.BuildServiceProvider();

        var demoService = provider.GetRequiredService<DemoService>();

        Console.WriteLine($"Output: {demoService.HelloWorld()}");
        Console.ReadKey();
    }
}

public class DemoService
{
    private readonly HelloWorldService helloWorldService;
    private readonly string firstname;
    private readonly string lastname;

    public DemoService(HelloWorldService helloWorldService, string firstname, string lastname)
    {
        this.helloWorldService = helloWorldService ?? throw new ArgumentNullException(nameof(helloWorldService));
        this.firstname = firstname ?? throw new ArgumentNullException(nameof(firstname));
        this.lastname = lastname ?? throw new ArgumentNullException(nameof(lastname));
    }

    public string HelloWorld()
    {
        return this.helloWorldService.Hello(firstname, lastname);
    }
}

public class HelloWorldService
{
    public string Hello(string name) => $"Hello {name}";
    public string Hello(string firstname, string lastname) => $"Hello {firstname} {lastname}";
}

// Just a helper method to shorten code registration code
static class ServiceProviderExtensions
{
    public static T ResolveWith<T>(this IServiceProvider provider, params object[] parameters) where T : class => 
        ActivatorUtilities.CreateInstance<T>(provider, parameters);
}

版画

Output: Hello Tseng Whosebug

Answer 4

您也可以使用此过程注入依赖项

_serviceCollection.AddSingleton<IOtherService , OtherService>();
_serviceCollection.AddSingleton<IAnotherOne , AnotherOne>();
_serviceCollection.AddSingleton<IService>(x=>new Service( x.GetService<IOtherService>(), x.GetService<IAnotherOne >(), "" ));

.NET Core DI，将参数传递给构造函数的方法

.NET Core DI, ways of passing parameters to constructor

c#

dependency-injection

ioc-container

.net-core

asp.net-core