Nie można przekonwertować wartości typu „T” na

Jest to prawdopodobnie pytanie nowicjusza, ale Google, co zaskakujące, nie udzieliło odpowiedzi.

Mam tę raczej sztuczną metodę

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

    return t;
}

Pochodząc z tła C ++, spodziewałem się, że to zadziała. Jednak kompilacja nie powiodła się z opcją „Nie można niejawnie przekonwertować typu„ T ”na łańcuch” i „Nie można przekonwertować typu„ T ”na ciąg znaków” dla obu powyższych przypisań.

Albo robię coś złego koncepcyjnie, albo po prostu mam złą składnię. Proszę, pomóż mi to rozwiązać.

Dziękuję Ci!

Mimo że jest wewnątrz z ifbloku, kompilator nie wie, że Tjest string.
Dlatego nie pozwala ci rzucać. (Z tego samego powodu, że nie może oddać DateTimedo string)

Musisz rzucać do object(do którego każdy Tmoże rzucać), a stamtąd do string(ponieważ objectmożna rzucać do string).
Na przykład:

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

Obie linie mają ten sam problem

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

Kompilator nie wie, że T jest ciągiem znaków, więc nie ma możliwości wiedzieć, jak to przypisać. Ale skoro sprawdziłeś, możesz to po prostu wymusić

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

nie musisz rzucać t, ponieważ jest to już ciąg, musisz również dodać ograniczenie

where T : class

Znam podobny kod, który OP zamieścił w tym pytaniu z generycznych parserów. Z punktu widzenia wydajności należy użyć Unsafe.As<TFrom, TResult>(ref TFrom source), które można znaleźć w pakiecie NuGet System.Runtime.CompilerServices.Unsafe . Pozwala to uniknąć pakowania typów wartości w tych scenariuszach. Myślę też, że Unsafe.Asskutkuje to mniejszą ilością kodu maszynowego produkowanego przez JIT niż dwukrotne rzutowanie (przy użyciu (TResult) (object) actualString), ale nie sprawdziłem tego.

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 zostaną zastąpione przez JIT z wydajnymi instrukcjami kodu maszynowego, jak widać w oficjalnym repozytorium CoreFX:

Jeśli szukasz jawnych typów, dlaczego deklarujesz te zmienne jako T?

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;
}

Otrzymasz również ten błąd, jeśli masz ogólną deklarację zarówno dla swojej klasy, jak i metody. Na przykład poniższy kod podaje ten błąd kompilacji.

public class Foo <T> {

    T var;

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

}

Ten kod nie kompiluje się (uwaga T została usunięta z deklaracji metody):

public class Foo <T> {

    T var;

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

}

Zmień tę linię:

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

Dla tej linii:

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