模式：工程化实现及扩展——工厂模式

/// <summary>
/// 工厂接口定义
/// </summary>
/// <remarks>
/// TTarget: 抽象产品类型
/// TSource: 具体产品类型
/// </remarks>
public interface IFactory
{
    #region config and register type mapping

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

    IFactory RegisterType<TTarget, TSource>();  // 注入产品
    IFactory RegisterType<TTarget, TSource>(string name);   // 注入产品

    #endregion

    #region factory method

    TTarget Create<TTarget>();
    TTarget Create<TTarget>(string name);

    #endregion
}

/// <summary>
/// 充当 依赖注入 的角色
/// </summary>
public sealed class TypeRegistry
{
    /// <summary>
    /// default name in type mappings
    /// </summary>
    readonly string DefaultName = Guid.NewGuid().ToString();

    /// <summary>
    /// Type        :   TTarget, 抽象产品类型
    /// IDictionary<string ,Type>
    ///     string  :   name
    ///     Type    :   TSource, 具体产品类型
    /// </summary>
    IDictionary<Type, IDictionary<string, Type>> registry =
        new Dictionary<Type, IDictionary<string, Type>>();

    public void RegisterType(Type targetType, Type sourceType)
    {
        RegisterType(targetType, sourceType, DefaultName);
    }

    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");

        if (!registry.TryGetValue(targetType, out IDictionary<string, Type> subDictionary))
        {
            subDictionary = new Dictionary<string, Type>
            {
                { name, sourceType }
            };
            registry.Add(targetType, subDictionary);
        }
        else
        {
            if (subDictionary.ContainsKey(name))
                throw new Exception($"{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, DefaultName]; }
    }
}

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

    #region IFactory Members

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

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

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

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

    #endregion
}