Utilizzando metodi generici, è possibile recuperare diversi tipi dallo stesso metodo?

Question

Potrei avere qualcosa di simile:

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

Così, un metodo che restituisce diversi tipi basati su T. Naturalmente, ci sarebbe la logica all'interno del metodo per assicurarsi che stava tornando la cosa giusta.

Non riesco mai a ottenere qualcosa di simile per l'esecuzione. Si lamenta che non può lanciare il valore di ritorno a T:

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

Answer 1

provare il seguente

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

Il trucco è il casting per object. Quello che stai cercando di fare è intrinsecamente pericoloso poiché il compilatore non può dedurre che 0 o "niente" sono convertibili in alcun dato T. Dopo tutto, è illimitato. Quindi, spiega esplicitamente al compilatore che non è sicuro con il casting su object.

Answer 2

Si potrebbe fare, se si desidera un valore di tipo "nullo" restituito se non è un int. Ma se vuoi una stringa in tutti gli altri casi, controlla le altre risposte.

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

Answer 3

@Nick è corretto nel suo commento che il tuo codice non verrà compilato. Ma supponendo che cercavi:

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

Si può essere difficile per rendere i farmaci generici non generico come si sta tentando (e in realtà in contrasto con il punto intero), ma questo dovrebbe funzionare:

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

Questo isn' t valido in quanto non vi è alcuna garanzia che T sia calcinabile/convertibile in stringa o int.

I generici NON sono varianti, vale a dire tipi che possono contenere qualsiasi cosa - sono in fase di compilazione risolti in un tipo reale. Il tuo codice non viene compilato perché non dovrebbe. Puoi aggirare i problemi relativi alla compilazione utilizzando alcuni degli hack pubblicati qui, ma questo è davvero un problema logico. Fai un passo indietro e ripensa a ciò che stai cercando di fare invece di cercare di aggirare il compilatore.

Answer 5

Leggermente fuori tema, ma se si sta cercando di fare questa cosa, allora può essere che il vostro disegno è sbagliato ...

Perché non sovraccaricare il metodo e impostare il risultato come un paramter out:

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

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

allora si può dire:

int value; 
MyMethod(out value); 

E il compilatore selezionare la versione giusta