À l’aide de la Case/Switch et GetType pour déterminer l’objet

Question

Double Possible:
C# Est - il une meilleure alternative que de ce "de type"?

Si vous souhaitez switch sur un type d'objet, quelle est la meilleure façon de le faire?

Extrait de Code

private int GetNodeType(NodeDTO node)
{
    switch (node.GetType())
    { 
        case typeof(CasusNodeDTO):
            return 1;
        case typeof(BucketNodeDTO):
            return 3;
        case typeof(BranchNodeDTO):
            return 0;
        case typeof(LeafNodeDTO):
            return 2;
        default:
            return -1;
    }
}

Je sais que cela ne fonctionne pas de cette façon, mais je me demandais comment vous pouvez résoudre ce problème. Est un if/else déclaration appropriée dans ce cas?

Ou vous utilisez le commutateur et d'ajouter .ToString() pour le type?

Answer 1

Ce ne sera pas directement résoudre votre problème que vous voulez allumer vos propres types définis par l’utilisateur, mais au profit de tiers qui ne veulent pas allumer les types intégrés, vous pouvez utiliser l’énumération TypeCode :

Answer 2

Si je devaissur type d’objet, je voudrais utiliser . Cependant, je voudrais l’éviter à tout prix : `` va faire beaucoup mieux, visiteur pourrait être une overdose, mais sinon c’est toujours une solution parfaitement bien.

Answer 3

Dans la MSDN blog de Nombreuses Questions: l'interrupteur sur le type de quelques informations sur le pourquoi .NET ne fournit pas de commutation sur les types.

Comme d'habitude - des solutions de contournement existe toujours.

Ce n'est pas la mienne, mais malheureusement j'ai perdu la source. Il rend la commutation sur les types possibles, mais personnellement, je pense que c'est assez maladroit (le dictionnaire idée est de mieux en mieux):

  public class Switch
  {
      public Switch(Object o)
      {
          Object = o;
      }

      public Object Object { get; private set; }
  }


  /// <summary>
  /// Extensions, because otherwise casing fails on Switch==null
  /// </summary>
  public static class SwitchExtensions
  {
      public static Switch Case<T>(this Switch s, Action<T> a)
            where T : class
      {
          return Case(s, o => true, a, false);
      }

      public static Switch Case<T>(this Switch s, Action<T> a,
           bool fallThrough) where T : class
      {
          return Case(s, o => true, a, fallThrough);
      }

      public static Switch Case<T>(this Switch s,
          Func<T, bool> c, Action<T> a) where T : class
      {
          return Case(s, c, a, false);
      }

      public static Switch Case<T>(this Switch s,
          Func<T, bool> c, Action<T> a, bool fallThrough) where T : class
      {
          if (s == null)
          {
              return null;
          }

          T t = s.Object as T;
          if (t != null)
          {
              if (c(t))
              {
                  a(t);
                  return fallThrough ? s : null;
              }
          }

          return s;
      }
  }

Utilisation:

 new Switch(foo)
     .Case<Fizz>
         (action => { doingSomething = FirstMethodCall(); })
     .Case<Buzz>
         (action => { return false; })

Answer 4

Je suis confronté au même problème et suis tombé sur ce post. Est-ce que l'on entend par l’approche de IDictionary :

Dans l’affirmative, je ne peux pas dire que je suis un fan de concilier les numéros dans le dictionnaire avec les instructions case.

Ce serait idéal, mais la référence de dictionnaire il tue :

Y a-t-il une autre implémentation, que j’ai oublié ?

Answer 5

J’ai eu il suffit d’utiliser un if instruction. Dans ce cas :

L’autre façon de le faire est :

Le premier exemple est vrai pour les types exacts seulement, où ce dernier vérifie aussi pour l’héritage.