ASP.NET Core 基础组件

分手后的思念是犯贱 2024-03-27 08:47 13阅读 0赞

## [ASP.NET][] Core中的依赖注入 ##

依赖:

类A用到了类B,我们就说类A依赖类B.如果一个类没有任何地方使用到,那这个类基本上可以删掉了.

public class Test
        {
            private MyDependency md = new MyDependency();
    
            public void Print()
            {
                md.Print();
            }
        }

public class MyDependency
        {
            public void Print()
            {
                Console.WriteLine("this is mydependency");
            }
        }

上面的示例中,Test 类就依赖 MyDependency 类.

**依赖倒置:**

依赖倒置原则是五大原则之一:

1.上层模块不应该依赖于下层模块，它们共同依赖于一个抽象.

2.抽象不能依赖于具象，具象依赖于抽象.

什么是上层?使用者就是上层,上例中,Test 类就是上层.

什么是下层?被使用者就是下层.上例中,Test 类使用了 MyDependency 类, MyDependency 类就是下层.

上层不应该依赖下层,Test 类不应该依赖 MyDependency 类,因为如果 MyDependency 类变化了,就是把这种变化所造成的影响传递到上层 Test 类.

因此,上例按照依赖倒置原则修改如下:

public class Test
        {
            private IDepenency md = new MyDependency();
    
            public void Print()
            {
                md.Print();
            }
        }

public interface IDepenency
        {
            void Print();
        }
    
    
    
        public class MyDependency : IDepenency
        {
            public void Print()
            {
                Console.WriteLine("this is mydependency");
            }
        }

**控制反转(IoC):Inversion of Control**

控制反转是一种思想,所谓"控制反转",就是反转获得依赖对象的过程.或许,叫"反转控制"更容易理解.

上例虽然遵循了"依赖倒置原则",但是违背"开放封闭原则",因为如果有一天想修改 md 为 YourDependency 类的实例,则需要修改 Test 类.因此,我们需要反转这种创建对象的过程.

internal class Program
        {
            private static void Main(string[] args)
            {
                Test test = new Test(new MyDependency());
                test.Print();           
                Console.ReadKey();
            }
        }
    
        public class Test
        {
            private IDepenency md;
    
            public Test(IDepenency depenency)
            {
                md = depenency;
            }
    
            public void Print()
            {
                md.Print();
            }
        }

上例中,将 md 的创建过程"反转"给了调用者.

**依赖注入(DI):Dependency Inject**

依赖注入设计模式是一种在类及其依赖对象之间实现控制反转(IOC)思想的技术.

所谓依赖注入，就是由IoC容器在运行期间，动态地将某种依赖关系注入到对象之中。

我们先创建一个简易的IoC容器(当然,实际的 IoC 容器复杂得多.):

public class IoCContainer
        {
            private Dictionary<Type, Object> dic;
    
            public IoCContainer()
            {
                Init();
            }
    
            private void Init()
            {
                dic = new Dictionary<Type, object>
                {
                    {typeof(IDepenency),new MyDependency() }
                };
            }
    
            public T GetInstance<T>()
            {
                return (T)dic[typeof(T)];
            }
        }

那么,上例的调用,则可以修改成:

internal class Program
        {
            private static void Main(string[] args)
            {
                IoCContainer container = new IoCContainer();//创建一个容器
                IDepenency dependency = container.GetInstance<IDepenency>();//获取注册的实例
                Test test = new Test(dependency);
                test.Print();
                Console.ReadKey();
            }
        }

依赖注入分为3中:构造函数注入,属性注入,方法注入,上例属于构造函数注入.

[ASP.NET]: https://ASP.NET