Vamos supor que eu tenha duas classes parecidas com esta (o primeiro bloco de código e o problema geral estão relacionados ao C #):
class A
{
public int IntProperty { get; set; }
}
class B
{
public int IntProperty { get; set; }
}
Essas classes não podem ser alteradas de forma alguma (elas fazem parte de uma montagem de terceiros). Portanto, não posso fazê-los implementar a mesma interface ou herdar a mesma classe que conteria IntProperty.
Eu quero aplicar alguma lógica na IntProperty
propriedade de ambas as classes, e em C ++ eu poderia usar uma classe de modelo para fazer isso facilmente:
template <class T>
class LogicToBeApplied
{
public:
void T CreateElement();
};
template <class T>
T LogicToBeApplied<T>::CreateElement()
{
T retVal;
retVal.IntProperty = 50;
return retVal;
}
E então eu poderia fazer algo assim:
LogicToBeApplied<ClassA> classALogic;
LogicToBeApplied<ClassB> classBLogic;
ClassA classAElement = classALogic.CreateElement();
ClassB classBElement = classBLogic.CreateElement();
Dessa forma, eu poderia criar uma única classe de fábrica genérica que funcionaria para a ClassA e a ClassB.
No entanto, em C #, tenho que escrever duas classes com duas where
cláusulas diferentes, mesmo que o código para a lógica seja exatamente o mesmo:
public class LogicAToBeApplied<T> where T : ClassA, new()
{
public T CreateElement()
{
T retVal = new T();
retVal.IntProperty = 50;
return retVal;
}
}
public class LogicBToBeApplied<T> where T : ClassB, new()
{
public T CreateElement()
{
T retVal = new T();
retVal.IntProperty = 50;
return retVal;
}
}
Eu sei que se eu quero ter classes diferentes na where
cláusula, elas precisam estar relacionadas, ou seja, herdar a mesma classe, se eu quiser aplicar o mesmo código a elas no sentido que descrevi acima. É apenas muito chato ter dois métodos completamente idênticos. Também não quero usar a reflexão por causa dos problemas de desempenho.
Alguém pode sugerir alguma abordagem em que isso possa ser escrito de uma maneira mais elegante?