Question

我正在学习.net核心的内置DI，并且感到困惑，为什么在下面可以使用B但不能使用A？

interface IService
{
    void Do();
}

class Service : IService
{
    public void Do() => Console.WriteLine("Doing...");
}


class Program
{
    static void Main()
    {
        using (ServiceProvider sp = RegisterServices())
        {
            sp.GetRequiredService<Service>().Do();
        }
    }

    static ServiceProvider RegisterServices()
    {
        ServiceCollection sc = new ServiceCollection();
        //sc.AddTransient<IService, Service>(); // A
        sc.AddTransient<Service>(); // B
        return sc.BuildServiceProvider();
    }
}

Answer 1

如果您这样做：

sc.AddTransient<Service>();

您正在告诉ServiceProvider（容器）它必须能够解析Service。当我要求Service时，请给我Service。

如果您有一个直接依赖于Service的的类，那将行得通。例如：

public class DependsOnService
{
    private readonly Service _service;

    public DependsOnService(Service service)
    {
        _service = service;
    }
}

但是在许多（也许大多数情况下）我们将编写类以依赖抽象（例如接口），而不是直接依赖于具体类。因此，以上内容通常看起来像这样：

public class DependsOnService
{
    private readonly IService _service;

    public DependsOnService(IService service)
    {
        _service = service;
    }
}

现在，在创建DependsOnService时，容器必须解析IService。它必须知道，当要求它解析IService时，它应该创建的实现是Service。这就是这样做的：

sc.AddTransient<IService, Service>();

它说，当我要求IService时，请给我Service。

AddTransient <iservice，service =“”>（）与AddTransient <service>（）

1 个答案: