Usando Case / Switch y GetType para determinar el objeto [duplicar]

Esto no resolverá directamente su problema ya que desea cambiar sus propios tipos definidos por el usuario, pero para el beneficio de otros que solo quieren cambiar los tipos integrados, puede usar el código de tipografía enumeración:

switch (Type.GetTypeCode(node.GetType()))
{
    case TypeCode.Decimal:
        // Handle Decimal
        break;

    case TypeCode.Int32:
        // Handle Int32
        break;
     ...
}

En la entrada del blog de MSDN Muchas preguntas: encienda el tipo hay alguna información sobre por qué . NET no proporciona conmutación de tipos.

Como de costumbre - siempre existen soluciones alternativas.

Este no es mío, pero desafortunadamente he perdido la fuente. Hace posible el cambio de tipos, pero personalmente creo que es bastante incómodo (la idea del diccionario es mejor):

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

Uso:

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

Solo usaría una declaración if. En este caso:

Type nodeType = node.GetType();
if (nodeType == typeof(CasusNodeDTO))
{
}
else ... 

La otra forma de hacer esto es:

if (node is CasusNodeDTO)
{
}
else ...

El primer ejemplo es verdadero solo para tipos exactos, donde este último también comprueba la herencia.

Me enfrento al mismo problema y me encontré con este post. ¿Es esto lo que se entiende por el enfoque IDictionary:

Dictionary<Type, int> typeDict = new Dictionary<Type, int>
{
    {typeof(int),0},
    {typeof(string),1},
    {typeof(MyClass),2}
};

void Foo(object o)
{
    switch (typeDict[o.GetType()])
    {
        case 0:
            Print("I'm a number.");
            break;
        case 1:
            Print("I'm a text.");
            break;
        case 2:
            Print("I'm classy.");
            break;
        default:
            break;
    }
}

Si es así, no puedo decir que soy un fan de conciliar los números en el diccionario con las declaraciones de caso.

Esto sería ideal, pero la referencia del diccionario lo mata:

void FantasyFoo(object o)
{
    switch (typeDict[o.GetType()])
    {
        case typeDict[typeof(int)]:
            Print("I'm a number.");
            break;
        case typeDict[typeof(string)]:
            Print("I'm a text.");
            break;
        case typeDict[typeof(MyClass)]:
            Print("I'm classy.");
            break;
        default:
            break;
    }
}

¿Hay otra implementación que he pasado por alto?

Puedes hacer esto:

if (node is CasusNodeDTO)
{
    ...
}
else if (node is BucketNodeDTO)
{
    ...
}
...

Si bien eso sería más elegante, posiblemente no sea tan eficiente como algunas de las otras respuestas aquí.

Puedes hacer esto:

function void PrintType(Type t) {
 var t = true;
 new Dictionary<Type, Action>{
   {typeof(bool), () => Console.WriteLine("bool")},
   {typeof(int),  () => Console.WriteLine("int")}
 }[t.GetType()]();
}

Es claro y fácil. Es un poco más lento que almacenar en caché el diccionario en algún lugar.. pero para un montón de código esto no importará de todos modos..

Un enfoque es agregar un método virtual puro GetNodeType() a NodeDTO y sobrescribirlo en los descendientes para que cada descendiente devuelva el tipo real.

Dependiendo de lo que esté haciendo en la instrucción switch, la respuesta correcta es el polimorfismo. Simplemente coloque una función virtual en la clase interfaz/base y anule para cada tipo de nodo.

Usaría la cadena (Nombre) en la parte superior del interruptor:

  private int GetNodeType(NodeDTO node)
            {
                    switch (node.GetType().Name)
                    { 
                            case "CasusNodeDTO":
                                    return 1;
                                    break;
                            case "BucketNodeDTO":
                                    return 3;
                                    break;
                           // ...

                            default:
                                    return -1;
                                    break;
                    }
            }

En realidad prefiero el enfoque dado como la respuesta aquí: ¿Hay una alternativa mejor que esta para 'activar el tipo'?

Sin embargo, hay un buen argumento acerca de no implementar ningún tipo de comparación methids en un lenguaje orientado a objetos como C#. Como alternativa, podría extender y agregar la funcionalidad adicional requerida utilizando la herencia.

Este punto fue discutido en los comentarios del blog de los autores aqui: http://blogs.msdn.com/b/jaredpar/archive/2008/05/16/switching-on-types.aspx#8553535

Me pareció un punto extremadamente interesante que cambió mi enfoque en una situación similar y solo espero que esto ayude a otros.

Saludos cordiales, Wayne