Prism的依赖注入

有关于依赖注入是什么，这里就不再过多赘述了。总而言之，当一个类需要使用到另一个类的实例或者功能时，必然会形成一种依赖关系，而通过注入方式就能够很好的实现解耦，这大致就是依赖注入的由来与作用了。这里推荐一篇：https://www.cnblogs.com/liuhaorain/p/3747470.html，通俗易懂，快速理解。

在WPF开发中，Prism框架应用颇多，我今天就来讲有关Prism框架的依赖注入实现。
c#中支持依赖注入的原生方式就是构造注入，属性注入和接口注入。如果一个项目的依赖越多，依赖关系越长。如果你使用原生的依赖方式去注入，就会很麻烦了。举个例子：

//这里先定义好Client类，这里Client类需要依赖C，而C依赖B，B又依赖A
public interface IA { }
public class A : IA
{
    public A() { }
}

public interface IB { }
public class B : IB
{
    private IA _a;
    public B(IA a)
    {
        _a = a;
    }
}

public interface IC { }
public class C : IC
{
    private IA _a;
    private IB _b;
    //这里IC依赖IA和IB是为了演示多依赖的情况，正常模拟依赖链过长的情况就只需要依赖IB
    public C(IA a, IB b)
    {
        _a = a;
        _b = b;
    }
}

public class Client
{
    private IC _c;
    public Client(IC c)
    {
        _c = c;
    }
    public void DoSomething()
    {
        // 使用_c
    }
}

不难看出，在定义类Client这里就已经是又臭又长了，那么在主函数中使用Client要如何做呢？

//主函数入口执行Client类的DoSomething
IA _a=new IA;
IB _b=new IB(_a);
IC _c=new IC(_a,_b);
Client _client=new Client(_c);
_client.DoSomething();

从上可以看出来，如果还有D，E，F，G，H依赖下去，调用DoSomething该有多么麻烦。而且构造函数中的注入过程也会非常繁琐。所以这时就引入了IOC容器，这是基于DIP原则的一种依赖注入框架。接下来我们讲讲它主要做了什么。先看一个看不懂的例子：

//在WPF开发中，我们经常在ViewModel需要引入许多其他的服务类，这里就必然使用注入。比如现在我要注入F类，F依赖E，E依赖D，D依赖C，C依赖B，B依赖A，A又依赖5，4，3，2，1等，用原生的构造注入方式的话也太不现实，冗长且重复。这里我们就用Prism的IOC容器。我们先在另一个服务类（Service）中定义好需要使用的接口类。
public interface IA { }
public class A : IA
{
    public A() { }
}

public interface IB { }
public class B : IB
{
    private IA _a;
    public B(IA a)
    {
        _a = a;
    }
}
......(省略部分)
public interface IF{ }
public class F : IF
{
    private IE _e;
    public F(IE e)
    {
        _e = e;
    }
}
public interface ICanService
public class CanService : ICanService
{
  private IF _f;
  public CanService(IF f)
  {
        _f = f;
  }
  public void Dowork()
  {
        console.writeline("完成了服务")
  }
}
//定义后我们开始使用容器注册（一般我们将依赖注册在App.xaml.cs中，这是整个WPF程序最先执行的入口并且保证依赖全局可用）
public partial class App : PrismApplication  // 继承自 PrismApplication
{
    // Prism 要求重写这个方法
    protected override void RegisterTypes(IContainerRegistry containerRegistry)
    {
        containerRegistry.RegisterSingleton<IA ,A >();
        containerRegistry.RegisterSingleton<IB ,B >();
        ......
        containerRegistry.RegisterSingleton<ICanService ,CanService >();
    }
}
//服务已经注册在容器里了，那么在WPF中我们一般将服务注入在ViewModel层
public class MainViewModel
{
    private ICanService _server;
    public MainViewModel(ICanService server)
    {
          _server = server;
    }
    _server.Dowork();
}

经过代码对比可以看出来，在实际使用时我们不再进行依赖的实例化操作了，也就是不用在 _server.Dowork();之前new IA, new IB...了。这其中也是IOC容器帮我们做了一些事情，具体就叫做控制反转。这里不过多介绍，具体参考推荐文章：https://www.cnblogs.com/fuchongjundream/p/3873073.html
好了，经过了以上介绍，你大概知道了，在WPF开发中，一些公共服务经常会由几个页面的ViewModel去进行调用，使用Prism的IOC容器可以帮我们节省掉许多的时间，同时也很好的实现了代码框架的清晰与解耦。希望本文对你有所帮助，也希望得到各位的一些指点。