Vérification du paramètre de type d'une méthode générique en C#

Question

Est-il possible de faire quelque chose comme ça en C#:

public void DoSomething<T>(T t) 
{ 
    if (T is MyClass) 
    { 
     MyClass mc = (MyClass)t 
     ... 
    } 
    else if (T is List<MyClass>) 
    { 
     List<MyClass> lmc = (List<MyClass>)t 
     ... 
    } 
} 

Answer 1

Oui:

if (typeof(T) == typeof(MyClass)) 
{ 
    MyClass mc = (MyClass)(object) t; 
} 
else if (typeof(T) == typeof(List<MyClass>)) 
{ 
    List<MyClass> lmc = (List<MyClass>)(object) t; 
} 

Il est un peu étrange que vous devez passer par un casting objecter, mais c'est exactement comme ça que fonctionnent les génériques - il n'y a pas autant de conversions à partir d'un type générique que l'on pourrait s'y attendre.

Bien sûr une autre alternative est d'utiliser le contrôle du temps d'exécution normale:

MyClass mc = t as MyClass; 
if (mc != null) 
{ 
    // ... 
} 
else 
{ 
    List<MyClass> lmc = t as List<MyClass>; 
    if (lmc != null) 
    { 
     // ... 
    } 
} 

Cela se comportent différemment au premier bloc de code si t est nul, bien sûr.

Je essayer d'éviter ce genre de code lorsque cela est possible, cependant - il peut être parfois nécessaire, mais l'idée de méthodes génériques est d'être capable d'écrire code générique qui fonctionne de la même manière pour tout type .

Answer 2

Je crois qu'il y a quelque chose qui cloche dans votre conception. Vous souhaitez comparer les types dans une méthode déjà générique. Les génériques sont destinés à traiter une situation de type variable. Je recommande de le faire de cette façon ..

//Generic Overload 1 
public void DoSomething<T>(T t) 
    where T : MyClass 
{ 
    ... 
} 

//Generic Overload 2 
public void DoSomething<T>(T t) 
    where T : List<MyClass> 
{ 
    ... 
} 

Answer 3

Il est 2017 et nous avons maintenant C# 7 avec correspondance de motif. Si votre type T Hériter object vous pouvez vous le code comme ceci

void Main() 
{ 
    DoSomething(new MyClass { a = 5 }); 
    DoSomething(new List<MyClass> { new MyClass { a = 5 }, new MyClass { a = 5 }}); 
} 


public void DoSomething(object t) 
{ 
    switch (t) 
    { 
     case MyClass c: 
      Console.WriteLine($"class.a = {c.a}"); 
      break; 
     case List<MyClass> l: 
      Console.WriteLine($"list.count = {l.Count}"); 
      break; 
    } 
} 

class MyClass 
{ 
    public int a { get; set;} 
} 

Answer 4

A partir de C# 7, vous pouvez le faire de manière concise avec l'opérateur is:

public void DoSomething<T>(T value) 
{ 
    if (value is MyClass mc) 
    { 
     ... 
    } 
    else if (value is List<MyClass> lmc) 
    { 
     ... 
    } 
} 

Voir la documentation: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/is#pattern-matching-with-is