Il valore di tipo 'T' non può essere convertito in

Questa è probabilmente una domanda per principianti, ma sorprendentemente Google non ha fornito una risposta.

Ho questo metodo piuttosto artificiale

T HowToCast<T>(T t)
{
    if (typeof(T) == typeof(string))
    {
        T newT1 = "some text";
        T newT2 = (string)t;
    }

    return t;
}

Proveniente da un background C ++, mi aspettavo che funzionasse. Tuttavia, non riesce a compilare con "Impossibile convertire implicitamente il tipo 'T' in stringa" e "Impossibile convertire il tipo 'T' in stringa" per entrambe le assegnazioni precedenti.

O sto facendo qualcosa di concettualmente sbagliato o ho solo la sintassi sbagliata. Per favore, aiutami a risolvere questo.

Grazie!

Anche se è all'interno di un ifblocco, il compilatore non sa che Tè string.
Pertanto, non ti consente di lanciare. (Per la stessa ragione per cui non puoi lanciare DateTimea string)

Devi lanciare object, (a cui chiunque Tpuò lanciare), e da lì a string(dato che objectpuò essere lanciato a string).
Per esempio:

T newT1 = (T)(object)"some text";
string newT2 = (string)(object)t;

Entrambe le linee hanno lo stesso problema

T newT1 = "some text";
T newT2 = (string)t;

Il compilatore non sa che T è una stringa e quindi non ha modo di saperlo assegnare. Ma dal momento che hai controllato puoi semplicemente forzarlo

T newT1 = "some text" as T;
T newT2 = t; 

non è necessario eseguire il cast di t poiché è già una stringa, inoltre è necessario aggiungere il vincolo

where T : class

Conosco un codice simile che l'OP ha pubblicato in questa domanda da parser generici. Dal punto di vista delle prestazioni, è necessario utilizzare Unsafe.As<TFrom, TResult>(ref TFrom source), disponibile nel pacchetto NuGet System.Runtime.CompilerServices.Unsafe . Evita la boxe per i tipi di valore in questi scenari. Penso anche che si Unsafe.Astraduca in meno codice macchina prodotto dalla JIT rispetto al casting due volte (utilizzo (TResult) (object) actualString), ma non l'ho verificato.

public TResult ParseSomething<TResult>(ParseContext context)
{
    if (typeof(TResult) == typeof(string))
    {
        var token = context.ParseNextToken();
        string parsedString = token.ParseToDotnetString();
        return Unsafe.As<string, TResult>(ref parsedString);
    }
    else if (typeof(TResult) == typeof(int))
    {
        var token = context.ParseNextToken();
        int parsedInt32 = token.ParseToDotnetInt32();
        // This will not box which might be critical to performance
        return Unsafe.As<int, TResult>(ref parsedInt32); 
    }
    // other cases omitted for brevity's sake
}

Unsafe.As verrà sostituito da JIT con istruzioni efficienti sul codice macchina, come puoi vedere nel repository CoreFX ufficiale:

Se stai cercando tipi espliciti, perché stai dichiarando quelle variabili come T's?

T HowToCast<T>(T t)
{
    if (typeof(T) == typeof(string))
    {
        var newT1 = "some text";
        var newT2 = t;  //this builds but I'm not sure what it does under the hood.
        var newT3 = t.ToString();  //for sure the string you want.
    }

    return t;
}

Riceverai anche questo errore se hai una dichiarazione generica sia per la tua classe che per il tuo metodo. Ad esempio, il codice mostrato di seguito fornisce questo errore di compilazione.

public class Foo <T> {

    T var;

    public <T> void doSomething(Class <T> cls) throws InstantiationException, IllegalAccessException {
        this.var = cls.newInstance();
    }

}

Questo codice viene compilato (nota T rimossa dalla dichiarazione del metodo):

public class Foo <T> {

    T var;

    public void doSomething(Class <T> cls) throws InstantiationException, IllegalAccessException {
        this.var = cls.newInstance();
    }

}

Cambia questa riga:

if (typeof(T) == typeof(string))

Per questa linea:

if (t.GetType() == typeof(string))