【问题标题】:Can I use Attributes so my Factory knows what it can/should instantiate without breaking the "Loosely-Coupled" rule?我可以使用属性让我的工厂知道它可以/应该实例化什么而不违反“松耦合”规则吗?
【发布时间】:2015-11-13 06:16:08
【问题描述】:

我在我的项目中实现了一个工厂,最近有人建议我在我的类上使用属性,以便工厂可以确定要实例化哪个类并传回。我是开发世界的新手,并试图严格遵循松散耦合规则,我想知道依赖“钩子”(作为属性)是否违背了这一点?

【问题讨论】:

  • 请提供更多细节。(例如一些代码)
  • 您能否提供一个建议实施的示例?

标签: c# factory-pattern


【解决方案1】:

装饰工厂的产品类可以使开发变得更加容易,这是我有时会做的事情。例如,当必须基于存储在数据库中的唯一标识符创建产品时,这尤其有用。该唯一 id 和产品类别之间必须存在映射,并且使用属性可以使这一点变得非常清晰和可重复。除此之外,它还允许您添加产品类,而无需更改工厂。

例如,你可以这样装饰你的班级:

[ProductAttribute(1)]
public class MyFirstProduct : IProduct
{
}

[ProductAttribute(2)]
public class MySecondProduct : IProduct
{
}

你可以像这样实现你的工厂:

public class ProductFactory : IProductFactory
{
    private static Dictionary<int, Type> products =
        new Dictionary<int, Type>();

    static ProductFactory()
    {
        // Please note that this query is a bit simplistic. It doesn't
        // handle error reporting.
        var productsWithId =
          from type in 
              Assembly.GetExecutingAssembly().GetTypes()
          where typeof(IProduct).IsAssignableFrom(type)
          where !type.IsAbstract && !type.IsInterface
          let attributes = type.GetCustomAttributes(
            typeof(ProductAttribute), false)
          let attribute = attributes[0] as ProductAttribute
          select new { type, attribute.Id };

        products = productsWithId
            .ToDictionary(p => p.Id, p => p.type);
    }

    public IProduct CreateInstanceById(int id)
    {
        Type productType = products[id];

        return Activator.CreateInstance(productType) as IProduct;
    }
}

完成此操作后,您可以使用该工厂来创建如下产品:

private IProductFactory factory;

public void SellProducts(IEnumerable<int> productIds)
{
    IEnumerable<IProduct> products =
        from productId in productIds
        select factory.CreateInstanceById(productId);

    foreach (var product in products)
    {
        product.Sell();
    }
}

我过去曾使用此概念来创建基于数据库标识符的发票计算。该数据库包含每种发票类型的计算列表。实际计算是在 C# 类中定义的。

【讨论】:

  • 谢谢。这是我所做的大部分工作。我只是挂断了使用属性是否会更紧密地“耦合”我的应用程序。我很欣赏这个很好的例子。
  • 我同意 tvanfossen,它降低了耦合度。除此之外,它允许真正的单一职责,因为在添加新产品时,您无需更改任何其他代码。
【解决方案2】:

我不认为使用属性会增加工厂和它创建的类之间的耦合,事实上,它会减少这里的耦合,因为工厂会在运行时通过属性发现信息。如果有的话,您只是在为与属性耦合而创建的类之间的耦合进行交易。就是说,我不确定这到底能给你带来什么。工厂的重点是您将创建逻辑本地化在一个地方。通过将其放入属性中,您再次将其传播到您的代码中,部分违背了工厂的目的:现在您必须同时查看工厂 和 属性以了解对象的状态已创建。

当然,我可能误解了你的问题。您可能意味着一个类使用其属性上的属性来指示哪些属性需要由工厂实例化。在这种情况下,您将替换一些配置驱动的机制来进行依赖注入。我当然可以看到这可能有用的地方;让工厂发现对象的依赖关系并在运行时自动创建它们。在这种情况下,您将稍微增加代码的整体耦合,因为现在属性和工厂之间存在以前不存在的依赖关系。总体而言,尽管您可能会降低代码复杂性,因为您无需为每个类提供特定代码即可提供其特定依赖项或从配置文件中发现它们。

