C #: Comment utiliser la méthode générique avec la variable “out”

Je veux créer une fonction générique simple

void Assign(out T result) { Type type = typeof(T); if (type.Name == "Ssortingng") { // result = "hello"; } else if (type.Name == "Int32") { // result = 100; } else result = default(T); } 

Usage:

 int value; ssortingng text; Assign(value); // <<< should set value to 100 Assign(text); // <<< should set text to "hello" 

Ma question est de savoir comment programmer le code pour définir ces valeurs, c.-à-d. les codes manquants dans la section commentaire.

Merci pour toute aide.

On dirait que dans ce cas, vous le faites peut-être pour éviter la boxe? Difficile à dire sans plus d’informations, mais pour cet exemple spécifique, il serait beaucoup plus facile et probablement moins sujet aux bogues d’utiliser simplement la surcharge de méthode:

 void Assign(out ssortingng value) { //... } void Assign(out int value) { //... } 

Pour apprendre précisément ce qui ne va pas ici, vous devez atsortingbuer une valeur à un object avant de le convertir en type générique:

 (T)(object)"hello world!"; 

Quelle OMI est assez méchante et devrait être un dernier recours – ne rend certainement pas votre code plus propre.

Chaque fois que vous effectuez une vérification de type des parameters génériques, c’est une bonne indication que les génériques ne sont pas la bonne solution à votre problème. Faire des vérifications de type de paramètre générique rend votre code plus complexe, pas plus simple. Cela rend une méthode responsable de différents comportements en fonction du type, au lieu d’une série de méthodes simples faciles à modifier sans affecter accidentellement les autres. Voir le principe de responsabilité unique .

Tout d’abord, c’est un très mauvais schéma. Vous ne devriez pas utiliser ce genre de modèle. Peut-être que si vous décrivez ce que vous voulez vraiment réaliser, il y aura de meilleures réponses.

Le code ci-dessous fonctionne, mais comme je l’ai dit, écrire du code de cette façon est une mauvaise idée.

  void Assign(out T result) { Type type = typeof(T); if (type.Name == "Ssortingng") { result = (T) ((object)"hello"); } else if (type.Name == "Int32") { result = (T) ((object)100); } else result = default(T); } 

Et utilisation:

  int value; ssortingng text; Assign(out value); Assign(out text); 
 public T GetObject(ssortingng val) { T _object = default(T); _object = (T)Convert.ChangeType(val, typeof(T)); return _object; } 

Voici un moyen:

 static void Assign(out T result) { Type type = typeof(T); if (type.Name == "Ssortingng") { result = (T)Convert.ChangeType("hello", typeof(T)); } else if (type.Name == "Int32") { result = (T)Convert.ChangeType(100, typeof(T)); } else { result = default(T); } } 

Mais ce code sent vraiment mauvais et va à l’encontre des génériques (utilisez plutôt des méthodes surchargées). J’espère que cela ne se retrouvera pas quelque part dans le code de production et ne servira qu’à édifier.