两种IOC容器注入的类型

基于接口的注入

在基于接口的注入中，您使用接口来定义依赖项。这允许您在不更改代码的情况下轻松地切换依赖项的不同实现。

代码示例：

public interface IMyDependency
{
    void DoSomething();
}
public class MyClass
{
    private readonly IMyDependency _dependency;
    public MyClass(IMyDependency dependency)
    {
        _dependency = dependency;
    }
}

在上面的示例中，IMyDependency 接口定义了依赖项。
MyClass 类使用该接口来注入依赖项。
您可以使用不同的类来实现 IMyDependency 接口，而无需更改 MyClass 类的代码。

基于类的注入

在基于类的注入中，您使用类来定义依赖项。这可以提供更好的性能，但它也使得在不更改代码的情况下切换依赖项的不同实现变得更加困难。

代码示例：

public class MyDependency
{
    public void DoSomething()
    {
        // ...
    }
}

public class MyClass
{
    private readonly MyDependency _dependency;

    public MyClass(MyDependency dependency)
    {
        _dependency = dependency;
    }
}

在上面的示例中，MyDependency 类定义了依赖项。
MyClass 类使用该类来注入依赖项。
如果您想要切换 MyDependency 类的一个不同的实现，您需要更改 MyClass 类的代码。

哪种注入方法更好？

基于接口的注入通常是首选方法，因为它更灵活且更容易测试。
但是，基于类的注入在某些情况下可以提供更好的性能。

何时使用基于类的注入？

您可能需要使用基于类的注入的情况包括：

当您需要访问依赖项的非公共成员时。
当您需要确保依赖项是单例时。
当您需要优化性能时。

完整的代码示例(基于接口和类的注入)

using System;
using Microsoft.Extensions.DependencyInjection;

// 定义依赖接口
public interface IDependency
{
    void DoWork();
}


// 实现依赖接口的类
public class DependencyImplementation : IDependency
{
    public void DoWork()
    {
        Console.WriteLine("工作已完成。");
    }
}



// 使用基于接口的注入的客户端类
public class ClientWithInterfaceInjection
{
    private readonly IDependency _dependency;

    public ClientWithInterfaceInjection(IDependency dependency)
    {
        _dependency = dependency;
    }

    public void StartWork()
    {
        Console.WriteLine("start work,基于接口注入");
        _dependency.DoWork();
        Console.WriteLine("end work,基于接口注入");
    }
}


// 使用基于类的注入的客户端类
public class ClientWithClassInjection
{
    private readonly DependencyImplementation _dependency;

    public ClientWithClassInjection(DependencyImplementation dependency)
    {
        _dependency = dependency;
    }

    public void StartWork()
    {
        System.Console.WriteLine("start work,基于类注入");
        _dependency.DoWork();
        System.Console.WriteLine("end work,基于类注入");
    }
}



class Program
{
    static void Main(string[] args)
    {
        // 设置依赖注入容器
        var services = new ServiceCollection();

        // 注册接口和实现
        services.AddTransient<IDependency, DependencyImplementation>();

        // 注册类
        services.AddTransient<DependencyImplementation>();

        services.AddTransient<ClientWithInterfaceInjection>();
        services.AddTransient<ClientWithClassInjection>();



        // 构建服务提供者
        var serviceProvider = services.BuildServiceProvider();

        // 基于接口的注入
        var clientInterface = serviceProvider.GetService<ClientWithInterfaceInjection>();
        clientInterface.StartWork();

        Console.WriteLine("----------------------");

        // 基于类的注入
        var clientClass = serviceProvider.GetService<ClientWithClassInjection>();
        clientClass.StartWork();

    }
}