如果您问使用属性是否是一个好主意,我认为我们可能需要更多信息,但由于您似乎只是在问您是否会违反 OO 原则,所以我不这么认为。我没有看到它增加了工厂和正在创建的类之间的耦合,只是略微增加了代码的整体耦合。无论如何,工厂就其本质而言,需要比其他类更多的耦合。请记住,它是松耦合,而不是非耦合。 解耦代码不做任何事情。您需要类之间的关系才能使任何事情发生。

【讨论】:

  • 看我的回答。我过去用过这个。在答案中,我描述了一种方法及其用途。我认为这就是 OP 正在寻找的。 (顺便说一句。很好的答案。+1)。
  • 我只在类级别使用该属性,以便我可以减少我的工厂以迭代我的应用程序中的自定义属性,并基于传递给 Factory.CreateInstance(Prop) 的属性返回正确的实例或错误。通过这个,我消除了工厂中额外的逻辑代码。
【解决方案3】:

这是我用来根据属性值创建具体实例的工厂实现。它还使用参数进行实例化。

class ViewFactory
{
    public static IView GetViewType(string PropertyValue, SomeOtherObject parentControl){
    Assembly assembly = Assembly.GetAssembly(typeof(ViewFactory));
    var types = from type in assembly.GetTypes()
                where Attribute.IsDefined(type,typeof(ViewTypeAttribute))
                select type;

    var objectType = types.Select(p => p).
        Where(t => t.GetCustomAttributes(typeof(ViewTypeAttribute), false)
            .Any(att => ((ViewTypeAttribute)att).name.Equals(PropertyValue)));

    IView myObject = (IView)Activator.CreateInstance(objectType.First(),parentControl);
    return myObject;
}
}

[ViewTypeAttribute("PropertyValue", "1.0")]
class ListboxView : IView
{


public ListboxView(FilterDocumentChoseTypeFieldControll parentControl)
{

}       
public override void CreateChildrens()
{

}

}

