Pro ASP.NET MVC 5 Framework.学习笔记.6.3.MVC的必备工具

每个MVC程序员的军火库中，都有这三个工具：一个依赖注入(DI)容器，一个单元测试框架，一个模拟工具。

1.准备一个示例项目

创建一个ASP.NET MVC Web Application的Empty项目，命名为EssentialTools。

1.1. 创建模型类

在Models文件夹下，创建Product类。

public class Product
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public string Category { get; set; }
}

为了计算一个Product集合的合计金额，需要在Models文件夹下再添加一个LinqValueCalculator的类。

public class LinqValueCalculator {
    public decimal ValueProducts(IEnumerable<Product> products) {
        return products.Sum(p => p.Price);
    }
}

这个类定义了一个叫做ValueProducts的方法，它使用Linq Sum方法，将可枚举对象中的每一个Product的Price属性的值，加在一起。

最后一个模型类是ShoppingCart，它代表一个Product对象的集合，并使用一个LinqValueCalculator来决定合计值。

public class ShoppingCart {
    private LinqValueCalculator calc;
    public ShoppingCart(LinqValueCalculator calcParam) {
        calc = calcParam;
    }
    public IEnumerable<Product> Products { get; set; }
    public decimal CalculateProductTotal() {
        return calc.ValueProducts(Products);
    }
}

1.2.添加控制器

添加一个HomeController

public class HomeController : Controller {
    private Product[] products = {
        new Product {Name = "Kayak", Category = "Watersports", Price = 275M},
        new  Product  {Name  =  "Lifejacket",  Category  =  "Watersports", Price = 48.95M},
        new  Product  {Name  =  "Soccer  ball",  Category  =  "Soccer",  Price = 19.50M},
        new  Product  {Name  =  "Corner  flag",  Category  =  "Soccer",  Price = 34.95M}
    };
    public ActionResult Index() {
        LinqValueCalculator calc = new LinqValueCalculator();
        ShoppingCart  cart  =  new  ShoppingCart(calc)  {  Products  = products };
        decimal totalValue = cart.CalculateProductTotal();
        return View(totalValue);
    }
}

1.3.添加视图

添加一个Index视图

<p>Total Price is :@Model</p>

2.使用Ninject

依赖注入(DI)用于对MVC程序中的各个组件解耦。通过接口和DI容器的组合，创建接口的实现，从而创建一个对象的实例。并且将他们注入到构造器。

我在例子中故意留了一个问题，下面我会解释它，并展示怎么用我喜欢的Ninject这个DI容器去解决它。

2.1.理解这个问题

在实例应用中，我创建了一个DI处理的基本问题：仅仅耦合的类。ShoppingCart类与LinqValueCalculator类紧紧耦合。HomeController类同时与ShoppingCart和LinqValueCalculator类紧紧耦合。

这意味着，如果我要替换LinqValueCalculator类，我不得不在与它紧紧耦合的类中，找到并改变对它的引用。这对于小项目来说，不是一个问题。但在一个真实的项目中，如果我想切换不同的calculator实现(为了测试、为了示例)，比起仅仅用一个类替换另一个类，这样的操作是冗长乏味的，并且容易出错。

2.1.1.应用一个接口

用接口，可以解决部分问题。接口定义了一个从实例中抽象出来的计算功能。在Models文件夹中，添加一个接口。

public interface IValueCalculator {
    decimal ValueProducts(IEnumerable<Product> products);
}

在LinqValueCalculator类中实现它。

public class LinqValueCalculator : IValueCalculator {
    public decimal ValueProducts(IEnumerable<Product> products) {
        return products.Sum(p => p.Price);
    }
}

这个接口，可以让我们破解ShoppingCart类和LinqValueCalculator类之间的紧紧耦合。

public class ShoppingCart {
    private IValueCalculator calc;
    public ShoppingCart(IValueCalculator calcParam) {
        calc = calcParam;
    }
    public IEnumerable<Product> Products { get; set; }
    public decimal CalculateProductTotal() {
        return calc.ValueProducts(Products);
    }
}

到这里，已经做了一些进展。但是C#需要在接口初始化期间，为其制定一个实例类。这可以理解为，因为它需要知道我想要使用哪个实例类。但是，这意味着，在我创建LinqValueCalculator对象时，这个问题依然在HomeController中存在，它依然与LinqValueCalculator类紧紧耦合着。

public ActionResult Index() {
     IValueCalculator calc = new LinqValueCalculator();
    ShoppingCart cart = new ShoppingCart(calc) { Products = products };
    decimal totalValue = cart.CalculateProductTotal();
    return View(totalValue);
}

