Usando métodos genéricos, ¿es posible volver a obtener diferentes tipos del mismo método?

Question

¿Podría tener algo como esto:

int x = MyMethod<int>(); 
string y = MyMethod<string>(); 

Por lo tanto, un método devolver diferentes tipos en función de T. Por supuesto, no sería lógica dentro del método para asegurarse de que regresaba lo correcto.

Nunca puedo obtener algo así para ejecutar. Se queja de que no se puede convertir el valor devuelto a T:

public static T MyMethod<T>() 
{ 
    if(typeof(T) == typeof(Int32)) 
    { 
    return 0; 
    } 
    else 
    { 
    return "nothing"; 
    } 
} 

Answer 1

intente lo siguiente

public static T MyMethod<T>() { 
    if (typeof(T) == typeof(Int32)) { 
    return (T)(object)0; 
    } else { 
    return (T)(object)"nothing"; 
    } 
} 

El truco aquí es el casting para object. Lo que intenta hacer es inherentemente inseguro ya que el compilador no puede inferir que 0 o "nada" son convertibles a T. No tiene límites después de todo. Así que simplemente dile al compilador explícitamente que no es seguro con el casting al object.

Answer 2

Podría hacer, si desea que se devuelva un valor de tipo "nulo" si no es un int. Pero si desea una cadena en todos los demás casos, verifique las otras respuestas.

public static T MyMethod<T>() 
{ 
    if(typeof(T) == typeof(Int32)) 
    { 
    return (T)(object)0; 
    } 
    else 
    { 
    return default(T); // or null 
    } 
} 

Answer 3

@Nick es correcto en su comentario que su código no se compilará. Pero suponiendo que decir:

public static T MyMethod<T>() 
{ 
    if(typeof(T) == typeof(Int32)) 
    { 
    return 0; 
    } 
    else 
    { 
    return "nothing"; 
    } 
} 

Se puede ser difícil de hacer los genéricos no genérico como que está intentando (y realmente contraviene el punto entero), pero esto debería funcionar:

public static T MyMethod<T>() 
{ 
    if(typeof(T) == typeof(Int32)) 
    { 
    return (T)(object)0; 
    } 
    else if(typeof(T) == typeof(string)) 
    { 
    return (T)(object)"nothing"; 
    } 

    return default(T); 
} 

Answer 4

Esto no es t válido ya que no hay garantía de que T sea moldeable/convertible en cadena o int.

Los genéricos NO son variantes, es decir, tipos que pueden contener nada, se resuelven en tiempo de compilación a un tipo real. Tu código no se compila porque no debería. Puede solucionar los problemas de tiempo de compilación utilizando algunos de los hacks publicados aquí, pero este es realmente un problema de lógica. Da un paso atrás y vuelve a pensar en lo que estás tratando de hacer en lugar de tratar de evitar el compilador.

Answer 5

poco fuera de tema, pero si usted está tratando de hacer esto, entonces puede ser que su diseño está mal ...

Por qué no sobrecargar el método y establecer el resultado como un parametro a cabo:

void MyMethod(out int result) 
{ 
    result=0; 
} 

void MyMethod(out string result) 
{ 
    result="my value"; 
} 

entonces se puede decir:

int value; 
MyMethod(out value); 

Y el compilador seleccionar la versión correcta