Использование Case / Switch и GetType для определения объекта

Если бы мне действительно пришлось switch указать тип объекта, я бы использовал .ToString(). Однако я бы избегал этого любой ценой: IDictionary<Type, int> будет намного лучше, посетитель может оказаться излишним. но в остальном это все еще прекрасное решение.

Это не решит напрямую вашу проблему, поскольку вы хотите включить свои собственные определяемые пользователем типы, но для тех, кто хочет включать только встроенные типы, вы можете использовать TypeCode:

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

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

В сообщении блога MSDN Многие вопросы: включите тип - это некоторая информация о том, почему .NET не поддерживает переключение типов. .

Как обычно - всегда есть обходные пути.

Это не мой, но, к сожалению, я потерял источник. Это делает возможным переключение типов, но лично я считаю это довольно неудобным (идея словаря лучше):

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

Использование:

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

Я столкнулся с той же проблемой и наткнулся на этот пост. Это то, что подразумевается под подходом 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;
    }
}

Если так, я не могу сказать, что я фанат согласования чисел в словаре с операторами case.

Это было бы идеально, но ссылка на словарь убивает его:

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

Есть ли еще одна реализация, которую я упустил?

Я бы просто использовал оператор if. В таком случае:

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

Другой способ сделать это:

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

Первый пример верен только для точных типов, где последний также проверяет наследование.

Ты можешь это сделать:

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

Это понятно и легко. Это немного медленнее, чем где-то кешировать словарь ... но для большого количества кода это все равно не имеет значения ...

Ты можешь это сделать:

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

Хотя это было бы более элегантно, возможно, это не так эффективно, как некоторые другие ответы здесь.

Один из подходов - добавить в NodeDTO чистый виртуальный метод GetNodeType () и переопределить его в потомках, чтобы каждый потомок возвращал фактический тип.

В зависимости от того, что вы делаете в операторе switch, правильный ответ - полиморфизм. Просто поместите виртуальную функцию в интерфейс / базовый класс и переопределите для каждого типа узла.

На самом деле я предпочитаю подход, представленный здесь в качестве ответа: Есть ли лучшая альтернатива" включить тип "?

Однако есть хороший аргумент в пользу отказа от реализации каких-либо методов сравнения типов в объектно-ориентированном языке, таком как C #. В качестве альтернативы вы можете расширить и добавить дополнительные необходимые функции, используя наследование.

Этот момент обсуждался в комментариях к блогу авторов здесь: http://blogs.msdn.com/b/jaredpar/archive/2008/05/16/switching-on-types.aspx#8553535

Я нашел это чрезвычайно интересным моментом, который изменил мой подход в аналогичной ситуации и надеюсь, что это поможет другим.

С уважением, Уэйн