///
    /// 工厂接口定义
    ///
    ///
    ///     TTarget : abstract product type
    ///     TSource:  concrete product type
    ///
    public interface IFactory
    {
        #region config and register type mapping

        ///
        /// 如果需要同时加载配置文件中定义的映射关系，可以按照SRP的原则定义独立的配置类型。
        /// 由该配置类型调用这两个接口为Factory加载配置信息
        ///

        IFactory RegisterType();  // fluent interface
        IFactory RegisterType(string name);   // fluent interface

        #endregion

        #region factory method

        TTarget Create();
        TTarget Create(string name);

        #endregion
    }

public sealed class TypeRegistry
    {
        readonly string DefaultNmae = Guid.NewGuid().ToString();
        IDictionary registry = new Dictionary();
        public void RegisterType(Type targetType,Type sourceType)
        {
            RegisterType(targetType, sourceType, DefaultNmae);
        }
        public void RegisterType(Type targetType, Type sourceType,string name)
        {
            if (targetType == null) throw new ArgumentNullException("targetType");
            if (sourceType == null) throw new ArgumentNullException("sourceType");
            if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name");
            IDictionary subDictionary;

            if (!registry.TryGetValue(targetType, out subDictionary))
            {
                subDictionary = new Dictionary();
                subDictionary.Add(name, sourceType);
                registry.Add(targetType, subDictionary);
            }
            else
            {
                if (subDictionary.ContainsKey(name))
                    throw new DuplicateKeyException(name);
                subDictionary.Add(name, sourceType);
            }
        }
        public Type this[Type targetType, string name]
        {
            get
            {
                if (targetType == null) throw new ArgumentNullException("targetType");
                if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name");
                if (registry.Count() == 0)
                    return null;

                return (registry
                    .Where(x => x.Key == targetType)).FirstOrDefault().Value
                    .Where(x => string.Equals(name, x.Key))
                        .FirstOrDefault().Value;
            }
        }

        public Type this[Type targetType]
        {
            get { return this[targetType, DefaultNmae]; }
        }

    }

public class Factory : IFactory
    {
        protected TypeRegistry registry = new TypeRegistry();

        #region IFactory Members

        public IFactory RegisterType()
        {
            registry.RegisterType(typeof(TTarget), typeof(TSource));
            return this;
        }

        public IFactory RegisterType(string name)
        {
            registry.RegisterType(typeof(TTarget), typeof(TSource), name);
            return this;
        }

        public TTarget Create()
        {
            return (TTarget)Activator.CreateInstance(registry[typeof(TTarget)]);
        }

        public TTarget Create(string name)
        {
            return (TTarget)Activator.CreateInstance(registry[typeof(TTarget), name]);
        }

        #endregion
    }

[TestMethod]
        public void CreateInstance()
        {
            var factory = new Factory()
                .RegisterType()
                .RegisterType("o")
                .RegisterType()
                .RegisterType("a")
                .RegisterType("b")
                .RegisterType("c");

            Assert.IsInstanceOfType(factory.Create(), typeof(Apple));
            Assert.IsInstanceOfType(factory.Create("o"), typeof (Orange));

            Assert.IsInstanceOfType(factory.Create(), typeof(Bicycle));
            Assert.IsInstanceOfType(factory.Create("a"), typeof(Bicycle));
            Assert.IsInstanceOfType(factory.Create("b"), typeof(Train));
            Assert.IsInstanceOfType(factory.Create("c"), typeof(Car));
        }