依赖:
类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容器:
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(); } }
当然,实际的 IoC 容器复杂得多.