GoF工厂的命名约定

问题答案

好，这个问题从抽象工厂的命名问题开始。作为一个经验法则，总是使用"正式的"名称(例如Factory, Decorator等)和具体实现的描述(例如Snickers, Mars, MotifWidget等)。

基本上，你创建了一个MSSQLConnection，这是你要描述的具体的东西，Factory，这意味着它遵循工厂模式的特征。

好的，到目前为止命名和最初的问题。现在来看一些很酷的东西。讨论的是在c#中实现抽象工厂的最佳方式，这是一个不同的主题。我在用c#实现所有设计模式方面做了相当多的工作，为此我将在这里分享一些关于工厂的细节。是:

抽象工厂和工厂

抽象工厂基本上是基类或接口与具体实现的组合。如果你需要共享大量代码，基类就是你需要的;如果你不需要，接口就是你需要的。

我通常区分"工厂"answers"抽象工厂"。工厂是一个创建对象(特定类型)的东西，一个"抽象工厂"是一个创建任意类型对象的东西。因此，抽象工厂的实现就是工厂。这与下一条信息有关。

工厂模式

支持RTTI的语言能够实现工厂模式。工厂模式是用来创建对象的。最简单的实现是一个只包含创建对象的方法的类，例如:

// ...
public void CreateConnection()
{
    return new SqlConnection();
}
// ...

你通常用它来抽象事物。例如，HTML解析器中生成XML节点的部分基于HTML标记创建特定类型的节点。

工厂通常根据运行时信息做出决策。因此，可以将工厂模式一般化以实现如下内容:

public T Create(string name) 
{
    // lookup constructor, invoke.
}

使用RTTI创建通用工厂模式非常容易，该模式为每个名称存储一个Type。查找名称，使用反射创建对象。做。

哦，作为奖励，你必须编写比手工制作所有工厂更少的代码。因为所有的实现都是相同的，所以您不妨将它放在基类中，并在静态构造函数中填充Dictionary。

泛化抽象工厂

抽象工厂基本上是工厂的集合，它们以与工厂模式相同的方式创建对象。唯一共享的是接口(例如，创建，或者你可以使用继承来创建抽象)。

实现非常简单，所以我就把它放在这里。

解耦工厂和类型

让我们回到GoF的例子。他们谈论MotifFactory和PMFactory。在未来，我们将遇到另一个UI的东西，我们需要一个ASPNETFactory或SilverlightFactory。然而，未来是未知的，如果我们不需要，我们宁愿不发布旧的DLL——毕竟，这是不灵活的。

如果要向工厂添加新方法，就会出现第二个问题。因此，这样做将涉及改变所有工厂。您可能已经猜到了，我不想在多个地方更改它。

幸运的是，我们可以解决这两个问题。接口是相同的(甚至可以一般化)，因此我们可以在运行时简单地向工厂添加新特性。

不是告诉工厂要创建什么对象，我们可以使用一个属性告诉类它应该由一个特定的工厂实现。我们还可以在装配加载期间扫描所有类型，因此，如果装配加载，我们可以简单地在运行中建立新工厂。

我为此牺牲的是编译时检查，但由于工厂模式通常使用运行时信息，这并不一定是个问题。下面是我的Factory的代码:

/// <summary>
/// This attribute is used to tag classes, enabling them to be constructed by a Factory class. See the <see cref="Factory{Key,Intf}"/> 
/// class for details.
/// </summary>
/// <remarks>
/// <para>
/// It is okay to mark classes with multiple FactoryClass attributes, even when using different keys or different factories.
/// </para>
/// </remarks>
/// <seealso cref="Factory{Key,Intf}"/>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
public class FactoryClassAttribute : Attribute
{
    /// <summary>
    /// This marks a class as eligible for construction by the specified factory type.
    /// </summary>
    /// <example>
    /// [FactoryClass("ScrollBar", typeof(MotifFactory))]
    /// public class MotifScrollBar : IControl { }
    /// </example>
    /// <param name="key">The key used to construct the object</param>
    /// <param name="factoryType">The type of the factory class</param>
    public FactoryClassAttribute(object key, Type factoryType)
    {
        if ((factoryType.IsGenericType &&
             factoryType.GetGenericTypeDefinition() == typeof(Factory<,>)) ||
            factoryType.IsAbstract || 
            factoryType.IsInterface)
        {
            throw new NotSupportedException("Incorrect factory type: you cannot use GenericFactory or an abstract type as factory.");
        }
        this.Key = key;
        this.FactoryType = factoryType;
    }
    /// <summary>
    /// The key used to construct the object when calling the <see cref="Factory{Key,Intf}.Create(Key)"/> method.
    /// </summary>
    public object Key { get; private set; }
    /// <summary>
    /// The type of the factory class
    /// </summary>
    public Type FactoryType { get; private set; }
}
/// <summary>
/// Provides an interface for creating related or dependent objects.
/// </summary>
/// <remarks>
/// <para>
/// This class is an implementation of the Factory pattern. Your factory class should inherit this Factory class and 
/// you should use the [<see cref="FactoryClassAttribute"/>] attribute on the objects that are created by the factory.
/// The implementation assumes all created objects share the same constructor signature (which is not checked by the Factory). 
/// All implementations also share the same <typeparamref name="Intf"/> type and are stored by key. During runtime, you can 
/// use the Factory class implementation to build objects of the correct type.
/// </para>
/// <para>
/// The Abstract Factory pattern can be implemented by adding a base Factory class with multiple factory classes that inherit from 
/// the base class and are used for registration. (See below for a complete code example).
/// </para>
/// <para>
/// Implementation of the Strategy pattern can be done by using the Factory pattern and making the <typeparamref name="Intf"/>
/// implementations algorithms. When using the Strategy pattern, you still need to have some logic that picks when to use which key.
/// In some cases it can be useful to use the Factory overload with the type conversion to map keys on other keys. When implementing 
/// the strategy pattern, it is possible to use this overload to determine which algorithm to use.
/// </para>
/// </remarks>
/// <typeparam name="Key">The type of the key to use for looking up the correct object type</typeparam>
/// <typeparam name="Intf">The base interface that all classes created by the Factory share</typeparam>
/// <remarks>
/// The factory class automatically hooks to all loaded assemblies by the current AppDomain. All classes tagged with the FactoryClass
/// are automatically registered.
/// </remarks>
/// <example>
/// <code lang="c#">
/// // Create the scrollbar and register it to the factory of the Motif system
/// [FactoryClass("ScrollBar", typeof(MotifFactory))]
/// public class MotifScrollBar : IControl { }
/// 
/// // [...] add other classes tagged with the FactoryClass attribute here...
///
/// public abstract class WidgetFactory : Factory&lt;string, IControl&gt;
/// {
///     public IControl CreateScrollBar() { return Create("ScrollBar") as IScrollBar; }
/// }
///
/// public class MotifFactory : WidgetFactory { }
/// public class PMFactory : WidgetFactory { }
///
/// // [...] use the factory to create a scrollbar
/// 
/// WidgetFactory widgetFactory = new MotifFactory();
/// var scrollbar = widgetFactory.CreateScrollBar(); // this is a MotifScrollbar intance
/// </code>
/// </example>
public abstract class Factory<Key, Intf> : IFactory<Key, Intf>
    where Intf : class
{
    /// <summary>
    /// Creates a factory by mapping the keys of the create method to the keys in the FactoryClass attributes.
    /// </summary>
    protected Factory() : this((a) => (a)) { }
    /// <summary>
    /// Creates a factory by using a custom mapping function that defines the mapping of keys from the Create 
    /// method, to the keys in the FactoryClass attributes.
    /// </summary>
    /// <param name="typeConversion">A function that maps keys passed to <see cref="Create(Key)"/> to keys used with [<see cref="FactoryClassAttribute"/>]</param>
    protected Factory(Func<Key, object> typeConversion)
    {
        this.typeConversion = typeConversion;
    }
    private Func<Key, object> typeConversion;
    private static object lockObject = new object();
    private static Dictionary<Type, Dictionary<object, Type>> dict = null;
    /// <summary>
    /// Creates an instance a class registered with the <see cref="FactoryClassAttribute"/> attribute by looking up the key.
    /// </summary>
    /// <param name="key">The key used to lookup the attribute. The key is first converted using the typeConversion function passed 
    /// to the constructor if this was defined.</param>
    /// <returns>An instance of the factory class</returns>
    public virtual Intf Create(Key key)
    {
        Dictionary<Type, Dictionary<object, Type>> dict = Init();
        Dictionary<object, Type> factoryDict;
        if (dict.TryGetValue(this.GetType(), out factoryDict))
        {
            Type t;
            return (factoryDict.TryGetValue(typeConversion(key), out t)) ? (Intf)Activator.CreateInstance(t) : null;
        }
        return null;
    }
    /// <summary>
    /// Creates an instance a class registered with the <see cref="FactoryClassAttribute"/> attribute by looking up the key.
    /// </summary>
    /// <param name="key">The key used to lookup the attribute. The key is first converted using the typeConversion function passed 
    /// to the constructor if this was defined.</param>
    /// <param name="constructorParameters">Additional parameters that have to be passed to the constructor</param>
    /// <returns>An instance of the factory class</returns>
    public virtual Intf Create(Key key, params object[] constructorParameters)
    {
        Dictionary<Type, Dictionary<object, Type>> dict = Init();
        Dictionary<object, Type> factoryDict;
        if (dict.TryGetValue(this.GetType(), out factoryDict))
        {
            Type t;
            return (factoryDict.TryGetValue(typeConversion(key), out t)) ? (Intf)Activator.CreateInstance(t, constructorParameters) : null;
        }
        return null;
    }
    /// <summary>
    /// Enumerates all registered attribute keys. No transformation is done here.
    /// </summary>
    /// <returns>All keys currently known to this factory</returns>
    public virtual IEnumerable<Key> EnumerateKeys()
    {
        Dictionary<Type, Dictionary<object, Type>> dict = Init();
        Dictionary<object, Type> factoryDict;
        if (dict.TryGetValue(this.GetType(), out factoryDict))
        {
            foreach (object key in factoryDict.Keys)
            {
                yield return (Key)key;
            }
        }
    }
    private void TryHook()
    {
        AppDomain.CurrentDomain.AssemblyLoad += new AssemblyLoadEventHandler(NewAssemblyLoaded);
    }
    private Dictionary<Type, Dictionary<object, Type>> Init()
    {
        Dictionary<Type, Dictionary<object, Type>> d = dict;
        if (d == null)
        {
            lock (lockObject)
            {
                if (dict == null)
                {
                    try
                    {
                        TryHook();
                    }
                    catch (Exception) { } // Not available in this security mode. You're probably using shared hosting
                    ScanTypes();
                }
                d = dict;
            }
        }
        return d;
    }
    private void ScanTypes()
    {
        Dictionary<Type, Dictionary<object, Type>> classDict = new Dictionary<Type, Dictionary<object, Type>>();
        foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
        {
            AddAssemblyTypes(classDict, ass);
        }
        dict = classDict;
    }
    private void AddAssemblyTypes(Dictionary<Type, Dictionary<object, Type>> classDict, Assembly ass)
    {
        try
        {
            foreach (Type t in ass.GetTypes())
            {
                if (t.IsClass && !t.IsAbstract &&
                    typeof(Intf).IsAssignableFrom(t))
                {
                    object[] fca = t.GetCustomAttributes(typeof(FactoryClassAttribute), false);
                    foreach (FactoryClassAttribute f in fca)
                    {
                        if (!(f.Key is Key))
                        {
                            throw new InvalidCastException(string.Format("Cannot cast key of factory object {0} to {1}", t.FullName, typeof(Key).FullName));
                        }
                        Dictionary<object, Type> keyDict;
                        if (!classDict.TryGetValue(f.FactoryType, out keyDict))
                        {
                            keyDict = new Dictionary<object, Type>();
                            classDict.Add(f.FactoryType, keyDict);
                        }
                        keyDict.Add(f.Key, t);
                    }
                }
            }
        }
        catch (ReflectionTypeLoadException) { } // An assembly we cannot process. That also means we cannot use it.
    }
    private void NewAssemblyLoaded(object sender, AssemblyLoadEventArgs args)
    {
        lock (lockObject)
        {
            // Make sure new 'create' invokes wait till we're done updating the factory
            Dictionary<Type, Dictionary<object, Type>> classDict = new Dictionary<Type, Dictionary<object, Type>>(dict);
            dict = null;
            Thread.MemoryBarrier();
            AddAssemblyTypes(classDict, args.LoadedAssembly);
            dict = classDict;
        }
    }
}

我不知道这里有什么惯例，但我认为这在很大程度上取决于情况。我只在依赖注入场景中使用AbstractFactory，在这些场景中，我希望在运行时创建类型，并且必须提供抽象。

1. "抽象"部分可以是接口->约定为IName
2. 你的基类应该描述一个关于它的实现的"共同"的事情，信息存在于上下文中:如果在你的上下文中，一个巧克力工厂可能是一个"抽象"的概念，实现(应该描述具体的事情(MyChocolateFactory不是一个好名字))应该显示他们(is)的关系，但也具体的用例。
3. 关于你的评论:如果不需要任何其他工厂实现，只是为了将来可能的用例，不要使用抽象工厂;)

您可以这样使用:

// general interface for abstract factory (this is optional)
public abstract class AbstractFactory { };
// interface that uses a type of factory and produce abstract product
public abstract class AbstractChocolateFactory : AbstractFactory  { };
// family of concrete factories that produce concrete products
public class NestleChocolateFactory { } : AbstractChocolateFactory 
public class SwissChocolateFactory { } : AbstractChocolateFactory 

这只是一个想法，但是使用抽象工厂模式的实现完全取决于你的具体任务。