我用Ninject的目标，是我在一个地方指定我想要实例化的IValueCalculator接口的实现，但是在HomeController的代码中，不出现要使用哪个实现的细节。

这意味着告诉Ninject，LinqValueCalculator是IvalueCalculator接口的实现，我想让它使用并更新HomeController类，让该类通过Ninject获得他的对象，而不是使用new关键字。

2.2.添加Ninject到VS项目中

使用NuGet包管理器，添加Ninject，Ninject.Web.Common，Ninject.MVC3这三个包到项目中。它会添加MVC3的引用，导致报错。在引用中，删除MVC3的引用，就可以在MVC5环境下完美工作。

2.3.用Ninject开始

这里有三个步骤，让基本的Ninject功能开始工作。在HomeController中，添加对Ninject的引用，创建一个Ninject kernel的实例，用Ninject添加接口和实现的绑定，从Ninject获得接口的实现。

public class HomeController : Controller {
    private Product[] products = {
        new Product {Name = "Kayak", Category = "Watersports", Price = 275M},
        new  Product  {Name  =  "Lifejacket",  Category  =  "Watersports", Price = 48.95M},
        new  Product  {Name  =  "Soccer  ball",  Category  =  "Soccer",  Price = 19.50M},
        new  Product  {Name  =  "Corner  flag",  Category  =  "Soccer",  Price = 34.95M}
    };
    public ActionResult Index() {
        IKernel ninjectKernel = new StandardKernel();
        ninjectKernel.Bind<IValueCalculator>().To<LinqValueCalculator>();
        IValueCalculator calc = ninjectKernel.Get<IValueCalculator>();
        ShoppingCart  cart  =  new  ShoppingCart(calc)  {  Products  = products };
        decimal totalValue = cart.CalculateProductTotal();
        return View(totalValue);
    }
}

第一步是准备Ninject。创建一个Ninject kernel的实例，它用来响应解决依赖，并创造新对象。当我需要一个对象时，我会使用kernel，而不是new关键字。

IKernel ninjectKernel = new StandardKernel();

通过创建StandardKernel类的新的实例，我创建了一个Ninjnel接口的实现。Ninject可以被扩展和个性化，来使用不同类型的kernel，但我只需要内置的StandardKernel。

第二步，是配置Ninject kernel ，让它理解我想使用每个接口的哪个实现。

ninjectKernel.Bind< IValueCalculator >().To< LinqValueCalculator >();

Ninject使用C#类型参数，来创建一个关系：将Bind方法的参数，设置为我想要使用的接口，并且在它返回的结果上，调用To方法。我将To方法的参数，设置为我想要实例化的那个接口的实现类。这个声明告诉Ninject，在IValueCalculator接口上的依赖，应该通过创建一个LinqValueCalculator类的实例来解决。最后一步，是使用Ninject的Get方法来创建一个对象。

IValueCalculator calc = ninjectKernel.Get<IValueCalculator>() ;

Get方法的参数，告诉Ninject，我感兴趣的是哪个接口，并且该方法返回的结果，是我在To方法中指定的实现的一个实例。

2.4.设置MVC依赖注入

上面展示的三个步骤的结果，是关于实现类必须被实例化来履行Ninject中设置的IValueCalculator接口的请求的知识。当然，我们还没有改进我们的应用，因为剩下的定义在HomeController中，这以为和HomeController依然与LinqValueCalculator类紧紧耦合着。

接下来，我会展示如何在MVC应用的核心部分，嵌入Ninject。这会让我们简化Controller，扩展Ninject的影响，让他贯穿整个应用。最后从控制器中移除配置。

2.4.1创建依赖解决者

我要做的第一个改变，是做一个自定义的依赖解决者。MVC框架使用依赖解决者来创建它需要服务请求的类的实例。通过创建一个自定义的解决者，我能确保MVC框架，无论何时他创建对象时，都使用Ninject。

要设置解决者，我创建一个文件夹Infrastructure（基础建设），用它来放不适合放在其他文件夹下的类。在文件夹下，创建NinjectDependencyresolver类。

public class NinjectDependencyResolver : IDependencyResolver {
    private IKernel kernel;
    public NinjectDependencyResolver(IKernel kernelParam) {
        kernel = kernelParam;
        AddBindings();
    }
    public object GetService(Type serviceType) {
        return kernel.TryGet(serviceType);
    }
    public IEnumerable<object> GetServices(Type serviceType) {
        return kernel.GetAll(serviceType);
    }
    private void AddBindings() {
        kernel.Bind<IValueCalculator>().To<LinqValueCalculator>();
    }
}

