标签：
首先，我不是一个开发者，只是业余学习者。其次我的文化水平很低，写这个主要是记录一下当前对于这块的理解，因为对于一个低水平 的业余学习者来说，忘记是很平常的事，因为接触、应用的少，现在理解，可能过段时间就会忘了，自己记录下来应该可以少走些弯路，以免从头再来查找资料。
另外，如果我的记录能帮忙到一些朋友的话，也难免会有些小满足的。学习的门槛除了理解能力，绝大部分来自于英文水平和专业术语，我希望的是我能用比较通俗易懂的表达，获得大家的理解，更希望大牛们是如是做的，所以写这个更希望的是能得到大牛的帮助。
下面是我对依赖注入在应用场景的理解
从框架设计方面 你希望的是你设计的架构能有不同的技术（或者叫第三方组件）实现，你只需要通过在固定地方修改极少的代码便可以。
来个例子吧，假如现在有两个不同的技术，当然它们应该是在不同的程序集中的，只是为了方便把它们放在一起
/// <summary> /// 第三方组件A /// </summary> public class ModuleA { public void Say() { Console.WriteLine("it is ModuleA"); } } /// <summary> /// 第三方组件B /// </summary> public class ModuleB { public void Say() { Console.WriteLine("it is ModuleB"); } }
你希望你能应用任意其中一个，并且可以随意更改。你可以对外抽象出一个约束接口或者抽象类，下面我用的是接口,你可以在你的设计中，通过构造函数来引用
/// <summary> /// 接口 /// </summary> public interface IInterface { void Say();//接口约束必须实现这个方法 } public class BaseStyle { private IInterface module;//你并不知道也不关心当前用的是哪个组件，只要组件能实现这个接口就行 public BaseStyle(IInterface module)//能过构造函数引用接口 { this.module = module; } public void Say() { module.Say(); } }
通过属性引用
/// <summary>
/// 通过属性引用组件方式
/// </summary>
public class BaseStyle
{
public IInterface Module { get; set; }
public void Say()
{
Module.Say();
}
}
当你要应用任意一个组件时，只须要让它实现接口
public class ModuleA : IInterface
{
public void Say()
{
Console.WriteLine("it is ModuleA");
}
}
这样就把BaseStyle类的Say方法分离出来，通过接口的实现类来完成。相当于接口的实现类可以是任意类。这便是传说中的接口分离，低藕合思想。例子不需要大，理解才是最重要。往大了说，这就相当于是面向接口编程。这是架构设计方面 。
然后就是应用了，也就是注入工作，Autofac之类的依赖注入组件不是必须的，只是当你的程序大了，用这些封装好的组件会更方便，易维护。你可以new BaseStyle然后传入对就的参数或设置属性就行了。
我一般用的是Autofac,用autofac，代码应该 是这样的
class Program
{
static void Main(string[] args)
{
ContainerBuilder builder = new ContainerBuilder();
builder.Register(o => new BaseStyle(o.Resolve<IInterface>()));//实例注入
builder.RegisterType<ModuleA>().As<IInterface>(); //类型注入
using (var container = builder.Build())
{
BaseStyle bs = container.Resolve<BaseStyle>();
bs.Say();
}
Console.ReadKey();
}
当然这样用肯定是没必要用autofac的，当有很多类须要用到Autofac注入时，这样并不会减少代码量，当要修改时，每个地方都要修改，如果只对Autofac停留在这个层面，还是不必要用它的好。
我比较喜欢的是封装一个Container类，由于我一惯喜欢用强类型，所以没有试过通过配置文件来配置。可能是因为我没有接触到真实项目的原因吧
封装一个类
public class ServiceContainer
{
private ServiceContainer() { }//不对外提供构造函数
private static IContainer container;
/// <summary>
/// 初始化container
/// </summary>
/// <param name="action"></param>
public static void Initialize(Action<ContainerBuilder> action)
{
if(action!=null)
{
ContainerBuilder builder = new ContainerBuilder();
action(builder);
container = builder.Build();
}
}
/// <summary>
/// 封装一个不带参数的IContainer的方法
/// </summary>
/// <typeparam name="Tservice"></typeparam>
/// <returns>返回一个注入的服务类实例</returns>
public static Tservice Resolve<Tservice>()
{
ThrowIfNotInitialized(); //检测容器是否初始化
return container.Resolve<Tservice>();
}
//此处省略其它IContainer方法的封装
/// <summary>
/// 检测容器是否初始化
/// </summary>
private static void ThrowIfNotInitialized()
{
if (container == null)
throw new InvalidOperationException("请先初始化容器,调用Initialize()方法");
}
}
通过个类提供的静态初始化方法，可以在应用程序开始处，将所有要注入的依赖注入到容器中，然后你可以在程序的任意地方通过静态方法Resolve<T>方法从容器中取得你想要的具体依赖。这里我只封装了一个方法，还可以封装更多的静态方法，灵活调用。
最后再传上测试的所有代码。这里我抽象出了一些基类，设置好依赖注入，方便客户端调用时不需要传入参数或是设置属性，个人感觉应该比较完美了
using System; using Autofac; namespace AutofacDemo { class Program { static void Main(string[] args) { ServiceContainer.Initialize(o => { o.RegisterType<ModuleA>().As<IInterface>(); //o.RegisterType<ModuleB>().As<IInterface>();需要用其它实现时，只须要修改传入对应的类型 }); StyleA a = new StyleA();//纯净的客户端调用 StyleB b = new StyleB(); a.Say(); b.Say(); #region 基本注入 //ServiceContainer.Initialize(o => // { // o.RegisterType<ModuleA>().As<IInterface>(); // }); //StyleA a = new StyleA(ServiceContainer.Resolve<IInterface>()); //StyleB b = new StyleB(); //b.Module = ServiceContainer.Resolve<IInterface>(); //a.Say(); //b.Say(); #endregion #region 实例注入、属性注入 //ServiceContainer.Initialize(o => //{ // o.Register(c => new StyleA(c.Resolve<IInterface>())); //实例注入 // o.Register(c => new StyleB { Module = c.Resolve<IInterface>() });//属性注入 // o.RegisterType<ModuleA>().As<IInterface>(); //}); //StyleA a = ServiceContainer.Resolve<StyleA>(); //StyleB b = ServiceContainer.Resolve<StyleB>(); //a.Say(); b.Say(); #endregion Console.ReadKey(); } } /// <summary> /// 接口 /// </summary> public interface IInterface { void Say(); } /// <summary> /// 接口的某个实现类A，通常相当于第三方组件 /// </summary> public class ModuleA : IInterface { public void Say() { Console.WriteLine("it is ModuleA"); } } /// <summary> /// 接口的某个实现类B，通常相当于第三方组件 /// </summary> public class ModuleB : IInterface { public void Say() { Console.WriteLine("it is ModuleB"); } } public class BaseStyle { private IInterface module; public BaseStyle(IInterface module) { this.module = module; } public void Say() { module.Say(); } } /// <summary> /// 基类通过构造函数引用组件方式 /// </summary> public abstract class BaseStyleA { private IInterface module; protected BaseStyleA(IInterface module) { this.module = module; } public void Say() { module.Say(); } } /// <summary> /// 基类通过属性引用组件方式 /// </summary> public abstract class BaseStyleB { public virtual IInterface Module { get; set; } public void Say() { Module.Say(); } } public class StyleA:BaseStyleA { public StyleA(IInterface module) : base(module) { } public StyleA() : base(ServiceContainer.Resolve<IInterface>())//方便客户端调用时不需要传参 { } } public class StyleB:BaseStyleB { public override IInterface Module { get { return ServiceContainer.Resolve<IInterface>();//方便客户端调用时不需要设置属性 } } } }
标签：
原文地址：http://www.cnblogs.com/yuzeyong/p/5347717.html
