Impossibile convertire implicitamente il tipo "Int" in "T"

Posso chiamare Get<int>(Stat);oGet<string>(Name);

Ma durante la compilazione ottengo:

Impossibile convertire implicitamente il tipo "int" in "T"

e la stessa cosa per 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;
    }
}

Ogni volta che ti ritrovi ad attivare un tipo in un generico , quasi sicuramente stai facendo qualcosa di sbagliato . I generici dovrebbero essere generici ; dovrebbero funzionare in modo identico e completamente indipendente dal tipo .

Se T può essere solo int o string, in primo luogo non scrivere il codice in questo modo. Scrivi due metodi, uno che restituisce un int e uno che restituisce una stringa.

Dovresti essere in grado di usare solo al Convert.ChangeType()posto del tuo codice personalizzato:

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

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

ChangeTypeè probabilmente la tua migliore opzione. La mia soluzione è simile a quella fornita da BrokenGlass con un po 'di logica try catch.

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

Prova questo:

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

In realtà, puoi semplicemente convertirlo in objecte poi in T.

T var = (T)(object)42;

Un esempio per 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 volte, questo comportamento è desiderabile. Ad esempio, quando si implementa o si sovrascrive un metodo generico da una classe o interfaccia di base e si desidera aggiungere alcune funzionalità diverse in base al Ttipo.

Considerando che @BrokenGlass logic ( Convert.ChangeType) non supporta il tipo di GUID.

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

Errore : cast non valido da "System.String" a "System.Guid".

Utilizzare invece la logica seguente utilizzando TypeDescriptor.GetConverteraggiungendo lo System.ComponentModelspazio dei nomi.

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

Leggi questo .

Sembra che tu abbia bisogno di un TypeConverter, guarda questo post di blog .

Puoi semplicemente trasmettere come di seguito,

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