genéricos sin estrenar()

Question

que tienen una docena de métodos en mi proyecto (C# 2.0) que se parecen a esto:

internal bool ValidateHotelStayEntity(DataRow row) 
{ 
    return (new HotelStayEntity(row)).Validate(); 
} 

... pero por diferentes clases de 'entidad'. (Bueno, no es tan trivial, he simplificado el código aquí.)

Parece un buen candidato para los genéricos y se me ocurrió esto:

internal bool ValidateEntity<T>(DataRow row) where T : EntityBase 
{ 
    return (new T(row)).Validate(); 
} 

Y, por supuesto, me sale el " No se puede crear una instancia del tipo parametrer 'T' porque no tiene el error new() constraint ".

El problema es que estas clases de "entidad" no tienen un constructor público sin parámetros, ni una forma de agregar los datos de la "fila" posteriormente. Y como EntityBase es parte del marco de trabajo de la compañía, no tengo control sobre él (es decir, no puedo cambiarlo).

¿Hay alguna forma de evitar esto?

Answer 1

embargo, otra forma podría ser involucrar a la reflexión en el precio del tiempo de compilación y una disminución del rendimiento:

internal bool ValidateEntity<T>(DataRow row) 
{ 
    object entity = Activator.CreateInstance(typeof(T), new object[] { row }); 
    MethodInfo validate = typeof(T).GetMethod("Validate"); 
    return (bool) validate.Invoke(entity, new object[]); 
} 

Tenga en cuenta que esto funcionaría incluso si las entidades no tienen un ancestro común

Answer 2

Una forma sencilla es proporcionar una función de fábrica:

internal bool ValidateEntity<T>(DataRow row, Func<DataRow, T> factory) 
    where T : EntityBase 
{ 
    return factory(row).Validate(); 
} 

y llame a:

bool valid = ValidateEntity(row, x => new Foo(x)); 

mente que, en ese momento es más complicado que simplemente llamando

bool valid = new Foo(row).Validate() 

en primer lugar ...

No está claro qué intenta lograr en su contexto real, pero este tipo de enfoque de fábrica/proveedor puede ser útil en otros momentos. Tenga en cuenta que llamar a un delegado de fábrica también puede ser considerablemente más rápido que usar new T() con una restricción, as I blogged a while ago. Irrevelante en muchos casos, pero vale la pena conocerlo.

EDIT: Para compatibilidad .NET 2.0 se necesitaría para declarar el delegado sí mismo, sino que es fácil:

public delegate TResult Func<T, TResult>(T input); 

Si eres realmente usando C# 2 (en lugar de, digamos, C# 3 la orientación .NET 2.0), entonces no será capaz de utilizar las expresiones lambda o bien, pero todavía se puede utilizar métodos anónimos:

bool valid = ValidateEntity(row, delegate(DataRow x) { return new Foo(x); }); 

Answer 3

Un ejemplo de solución método de fábrica @JohnSaunders':

internal bool ValidateEntity<T>(DataRow row, Func<DataRow, T> factory) where T : EntityBase 
{ 
    return (factory(row)).Validate(); 
} 

Answer 4

Puede hacer algo como esto:

internal bool ValidateEntity<T>(DataRow row) where T : EntityBase 
{ 
    return ((T)Activator.CreateInstance(typeof(T), new object[] { row })).Validate(); 
}