No se puede convertir implícitamente el tipo 'int' a 'T'

Question

me puede llamar Get<int>(Stat); o Get<string>(Name);

Pero al compilar me sale:

No se puede convertir implícitamente el tipo 'int' a 'T'

y lo mismo para string.

public T Get<T>(Stats type) where T : IConvertible 
{ 
    if (typeof(T) == typeof(int)) 
    { 
     int t = Convert.ToInt16(PlayerStats[type]); 
     return t; 
    } 
    if (typeof(T) == typeof(string)) 
    { 
     string t = PlayerStats[type].ToString(); 
     return t; 
    } 
} 

Answer 1

Cada vez que te encuentres conectando un tipo en un genérico casi seguro que estás haciendo algo mal. Los genéricos deben ser genéricos; deberían funcionar de manera idéntica completamente independiente del tipo.

Si T solo puede ser int o cadena, no escriba su código de esta manera en absoluto en primer lugar. Escriba dos métodos, uno que devuelva un int y otro que devuelva una cadena.

Answer 2

public T Get<T>(Stats type) where T : IConvertible 
{ 
    if (typeof(T) == typeof(int)) 
    { 
     int t = Convert.ToInt16(PlayerStats[type]); 
     return t as T; 
    } 
    if (typeof(T) == typeof(string)) 
    { 
     string t = PlayerStats[type].ToString(); 
     return t as T; 
    } 
} 

Answer 3

Usted debe ser capaz de usar sólo Convert.ChangeType() en lugar de su código personalizado:

public T Get<T>(Stats type) where T : IConvertible 
{ 
    return (T) Convert.ChangeType(PlayerStats[type], typeof(T)); 
} 

Answer 4

Parece que necesita un TypeConverter, ver this blog entry.

Answer 5

ChangeType es probablemente su mejor opción. Mi solución es similar a la proporcionada por BrokenGlass con un poco de lógica de captura de prueba.

static void Main(string[] args) 
{ 
    object number = "1"; 
    bool hasConverted; 
    var convertedValue = DoConvert<int>(number, out hasConverted); 

    Console.WriteLine(hasConverted); 
    Console.WriteLine(convertedValue); 
} 

public static TConvertType DoConvert<TConvertType>(object convertValue, out bool hasConverted) 
{ 
    hasConverted = false; 
    var converted = default(TConvertType); 
    try 
    { 
     converted = (TConvertType) 
      Convert.ChangeType(convertValue, typeof(TConvertType)); 
     hasConverted = true; 
    } 
    catch (InvalidCastException) 
    { 
    } 
    catch (ArgumentNullException) 
    { 
    } 
    catch (FormatException) 
    { 
    } 
    catch (OverflowException) 
    { 
    } 

    return converted; 
} 

Answer 6

Teniendo en cuenta la lógica @BrokenGlass (Convert.ChangeType) no admite para el tipo GUID.

public T Get<T>(Stats type) where T : IConvertible 
{ 
    return (T) Convert.ChangeType(PlayerStats[type], typeof(T)); 
} 

error: fundido no válida del 'System.String' a 'System.Guid'.

En su lugar, utilice la lógica siguiente utilizando TypeDescriptor.GetConverter agregando System.ComponentModel espacio de nombres.

public T Get<T>(Stats type) where T : IConvertible 
{ 
    (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFromInvariantString(PlayerStats[type]) 
} 

Leído this.

Answer 7

Prueba esto:

public T Get<T>(Stats type) where T : IConvertible 
{ 
    if (typeof(T) == typeof(int)) 
    { 
     return (T)(object)Convert.ToInt16(PlayerStats[type]); 

    } 
    if (typeof(T) == typeof(string)) 
    { 

     return (T)(object)PlayerStats[type]; 
    } 
} 

Answer 8

En realidad, sólo puede convertirlo a object y luego a T.

T var = (T)(object)42;

Un ejemplo para bool:

public class Program 
{ 
    public static T Foo<T>() 
    { 
     if(typeof(T) == typeof(bool)) { 
      return (T)(object)true; 
     } 

     return default(T); 
    } 

    public static void Main() 
    { 
     bool boolValue = Foo<bool>(); // == true 
     string stringValue = Foo<string>(); // == null 
    } 
} 

A veces, este comportamiento es deseable. Por ejemplo, al implementar o anular un método genérico de una clase base o interfaz y desea agregar algunas funcionalidades diferentes basadas en el tipo T.