依赖注入随写

    遵循接口分离原则是编写健壮可扩展程序的基本要求。软件的复杂性使用不断增加新层的方式解决，而层之间的耦合则依赖接口隔离的方式解决。

　　工厂模式是接口子类化的经典模式，工厂模式的实现方式，以前的随笔中已经详述过，故略去。这种子类化是一种主动式的子类化方法，调用者主动在需要的时候，进行子类化。而依赖注入模式则是一种被动式的子类化，其接口的子类化由调动者的调用者完成，如名字所述，其子类化的方式依靠反射功能实现注入，具体来分，又分为初始注入和属性赋值注入两种方式。在两种注入模式中，初始注入模式仅调用一次反射完成注入。

　　下面是一个简单的依赖注入框架：

   1.子类化接口与初始注入接口类：

    public interface IDependency {
        Object GetService(Type type);
    }

    public class DefaultDependency : IDependency {
        public object GetService(Type type) {
            if (type.GetConstructor(Type.EmptyTypes) != null) {
                return Activator.CreateInstance(type);
            }

            try {
                //just use the first constructor
                var cons = type.GetConstructors()[0];
                var paras = cons.GetParameters();
                var objs = new Object[paras.Length];
                for (int i = 0; i < paras.Length; i++) {
                    objs[i] = InstanceMap.CreateInstance(paras[i].ParameterType);
                }
                return cons.Invoke(objs);
            } catch(Exception ex){
                throw new InstanceInitException(ex);
            }
        }
    }

2.初始参数仓库

    public static class InstanceMap {
        public static Object CreateInstance(Type type) {
            foreach (var unit in units) {
                if (unit.InterfaceType == type) {
                    return unit.CreateInstance();
                }
            }
            return null;
        }

        public static void Config(Action<InstanceSetting> customConfig) {
            customConfig(innerSetting);
        }

        public static InstanceUnit For<InterfaceType>() {
            return For(typeof(InterfaceType));
        }

        public static InstanceUnit For(Type interfaceType) {
            foreach (var un in units) {
                if (un.InterfaceType == interfaceType) return un;
            }

            var unit = new InstanceUnit();
            unit.InterfaceType = interfaceType;

            units.AddLast(unit);
            return unit;
        }

        static LinkedList<InstanceUnit> units = new LinkedList<InstanceUnit>();
        static InstanceSetting innerSetting = new InstanceSetting();
    }

    public class InstanceUnit{
        internal InstanceUnit() {
            useSingleMode = false;
        }

        public Object CreateInstance() {
            if (useSingleMode) {
                if (singleInstance == null) {
                    if (instanceType == null) return null;
                    singleInstance = createInstance(instanceType, parameters);
                }
                return singleInstance;
            } else {
                if (instanceType == null) return null;
                else return createInstance(instanceType,parameters);
            }
        }

        public Type InterfaceType { get; set; }

        Object[] parameters { get; set; }
        Type instanceType { get; set; }
        Boolean useSingleMode { get; set; }
        Object singleInstance { get; set; }

        public InstanceUnit Reflect<InstanceType>() {
            return Reflect(typeof(InstanceType));
        }
        public InstanceUnit Reflect(Type type) {
            instanceType = type;
            return this;
        }

        public InstanceUnit ReflectSingle(Object singleInstance) {
            useSingleMode = true;
            singleInstance = singleInstance;
            return this;
        }
        public InstanceUnit ReflectSingle<InstanceType>() {
            useSingleMode = true;
            this.instanceType = typeof(InstanceType);
            return this;
        }

        public InstanceUnit Paras(params Object[] objs) {
            parameters = objs;
            return this;
        }

        static Object createInstance(Type type, Object[] paras) {
            var paraTypes = new Type[paras.Length];

            var i = 0;
            Array.ForEach(paras, value => {
                paraTypes[i] = value.GetType();
                i++;
            });

            var constructor = type.GetConstructor(paraTypes);
            try {
                return constructor.Invoke(paras);
            } catch {
                return null;
            }
        }
    }

    //for test
    public class InstanceSetting {
        public void AutoScanRegistedInstance() { }
        public void AllowScanAllAssemblies(){}
    }

3.使用方式

    class Program {
        static void Main(string[] args) {

            InstanceMap.Config(cfg => {
                cfg.AllowScanAllAssemblies();
            });
            InstanceMap.For<ITemp>().ReflectSingle<Temp>().Paras("wangjieas");
            ((new DefaultDependency()).GetService(typeof(TempUser)) as TempUser).Say();

            Console.Read();
        }
    }

    public interface IMessage {
        String Message { get; }
    }

    public class Message : IMessage {
        public Message(String str) {
            innerString = str;
        }

        string IMessage.Message {
            get { return innerString; }
        }

        String innerString;
    }

    public interface ITemp {
        String Message { get; }
    }

    public class Temp : ITemp {
        public Temp(String name) {
            this.name = name;
        }

        public string Message {
            get { return String.Format("Hello,{0}", name); }
        }

        String name;
    }


    public class TempUser {
        public TempUser(ITemp temp) {
            this.temp = temp;
        }

        public void Say() {
            Console.WriteLine(temp.Message);
        }

        ITemp temp;
    }

　　后记1：上面是一个简单的实现，仅仅用于测试。有兴趣的话，可以继续扩展。比如InstanceUnit中的Para,可以单独出来，分别对应配置文件项目和类attr值。DI经典的使用方式，自动化测试与mvc模式。

      后记2：DI是spring框架的拿手好戏，最新的asp.net mvc框架也加入了这一层，它在带来简便性的同时也引入了复杂性，两层反射模式的使用必定会对性能带来损耗。所以，请时刻秉持简单易用的原则，谨慎的选择合适的方式来组织代码。