blocks|key|3898297|text|我不认为使用属性会增加工厂和它创建的类之间的耦合度，事实上，它会减少这里的耦合度，因为工厂会在运行时通过属性发现信息。如果有什么不同的话，那就是简单地交换为耦合到属性而创建的类之间的耦合。也就是说，我不确定这到底能为你买到什么。工厂的要点是将创建逻辑本地化在一个地方。通过将其放入属性中，您再次将其散布到代码中，这在一定程度上违背了工厂的目的:现在，您必须同时查看工厂和属性，以了解对象是如何创建的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3898298|当然，我可能误解了你的问题。您的意思可能是，一个类使用其属性上的属性来指示哪些属性需要由工厂实例化。在这种情况下，您将替换一些用于进行依赖注入的配置驱动机制。我当然可以看到这可能有用的地方；让工厂发现对象的依赖关系，并在运行时自动创建它们。在这种情况下，您将略微增加代码的整体耦合性，因为现在属性和工厂之间存在以前不存在的依赖关系。总体而言，您可能会降低代码复杂性，因为您不需要为每个类编写特定的代码来提供其特定的依赖项或从配置文件中发现它们。|3898299|如果你问使用属性是否是一个好主意，我想我们可能需要更多的信息，但既然你似乎只问你是否会违反OO原则，我不这么认为。我不认为它会增加工厂和要创建的类之间的耦合，而只是略微增加代码的整体耦合。工厂本质上比其他类需要更多的耦合。记住，它是松耦合的，而不是解耦的。未耦合的代码不会做任何事情。您需要类之间的关系才能使任何事情发生。|3898300|entityMap^0|54|1|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|K|$]]

I don't think that using attributes would be increasing the coupling between the factory and the class it creates, in fact, it would decrease the coupling here because the factory would be discovering the information at runtime via the attributes. If anything you're simply trading the coupling between the class being created for the coupling to the attribute. That said, I'm not sure exactly what that buys you. The point of the factory is that you localize the creational logic in a single place. By putting it into attributes you've spread it all over your code again, partially defeating the purpose of the factory: now you have to look at both the factory and the attribute to understand how the object is being created.

Of course, I may be misunderstanding your question. You may mean that a class uses attributes on it's properties to indicate which of the properties need to be instantiated by the factory. In this case, you're replacing some configuration-driven mechanism for doing dependency injection. I can certainly see where that might be useful; having the factory discover an object's dependencies and automatically create them as well at runtime. In this case, you'd be slightly increasing the overall coupling of your code, since there is now a dependency between the attribute and the factory that didn't exist before. Overall, though you might decrease code complexity since you'd be able to do without specific code for each class to supply its particular dependencies or discover them from a configuration file.

If you're asking if using attributes a good idea, I think we probably need more information, but since you seem to be asking only if you're going to violate an OO principle, I don't think so. I don't see it increasing the coupling between the factory and the class being created and only slightly increasing the overall coupling of the code. Factories, by their nature, need more coupling than other classes anyway. Remember, it's loosely-coupled, not uncoupled. Uncoupled code doesn't do anything. You need relationships between classes to make anything happen.

blocks|key|1466701|text|装饰工厂的产品类可以使开发变得更容易，这是我有时会做的事情。例如，当必须基于存储在数据库中的唯一标识符来创建产品时，这尤其有用。在这个唯一的id和product类之间必须有一个映射，使用一个属性可以使这个映射变得非常清晰和可靠。除此之外，它还允许您添加产品类，而无需更改工厂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1466702|例如，你可以这样装饰你的类：|1466703|[ProductAttribute(1)]
public+class+MyFirstProduct+:+IProduct
{
}

[ProductAttribute(2)]
public+class+MySecondProduct+:+IProduct
{
}|code-block|syntax|javascript|1466704|你可以像这样实现你的工厂：|1466705|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;
++++}
}|1466706|这样做之后，您可以使用该工厂来创建产品，如下所示：|1466707|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();
++++}
}|1466708|例如，我过去使用过这个概念来创建基于数据库标识符的发票计算。该数据库包含每种发票类型的计算列表。实际计算是在C#类中定义的。|1466709|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Decorate product classes of a factory can make development much easier and it is something I sometime do. This is especially useful when products must be created based on a unique identifier stored in a database for instance. There must be a mapping between that unique id and the product class and using an attribute makes this very clear and reabable. Besides this, it allows you to add product classes, without changing the factory.

