La valeur de type «T» ne peut pas être convertie en

C'est probablement une question novice, mais Google n'a étonnamment pas fourni de réponse.

J'ai cette méthode plutôt artificielle

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

    return t;
}

Venant d'un fond C ++, je m'attendais à ce que cela fonctionne. Cependant, il ne parvient pas à compiler avec "Impossible de convertir implicitement le type 'T' en chaîne" et "Impossible de convertir le type 'T' en chaîne" pour les deux affectations ci-dessus.

Soit je fais quelque chose de mal conceptuel, soit j'ai simplement la mauvaise syntaxe. S'il vous plaît, aidez-moi à régler celui-ci.

Je vous remercie!

Même si c'est à l'intérieur d'un ifbloc, le compilateur ne sait pas que Tc'est string.
Par conséquent, il ne vous permet pas de lancer. (Pour la même raison que vous ne pouvez pas lancer DateTimeà string)

Vous devez lancer vers object, (vers lequel n'importe qui Tpeut lancer), et de là vers string(puisque objectpeut être lancé vers string).
Par exemple:

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

Les deux lignes ont le même problème

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

Le compilateur ne sait pas que T est une chaîne et n'a donc aucun moyen de savoir comment l'affecter. Mais puisque vous avez vérifié, vous pouvez simplement le forcer avec

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

vous n'avez pas besoin de transtyper le t car c'est déjà une chaîne, vous devez également ajouter la contrainte

where T : class

Je connais un code similaire que l'OP a publié dans cette question à partir d'analyseurs génériques. Du point de vue des performances, vous devez utiliser Unsafe.As<TFrom, TResult>(ref TFrom source), qui se trouve dans le package NuGet System.Runtime.CompilerServices.Unsafe . Cela évite de boxer pour les types valeur dans ces scénarios. Je pense aussi que cela Unsafe.Asentraîne moins de code machine produit par le JIT que de lancer deux fois (en utilisant (TResult) (object) actualString), mais je ne l'ai pas vérifié.

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 sera remplacé par le JIT avec des instructions de code machine efficaces, comme vous pouvez le voir dans le repo officiel CoreFX:

Si vous recherchez des types explicites, pourquoi déclarez-vous ces variables comme Tdes 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;
}

Vous obtiendrez également cette erreur si vous avez une déclaration générique pour votre classe et votre méthode. Par exemple, le code ci-dessous donne cette erreur de compilation.

public class Foo <T> {

    T var;

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

}

Ce code compile (note T retiré de la déclaration de méthode):

public class Foo <T> {

    T var;

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

}

Changez cette ligne:

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

Pour cette ligne:

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