通过接口调用接口实现类实现松耦合（接口的多态）

项目开发在各个层中通过接口实现松耦合的时候，如何实现接口调用接口实现类？

这里的要求是接口有多个实现类，通过接口调用不的接口实现类！

      开始，我想到了IOC（IOC最近忒火），确实有很多开发好的类库unity，ninject等等，但是这些类库都有点太强大了，例

如unity 是可以很容易实现我的要求，那么通过RegisterType<I, N>>(String name)注册；通过Resolve<I>(name) 就可以

用接口调用相应的接口实现类，如果想了解一下unity，

http://www.cnblogs.com/scy251147/archive/2012/11/21/2781328.html的文章不错！

     但是我想要的也就这点功能，所以就没有必要引入第三方库，自己实现一下IOC【其实，我对IOC理解比较肤浅，我的理解就是同

一接口调用接口的不同实现类（多态），所以下面不敢用IOC命名】，我这里定义为ServiceFactory类，另一个帮助类ServiceKey；

接口IOrderService和实现IOrderService接口的OrderService类OrderService2类。

    /// <summary>
    /// 根据服务接口创建服务类工厂
    /// </summary>
    public class ServiceFactory
    {
        
        /// <summary>
        /// 容器（唯一键，服务标志）
        /// </summary>
        private static Dictionary<String, RuntimeTypeHandle> container;
      
        /// <summary>
        /// 静态构造函数（注册接口）
        /// </summary>
        static ServiceFactory()
        {
            container = new Dictionary<String, RuntimeTypeHandle>();

            RegisterType<IOrderService, OrderService>();
            RegisterType<IOrderService, OrderService2>(ServiceKey.Second);/*同一接口，多个实现类*/
        }

        /// <summary>
        /// 注册对应服务接口和服务类型
        /// </summary>
        /// <typeparam name="I">服务接口</typeparam>
        /// <typeparam name="T">服务类型</typeparam>
        /// <param name="Key">服务的key</param>
        private static void RegisterType<I, T>(ServiceKey Key = ServiceKey.First)
            where I : class
            where T : class
        {
            String name = typeof(I).FullName;
            name += ((Int32)Key).ToString();
            container.Add(name, typeof(T).TypeHandle);
        }

        /// <summary>
        /// 根据服务接口创建服务类型
        /// </summary>
        /// <typeparam name="I">服务接口类型</typeparam>
        /// <param name="Key">服务的key（默认ServiceKey.First，用于同一接口，多个实现类）</param>
        /// <returns>服务类型实例</returns>
        public static I Create<I>(ServiceKey Key = ServiceKey.First) where I : class
        {
            Type newType = Type.GetTypeFromHandle(container[typeof(I).FullName + ((Int32)Key).ToString()]);
            return System.Activator.CreateInstance(newType) as I;
        }  
    }

    /// <summary>
    /// 服务的key(用于根据服务接口创建服务类，特别同一接口，多个实现类)
    /// </summary>
    public enum ServiceKey
    {
        First = 1,
        Second = 2,
        Third = 3,
        Fourth = 4,
        Fifth = 5,
        Sixth = 6,
        Seventh = 7,
        Eighth = 8,
        Ninth = 9
    }

    public interface IOrderService
    {
        String Test();
    }

    class OrderService : IOrderService
    {

        private String info = "OrderService";
        public OrderService()
        {
            info += DateTime.Now.ToString();
        }
        public String Test()
        {
            return info;
        }
    }

    class OrderService2 : IOrderService
    {
        private String info = "OrderService2";
        public OrderService2()
        {
            info += DateTime.Now.ToString();
        }
        public String Test()
        {
            return info;
        }
    }

1、RegisterType方法：添加接口和对应的实现类的标志（RuntimeTypeHandle 是类型唯一的抽象标志）到字典容器container中

2、Create方法：根据接口创建接口类型的实例，【这里接口就关联上了接口实现类】，保证在调用前都有注册接口，所以所有的注册

接口都放在静态构造函数中

3、参数ServiceKey为接口实现类的唯一键，通过接口的FullName+ServiceKey就可以唯一标示，接口有多个实现类的时候是关键

4、单元测试

        [TestMethod]
        public void TestServiceFactory()
        {
            var t11 = ServiceFactory.Create<IOrderService>().Test();
            var t12 = ServiceFactory.Create<IOrderService>().Test();
            var t13 = ServiceFactory.Create<IOrderService>().Test();
            var t21 = ServiceFactory.Create<IOrderService>(ServiceKey.Second).Test();
            var t22 = ServiceFactory.Create<IOrderService>(ServiceKey.Second).Test();
        }
   

这里，我们手动来维护接口和实现类的关联，大大增加了灵活性和项目的自主控制力，同时也实现了接口多态和解耦！