El valor del tipo 'T' no se puede convertir a

Esta es probablemente una pregunta novata, pero Google sorprendentemente no proporcionó una respuesta.

Tengo este método bastante artificial

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

    return t;
}

Viniendo de un fondo de C ++, esperaba que esto funcionara. Sin embargo, no se puede compilar con "No se puede convertir implícitamente el tipo 'T' a cadena" y "No se puede convertir el tipo 'T' a cadena" para las dos asignaciones anteriores.

Estoy haciendo algo conceptualmente incorrecto o simplemente tengo la sintaxis incorrecta. Por favor, ayúdame a resolver esto.

¡Gracias!

A pesar de que hay dentro de un ifbloque, el compilador no sabe que Tes string.
Por lo tanto, no te permite lanzar. (Por la misma razón que no se puede echar DateTimea string)

Debe lanzar a object, (a lo que cualquiera Tpuede lanzar), y de allí a string(ya que objectpuede lanzar a string).
Por ejemplo:

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

Ambas líneas tienen el mismo problema.

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

El compilador no sabe que T es una cadena y, por lo tanto, no tiene forma de saber cómo asignar eso. Pero como lo has verificado, puedes forzarlo con

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

no necesita emitir la t ya que ya es una cadena, también necesita agregar la restricción

where T : class

Sé un código similar al OP publicado en esta pregunta de analizadores genéricos. Desde una perspectiva de rendimiento, debe usar Unsafe.As<TFrom, TResult>(ref TFrom source), que se puede encontrar en el paquete System.Runtime.CompilerServices.Unsafe NuGet. Evita el boxeo para los tipos de valor en estos escenarios. También creo que eso Unsafe.Asproduce menos código de máquina producido por el JIT que lanzar dos veces (usando (TResult) (object) actualString), pero no lo he comprobado.

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 será reemplazado por el JIT con instrucciones de código de máquina eficientes, como puede ver en el repositorio oficial de CoreFX:

Si está buscando tipos explícitos, ¿por qué declara esas variables como 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;
}

También recibirá este error si tiene una declaración genérica tanto para su clase como para su método. Por ejemplo, el código que se muestra a continuación da este error de compilación.

public class Foo <T> {

    T var;

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

}

Este código se compila (nota T eliminada de la declaración del método):

public class Foo <T> {

    T var;

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

}

Cambia esta línea:

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

Para esta línea:

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