NinjectDependencyResolver类实现IDependencyResolver接口，这个接口是System.Mvc命名空间的一部分，并且MVC框架用它来得到需要的对象。MVC框架在他需要一个类的实例来服务传入的请求时，会调用GetService或GetServices方法。依赖解决者的任务，是通过执行TryGet和GetAll方法来创建实例。TryGet方法工作方式和Get方法相似，但是当这里没有合适的绑定时，它返回null，而不是抛出一个异常。GetAll方法支持多个绑定到一个单一类型，它用于当有多个不同的实现对象可用时。

我的依赖解决者类，也是我设置我的Ninject binding的地方。在AddBindings方法中，我使用Bind和To方法，来配置IValueCalculator接口和LinqValueCalculator类之间的关系。

2.4.2.注册依赖解决者

仅仅是创建一个IDependencyResolver接口的实现是不够的。Ninject包会在App_Start文件夹下创建一个叫做NinjectWebCommon的文件，它里面定义了程序启动时的automatically的方法，用来整合进ASP.NET请求的生命周期。在NinjectWebCommon类中的RegisterServices方法，我添加了一个声明，来创建一个NinjectDependencyResolver类的实例。并且使用System.Web.Mvc.DependencyResolver类中的静态方法SetResolver，使用MVC框架注册解决者。这句声明创建了Ninject和MVC框架之间的桥梁，来支持DI。

private static void RegisterServices(IKernel kernel) {
    System.Web.Mvc.DependencyResolver.SetResolver(new EssentialTools.Infrastructure.NinjectDependencyResolver(kernel));
}

2.4.3.重构HomeController

最后一步，是重构HomeController。在之前的章节，我们呢在它里面配置了一些先进的工具。

public class HomeController : Controller {
    private IValueCalculator calc;
    private Product[] products = {
        new Product {Name = "Kayak", Category = "Watersports", Price = 275M},
        new  Product  {Name  =  "Lifejacket",  Category  =  "Watersports", Price = 48.95M},
        new  Product  {Name  =  "Soccer  ball",  Category  =  "Soccer",  Price = 19.50M},
        new  Product  {Name  =  "Corner  flag",  Category  =  "Soccer",  Price = 34.95M}
    };
    public HomeController(IValueCalculator calcParam) {
        calc = calcParam;
    }
    public ActionResult Index() {
        ShoppingCart  cart  =  new  ShoppingCart(calc)  {  Products  = products };
        decimal totalValue = cart.CalculateProductTotal();
        return View(totalValue);
    }
}

最主要的改变，是我在了一个构造器，让它接收一个IValueCalculator接口的实现，改变HomeControllr类，让它声明一个依赖。当Ninject创建一个controller的实例时，Ninject会使用我在NinjectDependencyResolver类中的配置，为controller提供一个IValueCalculator接口的实现。

另一个改变，是移除了controller中提及的Ninject或LinqValueCalculator类。最后，我破坏了HomeController和LinqValueCalculator类之间紧紧耦合。

我已经创建了一个构造器注入的例子，它是依赖注入的一种。当你运行示例应用，并且IE请求应用的根路径时，发生的：

1.MVC框架接收到请求，并计算出请求是希望加入Home控制器。

2.MVC框架请求我自定义的依赖解决者，依赖解决者会使用GetService方法的Type参数，指定要创建的类，创建一个HomeController类的新实例。

3.我的依赖解决者请求Ninject创建一个新的HomeController类，将Type对象传递给TryGet方法。

4.Ninject会检查HomeController的构造器，发现它有一个声明，依赖了它应景绑定的IValueCalculator接口。

5.Ninject创建一个LinqValueCalculator类的实例，并使用它创建一个HomeController类的心实例。

6.Ninject传递HomeController实例给自定义依赖解决者，它会将他返回给MVC框架。MVC框架使用控制器的实例来为请求服务。

我分析得这么细，是因为在你第一次使用DI时，觉得它有点离奇古怪令人费解。我这样做的一个益处，是程序中的任何控制器，都能声明一个依赖，并且MVC框架会使用Ninject来解决它。

最好的部分是，当我想要用其他实现替换LinqValueCalculator时，只需要修改依赖解决者类。因为这是唯一一个地方，我不得不指定我要使用IValueCalculator接口的实现。