Impossible de convertir implicitement le type 'Int' à 'T'

Je peux appeler Get<int>(Stat); ou Get<string>(Name);

Mais lors de la compilation j'obtiens:

Impossible de convertir implicitement le type 'int' à 'T'

et la même chose pour 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;
    }
}

Vous pensez probablement que si le bloc vérifié que T est de type int, donc à l'intérieur du bloc, tu sais que T est de type int et vous devriez être en mesure de convertir implicitement int à T. Mais le compilateur n'est pas conçu pour suivre ce raisonnement, il sait juste que, généralement, les T ne provient pas de l'int, afin de ne pas permettre la conversion implicite. (Et si le compilateur pris en charge, le vérificateur ne serait pas, si l'assembly compilé serait invérifiable.)

InformationsquelleAutor David W | 2011-11-17

c#generics

119

Tout temps, vous trouvez vous-même d'allumer un type générique, vous êtes presque certainement fait quelque chose de mal. Les génériques doivent être générique; ils doivent fonctionner à l'identique totalement indépendante du type.

Si T ne peut être de type int ou string, puis ne pas écrire votre code de cette façon à tous, en premier lieu. Écrire deux méthodes, l'une qui renvoie un int et qui retourne une chaîne de caractères.
- Pourriez-vous élaborer sur quand cela va mal?
- Obtenir des<Voiture> où la voiture met en œuvre IConvertible va provoquer une rupture. Quand quelqu'un voit que vous avez une méthode générique ils supposent qu'ils peuvent passer dans tout ce qui implémente IConvertible.
- Je ne peux que partiellement d'accord avec vous, @Eric .J'ai une situation où j'ai eu à analyser des tableaux stockés dans le fichier XML-tags.Le problème, c'est que le cahier des charges que le document XML suit(COLLADA dans mon cas) dit que ces tableaux peuvent être non seulement float,int, bool, mais aussi certains types personnalisés.Toutefois, dans le cas où vous obtenez un float[](tableau balises contiennent le type de données stockées dans leurs noms:float_array magasins de flotteurs de), vous devez analyser la chaîne en un tableau de flotteurs, ce qui nécessite une certaine IFormatProvider à être utilisé).Évidemment je ne peut pas utiliser "T. Parse(...)".Donc pour un petit sous-ensemble de cas, j'ai besoin d'utiliser de tels commutation.
- Cette réponse va vous sortir du trou de lapin. Je voulais faire une fonction générique pour int, int?, bool, bool?, string, et il était apparemment impossible.
- Ce qui fait un switch sur un générique d'un type énuméré pratique.
InformationsquelleAutor Eric Lippert
119

Vous devriez être en mesure de l'utiliser juste Convertir.ChangeType() à la place de votre code personnalisé:
```
public T Get<T>(Stats type) where T : IConvertible
{
    return (T) Convert.ChangeType(PlayerStats[type], typeof(T));
}
```
- Que diriez - return (T)(object)PlayerStats[type];
InformationsquelleAutor BrokenGlass

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

return (T) t; car pas de nulle vérifications sont nécessaires.
Ce ci-dessus ne compile pas pour moi. T doit être un type de référence pour "que de" pour compiler.

InformationsquelleAutor Reza ArabQaeni

ChangeType est probablement votre meilleure option. Ma solution est similaire à celle prévue par BrokenGlass avec un peu de try catch logique.

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

Mon cas d'utilisation est un béton de classe dérivée à partir d'un générique de la classe abstraite. La classe est marquée abstrait parce qu'il définit une méthode abstraite qui fonctionne sur le générique de membre privé de la classe de base. Le générique utilise le C# 7.3 Enum contrainte sur sa de type générique. Je viens de terminé avec succès un test, et il fonctionne exactement comme je l'espérer.

InformationsquelleAutor Michael Ciba

Essayez ceci:

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

Merci cela a aidé, mon besoin est différent. Je suis à écrire un simulacre de méthode pour une méthode statique de sorte que je puisse le tester. À l'aide de ce osherove.com/blog/2012/7/8/...

InformationsquelleAutor Michael Kalinovich

4

Considérant @BrokenGlass logique (Convert.ChangeType) ne prend pas en charge pour le type de GUID.
```
public T Get<T>(Stats type) where T : IConvertible
{
    return (T) Convert.ChangeType(PlayerStats[type], typeof(T));
}
```
Erreur: Invalid cast de 'Système.Chaîne' de 'Système.Guid'.

Au lieu de cela, utiliser en dessous de la logique à l'aide de TypeDescriptor.GetConverter en ajoutant System.ComponentModel espace de noms.
```
public T Get<T>(Stats type) where T : IConvertible
{
    (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFromInvariantString(PlayerStats[type])
}
```
Lire cette.

InformationsquelleAutor Prasad Kanaparthi

En fait, vous pouvez simplement convertir object puis à T.

T var = (T)(object)42;

Un exemple pour 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
    }
}

Parfois, ce comportement est souhaitable. Par exemple, lors de l'application ou du remplacement d'une méthode générique d'une classe de base ou de l'interface et vous souhaitez ajouter des fonctionnalités différentes en fonction sur le T type.

InformationsquelleAutor GregaMohorko

3

Il semble que vous ayez besoin d'un TypeConverter, voir cette entrée de blog.

InformationsquelleAutor Ian Mercer

Vous pouvez tout simplement jeté comme ci-dessous,

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

InformationsquelleAutor Vijayanath Viswanathan

Vous devez vous connecter pour publier un commentaire.