Conosco il typeof (T) ma il compilatore no. Come risolvere?

Question

Sto cercando di scrivere un metodo come questo:

public static T Test<T>() 
{ 
    if (typeof(T)==typeof(string)) 
    return "1241"; 

    // do something else 
} 

ma io non riesco a capire come tirare fuori. Voglio restituire valori in base al tipo di T con cui è stato invocato il metodo. Devo restituire stringhe, int, classi personalizzate, elenco, ecc.

L'effettivo caso di utilizzo è un codice di serializzazione personalizzato in cui è essenziale che il codice di deserializzazione conosca il tipo di oggetto che dovrebbe produrre.

Chiarimento: l'esempio di cui sopra dà il seguente errore: Impossibile convertire la stringa di tipo T

La soluzione ideale sarebbe lavorare sui tipi di valore e tipi di riferimento, e non dovrebbe includere un parametro fittizio per la risoluzione di sovraccarico.

Sto iniziando a dubitare se questa soluzione ideale esiste però.

Grazie, Lucas

Answer 1

Il cast intermedio a object non è l'ideale, ma qualcosa di simile dovrebbe fare il trucco:

public static T Test<T>() 
{ 
    if (typeof(T) == typeof(string)) 
     return (T)(object)"1241"; 

    // do something else 
} 

Answer 2

Devi cast del valore restituito a T, per esempio qualcosa di simile per i tipi di riferimento:

public static T Test<T>() where T : class 
{ 
    if (typeof(T)==typeof(string)) 
    return "1241" as T; 

    return default(T); 
} 

Answer 3

Attenzione! La soluzione riportata di seguito è non lavoro (verificato utilizzando il compilatore C# Mono gmcs).

Tuttavia, lo deve essere funzionante in base alla lettura dello standard C#, poiché la risoluzione di sovraccarico dovrebbe preferire la versione non generica del metodo quando possibile. La sezione pertinente in ECMA-334 è 25.1.7: "Sovraccarico in classi generiche". Inoltre, Eric Lippert sembra dirlo anche in uno blog posting.

Il feedback sarebbe apprezzato: perché non funziona come previsto?

---

Hai avuto tipi indipendenti e comportamenti estranei: questo codice urla “! uso sovraccarico”

Generics sarebbe opportuno per i tipi non correlati, comportamento eppure uguali (o molto simili).

fare questo (programma completo di test per riprodurre il comportamento):

using System; 

class TestClass { 
    public static T Test<T>() { 
     return TestWith(default(T)); 
     // do something else 
    } 

    public static string TestWith(string dummy) { 
     // Used only for `string`. 
     return "string"; 
    } 

    public static T TestWith<T>(T dummy) { 
     // Used for everything else. 
     return dummy; 
    } 

    static void Main() { 
     Console.WriteLine("Expected \"0\", got \"{0}\"", Test<int>()); 
     Console.WriteLine("Expected \"string\", got \"{0}\"", Test<string>()); 
    } 
} 

Compilato con gmcs, questo rendimenti:

Expected "0", got "0" 
Expected "string", got "" 

Qui, il parametro serve solo per la disambiguazione della chiamata sovraccarico. Parametri generici espliciti non possono essere utilizzati qui poiché una delle funzioni (la specializzazione string) non è generica.

Answer 4

Prova

public static T Test<T>() where T : class 
{ 
    if (typeof(T) == typeof(string)) return "asdf" as T; // do something else 
    // do something else   
} 

Answer 5

è possibile utilizzare ChangeType?

public static T Test<T>() 
{ 
    if (typeof(T)==typeof(string)) 
     return (T)Convert.ChangeType("1234", typeof(T), CultureInfo.InvariantCulture); 
    return default(T); 
} 

Answer 6

ho trovato la soluzione:

public static T Test<T>() 
{ 
    if (typeof(T) == typeof(string)) 
    return (T)(object)"1241"; // this works. 

    // do something else 
} 

Grazie per tutte le risposte .

Answer 7

public static T Test<T>() 
{ 
    if (typeof(T)==typeof(string)) 
    return (T)Convert.ChangeType("1241", typeof(T)); 

    return default(T); 
} 

io non ho provato, però :-)