【讨论】:

    【解决方案4】:

    如果有人需要使用 System.Reflection.Emit 的版本...

    // just paste this into a Console App
    
    using System;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Reflection.Emit;
    
    class Program
    {
        static void Main(string[] args)
        {
            // Here's the usage of a "traditional" factory, which returns objects that implement a common interface.
            // This is a great pattern for a lot of different scenarios.
            // The only downside is that you have to update your factory class whenever you add a new class.
            TraditionalFactory.Create("A_ID").DoIt();
            TraditionalFactory.Create("B_ID").DoIt();        
            Console.ReadKey();
    
            // But what if we make a class that uses reflection to find attributes of classes it can create? Reflection!
            // This works great and now all we have to do is add an attribute to new classes and this thing will just work.
            // (It could also be more generic in its input / output, but I simplified it for this example)
            ReflectionFactory.Create("A_ID").DoIt();
            ReflectionFactory.Create("B_ID").DoIt();
            // Wait, that's great and all, but everyone always says reflection is so slow, and this thing's going to reflect 
            // on every object creation...that's not good right?
            Console.ReadKey();
    
            // So I created this new factory class which gives the speed of the traditional factory combined with the flexibility 
            // of the reflection-based factory.
            // The reflection done here is only performed once. After that, it is as if the Create() method is using a switch statement        
            Factory<string, IDoSomething>.Create("A_ID").DoIt();
            Factory<string, IDoSomething>.Create("B_ID").DoIt();
    
            Console.ReadKey();
        }
    }
    
    class TraditionalFactory
    {
        public static IDoSomething Create(string id)
        {
            switch (id)
            {
                case "A_ID":
                    return new A();
                case "B_ID":
                    return new B();
                default:
                    throw new InvalidOperationException("Invalid factory identifier");
            }
        }
    }
    
    class ReflectionFactory
    {
        private readonly static Dictionary<string, Type> ReturnableTypes;
    
        static ReflectionFactory()
        {
            ReturnableTypes = GetReturnableTypes();
        }
    
        private static Dictionary<string, Type> GetReturnableTypes()
        {
            // get a list of the types that the factory can return
            // criteria for matching types:
            // - must have a parameterless constructor
            // - must have correct factory attribute, with non-null, non-empty value
            // - must have correct BaseType (if OutputType is not generic)
            // - must have matching generic BaseType (if OutputType is generic)
    
            Dictionary<string, Type> returnableTypes = new Dictionary<string, Type>();
    
            Type outputType = typeof(IDoSomething);
            Type factoryLabelType = typeof(FactoryAttribute);
            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                string assemblyName = assembly.GetName().Name;
                if (!assemblyName.StartsWith("System") &&
                    assemblyName != "mscorlib" &&
                    !assemblyName.StartsWith("Microsoft"))
                {
                    foreach (Type type in assembly.GetTypes())
                    {
                        if (type.GetCustomAttributes(factoryLabelType, false).Length > 0)
                        {
                            foreach (object label in ((FactoryAttribute)type.GetCustomAttributes(factoryLabelType, true)[0]).Labels)
                            {
                                if (label != null && label.GetType() == typeof(string))
                                {
                                    if (outputType.IsAssignableFrom(type))
                                    {
                                        returnableTypes.Add((string)label, type);
                                    }
                                }
                            }
                        }
                    }
                }
            }
    
            return returnableTypes;
        }
    
        public static IDoSomething Create(string id)
        {
            if (ReturnableTypes.ContainsKey(id))
            {
                return (IDoSomething)Activator.CreateInstance(ReturnableTypes[id]);
            }
            else
            {
                throw new Exception("Invalid factory identifier");
            }
        }
    }
    
    [Factory("A_ID")]
    class A : IDoSomething
    {
        public void DoIt()
        {
            Console.WriteLine("Letter A");
        }
    }
    
    [Factory("B_ID")]
    class B : IDoSomething
    {
        public void DoIt()
        {
            Console.WriteLine("Letter B");
        }
    }
    
    public interface IDoSomething
    {
        void DoIt();
    }
    
    /// <summary>
    /// Attribute class for decorating classes to use with the generic Factory
    /// </summary>
    public sealed class FactoryAttribute : Attribute
    {
        public IEnumerable<object> Labels { get; private set; }
        public FactoryAttribute(params object[] labels)
        {
            if (labels == null)
            {
                throw new ArgumentNullException("labels cannot be null");
            }
            Labels = labels;
        }
    }
    
    /// <summary>
    /// Custom exception class for factory creation errors
    /// </summary>
    public class FactoryCreationException : Exception
    {
        public FactoryCreationException()
            : base("Factory failed to create object")
        {
        }
    }
    
    /// <summary>
    /// Generic Factory class.  Classes must have a parameterless constructor for use with this class.  Decorate classes with 
    /// <c>FactoryAttribute</c> labels to match identifiers
    /// </summary>
    /// <typeparam name="TInput">Input identifier, matches FactoryAttribute labels</typeparam>
    /// <typeparam name="TOutput">Output base class / interface</typeparam>
    public class Factory<TInput, TOutput>
        where TOutput : class
    {
        private static readonly Dictionary<TInput, int> JumpTable;
        private static readonly Func<TInput, TOutput> Creator;
    
        static Factory()
        {
            JumpTable = new Dictionary<TInput, int>();
            Dictionary<TInput, Type> returnableTypes = GetReturnableTypes();
            int index = 0;
            foreach (KeyValuePair<TInput, Type> kvp in returnableTypes)
            {
                JumpTable.Add(kvp.Key, index++);
            }
            Creator = CreateDelegate(returnableTypes);
        }
    
        /// <summary>
        /// Creates a TOutput instance based on the label
        /// </summary>
        /// <param name="label">Identifier label to create</param>
        /// <returns></returns>
        public static TOutput Create(TInput label)
        {
            return Creator(label);
        }
    
        /// <summary>
        /// Creates a TOutput instance based on the label
        /// </summary>
        /// <param name="label">Identifier label to create</param>
        /// <param name="defaultOutput">default object to return if creation fails</param>
        /// <returns></returns>
        public static TOutput Create(TInput label, TOutput defaultOutput)
        {
            try
            {
                return Create(label);
            }
            catch (FactoryCreationException)
            {
                return defaultOutput;
            }
        }
    
        private static Dictionary<TInput, Type> GetReturnableTypes()
        {
            // get a list of the types that the factory can return
            // criteria for matching types:
            // - must have a parameterless constructor
            // - must have correct factory attribute, with non-null, non-empty value
            // - must have correct BaseType (if OutputType is not generic)
            // - must have matching generic BaseType (if OutputType is generic)
    
            Dictionary<TInput, Type> returnableTypes = new Dictionary<TInput, Type>();
    
            Type outputType = typeof(TOutput);
            Type factoryLabelType = typeof(FactoryAttribute);
            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                string assemblyName = assembly.GetName().Name;
                if (!assemblyName.StartsWith("System") &&
                    assemblyName != "mscorlib" &&
                    !assemblyName.StartsWith("Microsoft"))
                {
                    foreach (Type type in assembly.GetTypes())
                    {
                        if (type.GetCustomAttributes(factoryLabelType, false).Length > 0)
                        {
                            foreach (object label in ((FactoryAttribute)type.GetCustomAttributes(factoryLabelType, true)[0]).Labels)
                            {
                                if (label != null && label.GetType() == typeof(TInput))
                                {
                                    if (outputType.IsAssignableFrom(type))
                                    {
                                        returnableTypes.Add((TInput)label, type);
                                    }
                                }
                            }
                        }
                    }
                }
            }
    
            return returnableTypes;
        }
    
        private static Func<TInput, TOutput> CreateDelegate(Dictionary<TInput, Type> returnableTypes)
        {
            // get FieldInfo reference to the jump table dictionary
            FieldInfo jumpTableFieldInfo = typeof(Factory<TInput, TOutput>).GetField("JumpTable", BindingFlags.Static | BindingFlags.NonPublic);
            if (jumpTableFieldInfo == null)
            {
                throw new InvalidOperationException("Unable to get jump table field");
            }
    
            // set up the IL Generator
            DynamicMethod dynamicMethod = new DynamicMethod(
                "Magic",                                        // name of dynamic method
                typeof(TOutput),                                // return type
                new[] { typeof(TInput) },                        // arguments
                typeof(Factory<TInput, TOutput>),                // owner class
                true);
            ILGenerator gen = dynamicMethod.GetILGenerator();
    
            // define labels (marked later as IL is emitted)
            Label creationFailedLabel = gen.DefineLabel();
            Label[] jumpTableLabels = new Label[JumpTable.Count];
            for (int i = 0; i < JumpTable.Count; i++)
            {
                jumpTableLabels[i] = gen.DefineLabel();
            }
    
            // declare local variables
            gen.DeclareLocal(typeof(TOutput));
            gen.DeclareLocal(typeof(TInput));
            LocalBuilder intLocalBuilder = gen.DeclareLocal(typeof(int));
    
            // emit MSIL instructions to the dynamic method
            gen.Emit(OpCodes.Ldarg_0);
            gen.Emit(OpCodes.Stloc_1);
            gen.Emit(OpCodes.Volatile);
            gen.Emit(OpCodes.Ldsfld, jumpTableFieldInfo);
            gen.Emit(OpCodes.Ldloc_1);
            gen.Emit(OpCodes.Ldloca_S, intLocalBuilder);
            gen.Emit(OpCodes.Call, typeof(Dictionary<TInput, int>).GetMethod("TryGetValue"));
            gen.Emit(OpCodes.Brfalse, creationFailedLabel);
            gen.Emit(OpCodes.Ldloc_2);
            // execute the MSIL switch statement
            gen.Emit(OpCodes.Switch, jumpTableLabels);
    
            // set up the jump table
            foreach (KeyValuePair<TInput, int> kvp in JumpTable)
            {
                gen.MarkLabel(jumpTableLabels[kvp.Value]);
                // create the type to return
                gen.Emit(OpCodes.Newobj, returnableTypes[kvp.Key].GetConstructor(Type.EmptyTypes));
                gen.Emit(OpCodes.Ret);
            }
    
            // CREATION FAILED label
            gen.MarkLabel(creationFailedLabel);
            gen.Emit(OpCodes.Newobj, typeof(FactoryCreationException).GetConstructor(Type.EmptyTypes));
            gen.Emit(OpCodes.Throw);
    
            // create a delegate so we can later invoke the dynamically created method
            return (Func<TInput, TOutput>)dynamicMethod.CreateDelegate(typeof(Func<TInput, TOutput>));
        }
    }
    

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 2018-01-22
      • 2011-08-07
      • 1970-01-01
      • 2012-02-27
      • 2019-08-13
      • 2019-09-07
      • 1970-01-01
      相关资源
      最近更新 更多