如何使用C#依赖注入

Question

抱歉给您带来新手问题。您想学习依赖注入，所以尝试模拟了一个简单的示例。

这是一个基于 .Net6 的控制台应用程序，包含两个主要文件：Program.cs 和 Application.cs。

在 Program.cs 中：

using DependencyInjectionDemo.Services;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

Console.WriteLine("Hello, World!");
IHost _host = Host.CreateDefaultBuilder().ConfigureServices(
    services => {
         services.AddSingleton();
    })
    .Build();

var app = _host.Services.GetRequiredService();
app.TestRun();

此部分创建了一个默认主机，并将 Application 类型作为 IApplication 接口的单例服务注册到服务容器中。然后从服务容器获取 IApplication 实例并调用其 TestRun 方法。

在 Application.cs 中：

using Microsoft.Extensions.Logging;
// ... 其他命名空间省略

namespace DependencyInjectionDemo.Services
{
    internal interface IApplication
    {
        void TestRun();
    }

    internal class Application : IApplication
    {
        private readonly ILogger _logger;

        public Application(ILogger logger)
        {
            _logger = logger;
        }

        public void TestRun()
        {
            _logger.LogInformation("Logging from the Application classssssssssssss!");
            Console.WriteLine("Hello, World from the Application class!");
        }
    }
}

这里定义了 IApplication 接口和其实现类 Application，其中 TestRun 方法使用日志记录功能输出一条消息。

现在您希望创建一个新的 Test 类，并从该类中调用 Application 类的 TestRun 方法。

修改后的 Test.cs：

namespace DependencyInjectionDemo.Services
{
    internal interface ITest
    {
        void CallTestRun();
    }

    internal class Test : ITest
    {
        private IApplication _app;

        public Test(IApplication app)
        {
            _app = app;
        }

        public void CallTestRun()
        {
            Console.WriteLine("Hello, World from the Test class!");
            _app.TestRun();
        }
    }
}

在此版本中，您创建了一个新的 ITest 接口和实现类 Test，并在构造函数中注入 IApplication 以供调用其 TestRun 方法。

最后，在 Program.cs 中进行相应修改：

Console.WriteLine("Hello, World!");

IHost _host = Host.CreateDefaultBuilder().ConfigureServices(
    services => {
        services.AddSingleton();
        services.AddSingleton();
    })
    .Build();

var app = _host.Services.GetRequiredService();
app.TestRun();

var test = _host.Services.GetRequiredService();
test.CallTestRun();

我担心日志输出的顺序不正确...

Joshua Taylor · Answer

在 C# 控制台应用程序中，首先要安装 NuGet 包 Microsoft.Extensions.DependencyInjection。

然后按照以下代码创建依赖注入提供者对象：

var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection();
serviceCollection.AddTransient(); // 注册依赖项
// 为包含 'InnerService' 的 FooService 注册依赖项
serviceCollection.AddTransient();
serviceCollection.AddLogging(); // 添加日志记录依赖项

IServiceProvider serviceProvider = serviceCollection.BuildServiceProvider(); // 创建依赖注入容器

var fooServiceInstance = serviceProvider.GetService();

fooServiceInstance.DoThing(9);
fooServiceInstance.InnerService.DoSomeRealWork();

// 接口定义
public interface IFooService
{
    void DoThing(int number);
    IInnerService InnerService { get; set; }
}

public interface IInnerService
{
    void DoSomeRealWork();
}

// 内部服务实现
public class InnerService : IInnerService
{
    private readonly IFooService _fooService;
    public InnerService()
    {
    }

    public void DoSomeRealWork()
    {
        // 实际业务逻辑
    }
}

// FooService 实现
public class FooService : IFooService
{
    private readonly IInnerService _barServ;
    private readonly ILogger _logger;
    
    public FooService(IInnerService barServ, ILogger logger)
    {
        _barServ = barServ;
        _logger = logger;
    }

    public void DoThing(int number)
    {
        _barServ.DoSomeRealWork();
    }

    public IInnerService InnerService
    {
        get; set;
    }
}

Shyju · Answer

让我们退一步，从.NET 自动注册之外的基础开始，了解一下什么是依赖注入。

假设在一个名为 Program.cs 的文件中，主线程开始运行。假设有两个独立的类：

class App
{
    private Helper helper;

    public App(Helper _helper)
    {
        helper = _helper;
    }

    public int GetZero()
    {
        return helper.GetZero();
    }
}

class Helper
{
    public Helper()
    {
    }

    public int GetZero()
    {
        return 0;
    }
}

现在我们可以看到，App 类“依赖于”Helper 类。
这意味着在我们的 Program.cs 文件中，我们需要先创建这两个类的新实例，并将 Helper 类“注入”到 App 类中：

// 在 Program.cs 中
......代码......
Helper helper = new Helper();
App app = new App(helper);
app.GetZero();
..............

我们必须确保在创建 app 对象之前先创建 helper 对象，因为 app 依赖于 helper，没有它的话，app 几乎无法正常工作。

在 .NET 中，这会由依赖注入容器自动处理一部分。通常，我们会在 ConfigureServices 方法中完成这一操作。然而，在注册服务时，需要注意先注册依赖项，再注册依赖这些依赖项的服务。

在您的例子中，这大概会是这样的：

....
namespace DependencyInjectionDemo
{
    internal class Test
    {
        private Application app;
        public Test(Application _app)
        {
           app = _app;
        }

        public void CallTestRun()
        {
           app.TestRun();
        }
    }
}
...

在 Program.cs 中

using DependencyInjectionDemo.Services;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

Console.WriteLine("Hello, World!");
IHost _host = Host.CreateDefaultBuilder().ConfigureServices(
    services =>
    {
         services.AddSingleton();
         services.AddSingleton();
    })
    .Build();

var app = _host.Services.GetRequiredService();
app.TestRun();

对于您的 Test 类服务，我没有展示接口的创建过程，但我希望您能理解这其中的关键点。