parameter - generic t property c#

Reflexión y tipos genéricos

Question

Estoy escribiendo un código para un constructor de clase que recorre todas las propiedades de la clase y llama a un método estático genérico que rellena mi clase con datos de una API externa. Así que tengo esto como una clase de ejemplo:

public class MyClass{
public string Property1 { get; set; }
public int Property2 { get; set; }
public bool Property3 { get; set; }
public static T DoStuff<T>(string name){
// get the data for the property from the external API
// or if there''s a problem return ''default(T)''
}
}

Ahora en mi constructor quiero algo como esto:

public MyClass(){
var properties = this.GetType().GetProperties();
foreach(PropertyInfo p in properties){
p.SetValue(this, DoStuff(p.Name), new object[0]);
}
}

Entonces, el constructor anterior arrojará un error porque no estoy suministrando el tipo genérico.

Entonces, ¿cómo paso el tipo de propiedad?

Answer 1

Si no usa DoStuff desde otro lugar, también sugiero que escriba un método no genérico.

Tal vez haya creado el método genérico para poder usar el valor predeterminado (T). Para reemplazar eso en un método no genérico, puede usar Activator.CreateInstance (T) para los tipos de valor y null para los tipos de referencia:

object defaultResult = type.IsValueType ? Activator.CreateInstance(type) : null

Answer 2

¿Desea llamar a DoStuff <T> con T = el tipo de cada propiedad? En ese caso, "tal cual" necesitaría usar reflection y MakeGenericMethod - ie

var properties = this.GetType().GetProperties();
foreach (PropertyInfo p in properties)
{
object value = typeof(MyClass)
.GetMethod("DoStuff")
.MakeGenericMethod(p.PropertyType)
.Invoke(null, new object[] { p.Name });
p.SetValue(this, value, null);
}

Sin embargo, esto no es muy bonito. En realidad, me pregunto si no sería mejor tener:

static object DoStuff(string name, Type propertyType);
... and then
object value = DoStuff(p.Name, p.PropertyType);

¿Qué te dan los genéricos en este ejemplo? Tenga en cuenta que los tipos de valor seguirán encerrados, etc. durante la llamada de reflexión, e incluso entonces el boxeo no es tan malo como podría pensar .

Finalmente, en muchos escenarios, TypeDescriptor.GetProperties () es más apropiado que Type.GetProperties () - permite modelos de objetos flexibles, etc.

Answer 3

Fue su código de constructor destinado a leer así:

public MyClass(){
var properties = this.GetType().GetProperties();
foreach(PropertyInfo p in properties){
p.SetValue(this, DoStuff(p.Name), new object[0]);
}
}

? Tenga en cuenta el DoStuff lugar de MyClass .

Si es así, el problema es que estás tratando de usar medicamentos genéricos cuando en realidad no son aplicables. El objetivo de los genéricos (bueno, uno de los puntos) es usar seguridad de tipo de tiempo de compilación. ¡Aquí no sabes el tipo en tiempo de compilación! Puede llamar al método por reflexión (buscando el formulario abierto y luego llamando a MakeGenericMethod ), pero eso es bastante feo.

DoStuff realmente necesita ser genérico en primer lugar? ¿Está siendo utilizado desde otro lugar? El parámetro para PropertyInfo.SetValue es solo objeto, por lo que aún obtendrás boxeo, etc. incluso si pudieras llamar al método genéricamente.