For instance, you can decorate your class like this:

<pre><code>[ProductAttribute(1)]
public class MyFirstProduct : IProduct
{
}

[ProductAttribute(2)]
public class MySecondProduct : IProduct
{
}
</code></pre>

And you can implement your factory like this:

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

 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 &amp;&amp; !type.IsInterface
 let attributes = type.GetCustomAttributes(
 typeof(ProductAttribute), false)
 let attribute = attributes[0] as ProductAttribute
 select new { type, attribute.Id };

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

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

 return Activator.CreateInstance(productType) as IProduct;
 }
}
</code></pre>

After doing this you can use that factory for creating products like this:

<pre><code>private IProductFactory factory;

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

 foreach (var product in products)
 {
 product.Sell();
 }
}
</code></pre>

I've used this concept in the past for instance to create invoice calculations based on a database identifier. The database contained a list of calculations per type of invoice. The actual calculations were defined in C# classes.

blocks|key|1466739|text|下面是我用来基于属性值创建具体实例的工厂实现。它还使用参数实例化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1466740|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()
{

}

}|code-block|syntax|javascript|1466741|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a factory implementation that i used to create concrete instances based on a attribute value. It also instantiates with parameters.

<pre><code>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 =&gt; p).
 Where(t =&gt; t.GetCustomAttributes(typeof(ViewTypeAttribute), false)
 .Any(att =&gt; ((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()
{

}

}
</code></pre>

blocks|key|1468449|text|如果有人需要使用System.Reflection.Emit的版本...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1468450|//+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%2B%2B);
++++++++}
++++++++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+%7C+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%2B%2B)
++++++++{
++++++++++++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>));
++++}
}|code-block|syntax|javascript|1468451|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In case anyone needs a version that uses System.Reflection.Emit...

