当一个类依赖于另一个具体类的时候,这样很容易形成两者间的"强耦合"关系。我们通常根据具体类抽象出一个接口,然后让类来依赖这个接口,这样就形成了"松耦合"关系,有利于应用程序的扩展。我们可以用DI容器、Dependency Injection容器,即依赖注入容器来管理接口和实现类。所谓的"依赖注入"是指:当某个类需要用到或依赖于某个接口类的实现类时,通过DI容器的API把接口注入到该类的构造函数或属性上,接着调用注入接口的方法,DI容器根据已经注册的依赖性链,要么自动执行接口实现类的方法,要么使用它的API选择性地执行某个接口实现类的方法。本篇体验使用Ninject这个DI容器。
本篇内容包括:
Ninject管理简单的接口和实现类,自动执行接口实现类方法
需求:一个购物车类计算所有产品的总价
有关产品:
public class Product
{
int Id { get; set; }
string Name { decimal Price { set; }
}
需要一个计算产品总价的帮助类,不过考虑到扩展性,先写一个计算产品总价的接口:
interface IValueCalculator
{
decimal ValueProducts(params Product[] products);
}
然后再写这个计算总价接口的实现类,用Linq方法实现:
class LinqValueCalculator : IValueCalculator
{
params Product[] products)
{
return products.Sum(p => p.Price);
}
}
最后在购物车类中,通过其构造函数把IValueCalculator注入进来:
class
ShoppingCart
{
private IValueCalculator calculator;
public ShoppingCart(IValueCalculator calc)
{
calculator =
calc;
}
decimal TotalValue()
{
Product[] products =
{
new Product(){Id =
1,Name =
"Product1",Price =
85M},2,0)">Product2
90M}
};
return calculator.ValueProducts(products);
}
}
使用NuGet安装Ninject,客户端调用时,首先要注册接口和实现类的依赖链,在需要用到接口的时候,再从DI容器中把这个接口取出来。
class
Program
{
static void Main(
string[] args)
{
IKernel ninjectKernel =
new StandardKernel();
ninjectKernel.Bind<IValueCalculator>().To<LinqValueCalculator>
();
IValueCalculator calculator = ninjectKernel.Get<IValueCalculator>
();
ShoppingCart cart =
new ShoppingCart(calculator);
Console.WriteLine(总价:{0}",cart.TotalValue());
Console.ReadKey();
}
}
结果显示:175
从中可以看到,我们只是把接口注入到ShoppingCart类中,在调用接口方法的时候,DI容器自动帮我们找到该接口的实现类并调用方法。
Ninject管理嵌套接口和实现类,自动执行接口实现类方法
需求:一个购物车类计算所有产品的总价,并打折
分析:计算所有产品总价的时候,ShoppingCart类依赖于计算总价的类,而但需要打折的时候,这个计算总价的实现类同样需要依赖于一个打折接口。无论依赖关系如何嵌套,我们只要把接口和实现类交给Ninject,其余事情Ninject轻松搞定。
打折的方式可能有很多种,这里也是一个扩展点,所以先打折接口:
interface IDiscountHelper
{
decimal ApplyDiscount(decimal total);
}
默认打9折:
class
DefaultDiscountHelper : IDiscountHelper
{
decimal total)
{
return (total - 10m/100m*
total);
}
}
计算总价的实现类,现在需要依赖于这个打折接口:
private
IDiscountHelper discounter;
public LinqValueCalculator(IDiscountHelper discountParam)
{
this.discounter =
discountParam;
}
return discounter.ApplyDiscount(products.Sum(p =>
p.Price));
}
}
客户端现在需要注册打折接口和实现类的关系:
new
StandardKernel();
ninjectKernel.Bind<IValueCalculator>().To<LinqValueCalculator>
();
ninjectKernel.Bind<IDiscountHelper>().To<DefaultDiscountHelper>
();
IValueCalculator calculator = ninjectKernel.Get<IValueCalculator>
();
ShoppingCart cart =
//175
Console.ReadKey();
}
}
结果显示:157.5
可见,一旦在Ninject中注册好所有的接口和实现类关系,在调用计算总价接口方法时,Ninject自动为我们找到计算总价的实现类,接着自动找到打折的实现类。
Ninject设置接口实现类属性值
需求:一个购物车类计算所有产品的总价,并打折,打折的金额可以动态设置
分析:打折实现类添加一个属性,Ninject注册接口和实现类的时候,给该属性赋初值
在打折接口实现类中添加一个属性:
decimal DiscountSize {
set; }
return (total - DiscountSize/100m*
total);
}
}
客户端应用程序中,在注册接口和实现类的时候为DiscountSize赋初值。
new
StandardKernel();
ninjectKernel.Bind<IValueCalculator>().To<LinqValueCalculator>
();
ninjectKernel.Bind<IDiscountHelper>().To<DefaultDiscountHelper>().WithPropertyValue(
DiscountSize();
ShoppingCart cart =
结果显示:87.5
Ninject设置接口实现类的构造参数值
依然是这样的需求:一个购物车类计算所有产品的总价,并打折,打折的金额可以动态设置
在打折接口实现类中添加构造函数和私有变量:
private
decimal discountRate;
public DefaultDiscountHelper(
decimal discountParam)
{
discountRate =
discountParam;
}
return (total - discountRate/100m*
total);
}
}
客户端应用程序中,在注册接口和实现类的时候为构造函数参数赋初值:
new
StandardKernel();
ninjectKernel.Bind<IValueCalculator>().To<LinqValueCalculator>
();
ninjectKernel.Bind<IDiscountHelper>
()
.To<DefaultDiscountHelper>
()
.WithConstructorArgument(discountParam
Ninject具体类的自身绑定
Ninject具体类的自身绑定,从文字上看,似乎有点不知所云。我们可以这样理解:
当Ninject注册接口和实现类的时候,我们可以通过IValueCalculator calculator = ninjectKernel.Get<IValueCalculator>()拿到接口。ShoppingCart正是依赖于IValueCalculator,虽然ShoppingCart不是接口类型,但是否可以通过某种设置,让我们也可以通过ShoppingCart cart = ninjectKernel.Get<ShoppingCart>()这种方式拿到ShoppingCart这个具体类的实例呢?
答案是:可以的。我们需要让ShoppingCart这个具体在Ninject实现自身绑定:
().ToSelf();
ShoppingCart cart = ninjectKernel.Get<ShoppingCart>
();
Console.WriteLine(
Ninject绑定基类和派生类,并设置派生类的属性值
新的需求是这样:一个购物车类计算所有产品的总价,并打折,打折的金额可以动态设置;给被计算产品的价格设置一个上限。
分析:可以把ShoppingCar设计为基类,并把其中计算总价的方法设计为virtual,在ShoppingCart的派生类中添加一个有关价格上限的属性,再重写ShoppingCart这个基类中的计算总价方法,把产品价格上限这个因素考虑进去。
把ShoppingCart作为基类,把计算总价的方法设置为virtual方法:
protected
IValueCalculator calculator;
protected Product[] products;
public ShoppingCart(IValueCalculator calc)
{
calculator =
calc;
products =
new[]
{
90M}
};
}
virtual decimal TotalValue()
{
ShoppingCart的派生类重写计算总价的方法并考虑价格上限:
class
LimitPriceShoppingCart : ShoppingCart
{
public LimitPriceShoppingCart(IValueCalculator calc) :
base(calc){}
override decimal TotalValue()
{
var filteredProducts = products.Where(e => e.Price <
PriceLimit);
return calculator.ValueProducts(filteredProducts.ToArray());
}
decimal PriceLimit {
set; }
}
基类和派生类注册到Ninject中,并为派生类的属性赋初始值:
PriceLimit
();
Console.WriteLine( 结果显示:42.5
Ninject条件绑定
即一个接口可以有多个实现,并使用Ninject的API规定在某些条件下使用某些接口的实现类。
比如,给计算价格的接口再添加一个通过遍历组合计算价格的类:
class
IterativeValueCalculator : IValueCalculator
{
decimal result =
0;
foreach (
var item
in products)
{
result +=
item.Price;
}
return result;
}
}
并规定注入到LimitPriceShoppingCart的时候使用这个计算总价的实现:
new
StandardKernel();
ninjectKernel.Bind<IValueCalculator>().To<LinqValueCalculator>
();
ninjectKernel.Bind<IValueCalculator>
()
.To<IterativeValueCalculator>
()
.WhenInjectedInto<LimitPriceShoppingCart>
();
ninjectKernel.Bind<IDiscountHelper>
()
.To<DefaultDiscountHelper>
()
.WithConstructorArgument( 结果显示:85
总结
Ninject这个DI容器,可以帮助我们管理接口和实现,基类和派生类,并提供了一些API,允许我们为接口的实现类或基类的派生类设置构造函数参数初始值、设置属性的初始值,甚至设置在某种条件使用特定的实现,即条件绑定。