C#进阶——依赖注入(DI)

        我们的一个对象需要调用另一个对象的时候，我们通常会采用new的方法来创建对象，但是这种方法会导致调用者和被调用者之间的耦合性增加，不利于维护

        依赖关系：即一个类的实现需要另一个类的协助

        类之间的依赖关系由容器来负责。简单来讲a依赖b，但a不创建（或销毁）b，仅使用b，b的创建（或销毁）交给容器，这就是依赖注入的精髓

它有三种实现途径

比如我们有两个类，A类和B类，A类的实现需要引用B类中的B方法，如下：

public class A
{
    
    public void A()
    {
        var B = new B()
        B.B();
    }
}
public class B
{
    public void B()
    {
        Console.WritrLine(0);
    }
}

最后我们在客户端进行调用

static void Main()
{
    var A = new A()
    A.A()
}

上面的例子我们可以看出，我们的A类依赖B类，我们DI的定义是，A以来B，但是A不创建（销毁）B，仅仅使用B，所以上面的方法并不符合DI，那我们要怎么做呢?

一、构造函数注入

public class A{
    private B b;
    public A(B b)
    {
        this.b = b;
    }
    public void A()
    {
        b.B();
    }
}

A类就变成如上了，使用构造函数的时候就创建B，不需要再new出来一个B，B类没有变化。

客户端代码就如下了：

static void Main()
{
    var A = new A();
    var B = new B();
    A.a();
}

这样我们虽然A依赖B，但是A没有new一个B出来，就实现了解耦

二、Setter（属性）注入

A类

public class A
{
    private B b;
    public B B
    {
        set
        {
            this.b = value;
        }
        get
        {
            return this.B;
        }
    }
    public void A()
    {
        B.B();
    }
}

B类不需要变化

客户端如下：

static void Main()
{
    var a = new A();
    var b = new B();
    a.A();
}

三、接口注入

Interface IActor
{
    B b {set;get;}
    void B;
}
public class A:IActor
{
    private B b;
    public B B
    {
        set
        {
            this.b = value;
        }
        get
        {
            return this.B;
        }
    }
    public void A()
    {
        B.B();
    }
}

B不需要变化

客户端：

static void Main()
{
    var B = new B();
    IActor actor = new Actor();
    a.A();
}