<pre><code>// 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&lt;string, IDoSomething&gt;.Create("A_ID").DoIt();
 Factory&lt;string, IDoSomething&gt;.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&lt;string, Type&gt; ReturnableTypes;

 static ReflectionFactory()
 {
 ReturnableTypes = GetReturnableTypes();
 }

 private static Dictionary&lt;string, Type&gt; 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&lt;string, Type&gt; returnableTypes = new Dictionary&lt;string, Type&gt;();

 Type outputType = typeof(IDoSomething);
 Type factoryLabelType = typeof(FactoryAttribute);
 foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
 {
 string assemblyName = assembly.GetName().Name;
 if (!assemblyName.StartsWith("System") &amp;&amp;
 assemblyName != "mscorlib" &amp;&amp;
 !assemblyName.StartsWith("Microsoft"))
 {
 foreach (Type type in assembly.GetTypes())
 {
 if (type.GetCustomAttributes(factoryLabelType, false).Length &gt; 0)
 {
 foreach (object label in ((FactoryAttribute)type.GetCustomAttributes(factoryLabelType, true)[0]).Labels)
 {
 if (label != null &amp;&amp; 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();
}

/// &lt;summary&gt;
/// Attribute class for decorating classes to use with the generic Factory
/// &lt;/summary&gt;
public sealed class FactoryAttribute : Attribute
{
 public IEnumerable&lt;object&gt; Labels { get; private set; }
 public FactoryAttribute(params object[] labels)
 {
 if (labels == null)
 {
 throw new ArgumentNullException("labels cannot be null");
 }
 Labels = labels;
 }
}

/// &lt;summary&gt;
/// Custom exception class for factory creation errors
/// &lt;/summary&gt;
public class FactoryCreationException : Exception
{
 public FactoryCreationException()
 : base("Factory failed to create object")
 {
 }
}

/// &lt;summary&gt;
/// Generic Factory class. Classes must have a parameterless constructor for use with this class. Decorate classes with 
/// &lt;c&gt;FactoryAttribute&lt;/c&gt; labels to match identifiers
/// &lt;/summary&gt;
/// &lt;typeparam name="TInput"&gt;Input identifier, matches FactoryAttribute labels&lt;/typeparam&gt;
/// &lt;typeparam name="TOutput"&gt;Output base class / interface&lt;/typeparam&gt;
public class Factory&lt;TInput, TOutput&gt;
 where TOutput : class
{
 private static readonly Dictionary&lt;TInput, int&gt; JumpTable;
 private static readonly Func&lt;TInput, TOutput&gt; Creator;

 static Factory()
 {
 JumpTable = new Dictionary&lt;TInput, int&gt;();
 Dictionary&lt;TInput, Type&gt; returnableTypes = GetReturnableTypes();
 int index = 0;
 foreach (KeyValuePair&lt;TInput, Type&gt; kvp in returnableTypes)
 {
 JumpTable.Add(kvp.Key, index++);
 }
 Creator = CreateDelegate(returnableTypes);
 }

 /// &lt;summary&gt;
 /// Creates a TOutput instance based on the label
 /// &lt;/summary&gt;
 /// &lt;param name="label"&gt;Identifier label to create&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public static TOutput Create(TInput label)
 {
 return Creator(label);
 }

 /// &lt;summary&gt;
 /// Creates a TOutput instance based on the label
 /// &lt;/summary&gt;
 /// &lt;param name="label"&gt;Identifier label to create&lt;/param&gt;
 /// &lt;param name="defaultOutput"&gt;default object to return if creation fails&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public static TOutput Create(TInput label, TOutput defaultOutput)
 {
 try
 {
 return Create(label);
 }
 catch (FactoryCreationException)
 {
 return defaultOutput;
 }
 }

 private static Dictionary&lt;TInput, Type&gt; 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&lt;TInput, Type&gt; returnableTypes = new Dictionary&lt;TInput, Type&gt;();

 Type outputType = typeof(TOutput);
 Type factoryLabelType = typeof(FactoryAttribute);
 foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
 {
 string assemblyName = assembly.GetName().Name;
 if (!assemblyName.StartsWith("System") &amp;&amp;
 assemblyName != "mscorlib" &amp;&amp;
 !assemblyName.StartsWith("Microsoft"))
 {
 foreach (Type type in assembly.GetTypes())
 {
 if (type.GetCustomAttributes(factoryLabelType, false).Length &gt; 0)
 {
 foreach (object label in ((FactoryAttribute)type.GetCustomAttributes(factoryLabelType, true)[0]).Labels)
 {
 if (label != null &amp;&amp; label.GetType() == typeof(TInput))
 {
 if (outputType.IsAssignableFrom(type))
 {
 returnableTypes.Add((TInput)label, type);
 }
 }
 }
 }
 }
 }
 }

 return returnableTypes;
 }

 private static Func&lt;TInput, TOutput&gt; CreateDelegate(Dictionary&lt;TInput, Type&gt; returnableTypes)
 {
 // get FieldInfo reference to the jump table dictionary
 FieldInfo jumpTableFieldInfo = typeof(Factory&lt;TInput, TOutput&gt;).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&lt;TInput, TOutput&gt;), // 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 &lt; 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&lt;TInput, int&gt;).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&lt;TInput, int&gt; 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&lt;TInput, TOutput&gt;)dynamicMethod.CreateDelegate(typeof(Func&lt;TInput, TOutput&gt;));
 }
}
</code></pre>

I have implemented a factory in my project and it was recently suggested that I use attributes on my classes so the factory can determine which class to instantiate and pass back. I am new to the world of development and trying to rigidly follow the loosely-coupled rule, I wondering if relying on "hooks" (being the attributes) goes against this?

Can I use Attributes so my Factory knows what it can/should instantiate without breaking the "Loosely-Coupled" rule?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我已经在我的项目中实现了一个工厂，最近有人建议我在我的类上使用属性，这样工厂就可以确定实例化哪个类并传回。我是开发领域的新手，试图严格遵循松耦合规则，我想知道依赖“钩子”(属性)是否与此背道而驰？

问我是否可以使用属性，让我的工厂知道它可以/应该实例化什么，而不违反“松散耦合”规则？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我是否可以使用属性，让我的工厂知道它可以/应该实例化什么，而不违反“松散耦合”规则？EN