Fábrica basada en Typeof o es una
Pregunta
¿Cuál es una forma más elegante de tener el código a continuación donde quiero devolver una clase derivada según el tipo de otra clase?
if (option_ is Rectangle)
{
modelInputs = new Foo();
}
else if (option_ is Circle)
{
modelInputs = new Bar();
}
else if (option_ is Triangle)
{
modelInputs = new Bar2();
}
Solución
Haga que Rectangle, Circle y Triangle implementen IHasModelInput:
interface IHasModelInput
{
IModelInput GetModelInput();
}
entonces puedes hacerlo
IModelInput modelInputs = option_.GetModelInput();
Otros consejos
Mi opinión: su " inelegant " el camino está bien Es simple, legible y hace el trabajo.
Tener el Rectángulo, Círculo y Triángulo implementando la función de fábrica necesaria a través de IHasModelInput funcionaría, pero tiene un costo de diseño: ahora ha acoplado este conjunto de clases con el conjunto de clases IModelInput ( Foo, Bar y Bar2). Podrían estar en dos bibliotecas completamente diferentes, y tal vez no deberían conocerse entre sí.
A continuación se muestra un método más complicado. Le brinda la ventaja de poder configurar su lógica de fábrica en tiempo de ejecución.
public static class FactoryMethod<T> where T : IModelInput, new()
{
public static IModelInput Create()
{
return new T();
}
}
delegate IModelInput ModelInputCreateFunction();
IModelInput CreateIModelInput(object item)
{
Dictionary<Type, ModelInputCreateFunction> factory = new Dictionary<Type, ModelInputCreateFunction>();
factory.Add(typeof(Rectangle), FactoryMethod<Foo>.Create);
factory.Add(typeof(Circle), FactoryMethod<Bar>.Create);
// Add more type mappings here
IModelInput modelInput;
foreach (Type t in factory.Keys)
{
if ( item.GetType().IsSubclassOf(t) || item.GetType().Equals(t))
{
modelInput = factory[t].Invoke();
break;
}
}
return modelInput;
}
Pero luego pregunte: ¿cuál preferiría leer?
Puede poner las entradas y salidas en una Hashtable, o almacenar los tipos que crean cada clase dentro de cada una de las clases que crea y luego usar Activator.CreateInstance para hacer la fábrica en ':
Hashtable ht = new Hashtable();
ht.Add(typeof(Rectangle), typeof(Bar));
ht.Add(typeof(Square), typeof(Bar2));
modelInputs = Activator.CreateInstance(ht[option.GetType()]);
De cualquier manera, Activator.CreateInstance es una manera muy buena de hacer que las fábricas funcionen en .NET. Disfruta y usa el poder que te he dado sabiamente, hijo.
Puede asociar un tipo con la opción " option_ " ;, si lo permite, y luego crear una instancia de él.
Normalmente uso un método de fábrica como este cuando quiero convertir una cadena a un tipo en tiempo de ejecución, uso un Diccionario que asigna una cadena a un Tipo.
Me gusta esto de un proyecto reciente:
public class TaskFactory
{
private Dictionary<String, Type> _taskTypes = new Dictionary<String, Type>();
public TaskFactory()
{
// Preload the Task Types into a dictionary so we can look them up later
foreach (Type type in typeof(TaskFactory).Assembly.GetTypes())
{
if (type.IsSubclassOf(typeof(CCTask)))
{
_taskTypes[type.Name.ToLower()] = type;
}
}
}
public CCTask CreateTask(XmlElement task)
{
if (task != null)
{
string taskName = task.Name;
taskName = taskName.ToLower() + "task";
// If the Type information is in our Dictionary, instantiate a new instance of that task
Type taskType;
if (_taskTypes.TryGetValue(taskName, out taskType))
{
return (CCTask)Activator.CreateInstance(taskType, task);
}
else
{
throw new ArgumentException("Unrecognized Task:" + task.Name);
}
}
else
{
return null;
}
}
}