Wert vom Typ 'T' kann nicht konvertiert werden

Dies ist wahrscheinlich eine Anfängerfrage, aber Google hat überraschenderweise keine Antwort geliefert.

Ich habe diese eher künstliche Methode

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

    return t;
}

Ich komme aus einem C ++ - Hintergrund und habe erwartet, dass dies funktioniert. Es kann jedoch nicht mit "Typ 'T' kann nicht implizit in Zeichenfolge konvertiert werden" und "Typ 'T' kann nicht in Zeichenfolge konvertiert werden" für beide oben genannten Zuweisungen kompiliert werden.

Ich mache entweder konzeptionell etwas falsch oder habe einfach die falsche Syntax. Bitte helfen Sie mir, das zu klären.

Danke dir!

Auch wenn es innerhalb eines ist ifBlock, wird der Compiler weiß nicht , dass Tist string.
Daher können Sie nicht wirken. (Aus dem gleichen Grund , dass Sie nicht werfen kann DateTimezu string)

Sie müssen zu object(zu dem jeder Twechseln kann) und von dort zu string(seit)object kann zu geworfen werden string).
Beispielsweise:

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

Beide Leitungen haben das gleiche Problem

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

Der Compiler weiß nicht, dass T eine Zeichenfolge ist, und kann daher nicht wissen, wie er diese zuweisen soll. Aber da Sie überprüft haben, können Sie es einfach mit erzwingen

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

Sie müssen das t nicht umwandeln, da es bereits eine Zeichenfolge ist. Außerdem müssen Sie die Einschränkung hinzufügen

where T : class

Ich kenne einen ähnlichen Code, den das OP in dieser Frage von generischen Parsern gepostet hat. Aus Sicht der Leistung sollten Sie diese verwenden Unsafe.As<TFrom, TResult>(ref TFrom source), die im System.Runtime.CompilerServices.Unsafe NuGet-Paket enthalten ist. In diesen Szenarien wird das Boxen für Werttypen vermieden. Ich denke auch, dass dies dazu Unsafe.Asführt , dass weniger Maschinencode von der JIT erzeugt wird als zweimal (mit (TResult) (object) actualString), aber ich habe das nicht überprüft.

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 wird durch die JIT durch effiziente Maschinencode-Anweisungen ersetzt, wie Sie im offiziellen CoreFX-Repo sehen können:

Wenn Sie nach expliziten Typen suchen, warum deklarieren Sie diese Variablen als 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;
}

Sie erhalten diesen Fehler auch, wenn Sie eine generische Deklaration für Ihre Klasse und Ihre Methode haben. Der unten gezeigte Code gibt beispielsweise diesen Kompilierungsfehler aus.

public class Foo <T> {

    T var;

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

}

Dieser Code wird kompiliert (Hinweis T aus der Methodendeklaration entfernt):

public class Foo <T> {

    T var;

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

}

Ändern Sie diese Zeile:

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

Für diese Zeile:

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