Is there a better alternative than this to switch on type

Question

Seeing as C  can t switch on a Type  which I gather wasn t added as a special case because is relationships mean that more than one distinct case might apply   is there a better way to simulate switching on type other than this   void Foo object o        if  o is A                  A o  Hop              else if  o is B                  B o  Skip              else               throw new ArgumentException  Unexpected type      o GetType

User · Answer

Create a superclass  S  and make A and B inherit from it  Then declare an abstract method on S that every subclass needs to implement   Doing this the  foo  method can also change its signature to Foo S o   making it type safe  and you don t need to throw that ugly exception

User · Answer

Create an interface IFooable  then make your A and B classes to implement a common method  which in turn calls the corresponding method you want   interface IFooable       public void Foo       class A   IFooable         other methods          public void Foo                 this Hop             class B   IFooable         other methods          public void Foo                 this Skip             class ProcessingClass       public void Foo object o                if  o    null              throw new NullRefferenceException  Null reference    o             IFooable f   o as IFooable          if  f    null                        f Foo                      else                       throw new ArgumentException  Unexpected type      o GetType                         Note  that it s better to use as instead first checking with is and then casting  as that way you make 2 casts  so it s more expensive

User · Answer

Create an interface IFooable  then make your A and B classes to implement a common method  which in turn calls the corresponding method you want   interface IFooable       public void Foo       class A   IFooable         other methods          public void Foo                 this Hop             class B   IFooable         other methods          public void Foo                 this Skip             class ProcessingClass       public void Foo object o                if  o    null              throw new NullRefferenceException  Null reference    o             IFooable f   o as IFooable          if  f    null                        f Foo                      else                       throw new ArgumentException  Unexpected type      o GetType                         Note  that it s better to use as instead first checking with is and then casting  as that way you make 2 casts  so it s more expensive

User · Answer

Another way would be to define an interface IThing and then implement it in both classes  here s the snipet   public interface IThing       void Move       public class ThingA   IThing       public void Move                 Hop               public void Hop                Implementation of Hop            public class ThingA   IThing       public void Move                 Skip               public void Skip               Implementation of Skip               public class Foo       static void Main String   args                    private void Foo IThing a                a Move

User · Answer

Yes - just use the slightly weirdly named  pattern matching  from C 7 upwards to match on class or structure   IObject concrete1   new ObjectImplementation1    IObject concrete2   new ObjectImplementation2     switch  concrete1        case ObjectImplementation1 c1  return  type 1                case ObjectImplementation2 c2  return  type 2

User · Answer

After having compared the options a few answers here provided to F  features  I discovered F  to have a way better support for type-based switching  although I m still sticking to C    You might want to see here and here

User · Answer

If you were using C  4  you could make use of the new dynamic functionality to achieve an interesting alternative  I m not saying this is better  in fact it seems very likely that it would be slower  but it does have a certain elegance to it      class Thing      void Foo A a           a Hop           void Foo B b           b Skip             And the usage   object aOrB   Get AOrB    Thing t   GetThing      dynamic t  Foo aorB     The reason this works is that a C  4 dynamic method invocation has its overloads resolved at runtime rather than compile time  I wrote a little more about this idea quite recently  Again  I would just like to reiterate that this probably performs worse than all the other suggestions  I am offering it simply as a curiosity

User · Answer

I would create an interface with whatever name and method name that would make sense for your switch  let s call them respectively  IDoable that tells to implement void Do     public interface IDoable       void Do       public class A   IDoable       public void Hop                                    public void Do                 Hop             public class B   IDoable       public void Skip                                    public void Do                 Skip              and change the method as follows    void Foo lt T gt  T obj      where T   IDoable                  obj Do                   At least with that you are safe at the compilation-time and I suspect that performance-wise it s better than checking type at runtime

User · Answer

For built-in types  you can use the TypeCode enumeration   Please note that GetType   is kind of slow  but probably not relevant in most situations   switch  Type GetTypeCode someObject GetType           case TypeCode Boolean          break      case TypeCode Byte          break      case TypeCode Char          break      For custom types  you can create your own enumeration  and either an interface or a base class with abstract property or method     Abstract class implementation of property  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public abstract class Foo       public abstract FooTypes FooType   get      public class FooFighter   Foo       public override FooTypes FooType   get   return FooTypes FooFighter          Abstract class implementation of method  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public abstract class Foo       public abstract FooTypes GetFooType      public class FooFighter   Foo       public override FooTypes GetFooType     return FooTypes FooFighter        Interface implementation of property  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public interface IFooType       FooTypes FooType   get      public class FooFighter   IFooType       public FooTypes FooType   get   return FooTypes FooFighter          Interface implementation of method  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public interface IFooType       FooTypes GetFooType      public class FooFighter   IFooType       public FooTypes GetFooType     return FooTypes FooFighter        One of my coworkers just told me about this too  This has the advantage that you can use it for literally any type of object  not just ones that you define   It has the disadvantage of being a bit larger and slower   First define a static class like this   public static class TypeEnumerator       public class TypeEnumeratorException   Exception               public Type unknownType   get  private set            public TypeEnumeratorException Type unknownType    base                         this unknownType   unknownType                      public enum TypeEnumeratorTypes    int   string   Foo   TcpClient         private static Dictionary lt Type  TypeEnumeratorTypes gt  typeDict      static TypeEnumerator                 typeDict   new Dictionary lt Type  TypeEnumeratorTypes gt             typeDict typeof int     TypeEnumeratorTypes  int          typeDict typeof string     TypeEnumeratorTypes  string          typeDict typeof Foo     TypeEnumeratorTypes  Foo          typeDict typeof System Net Sockets TcpClient     TypeEnumeratorTypes  TcpClient                 lt summary gt          Throws NullReferenceException and TypeEnumeratorException lt  summary gt           lt exception cref  System NullReferenceException  gt NullReferenceException lt  exception gt           lt exception cref  MyProject TypeEnumerator TypeEnumeratorException  gt TypeEnumeratorException lt  exception gt      public static TypeEnumeratorTypes EnumerateType object theObject                try                       return typeDict theObject GetType                       catch  KeyNotFoundException                        throw new TypeEnumeratorException theObject GetType                         And then you can use it like this   switch  TypeEnumerator EnumerateType someObject         case TypeEnumerator TypeEnumeratorTypes  int          break      case TypeEnumerator TypeEnumeratorTypes  string          break

User · Answer

You can use pattern matching in C  7 or above   switch  foo GetType          case var type when type    typeof Player           break      case var type when type    typeof Address           break      case var type when type    typeof Department           break      case var type when type    typeof ContactType           break      default          break

User · Answer

With JaredPar s answer in the back of my head  I wrote a variant of his TypeSwitch class that uses type inference for a nicer syntax   class A   string Name   get      class B   A   string LongName   get      class C   A   string FullName   get      class X   public string ToString IFormatProvider provider     class Y   public string GetIdentifier       public string GetName object value        string name   null      TypeSwitch On value           Case  C x    gt  name   x FullName           Case  B x    gt  name   x LongName           Case  A x    gt  name   x Name           Case  X x    gt  name   x ToString CultureInfo CurrentCulture            Case  Y x    gt  name   x GetIdentifier             Default  x    gt  name   x ToString         return name      Note that the order of the Case   methods is important     Get the full and commented code for my TypeSwitch class  This is a working abbreviated version   public static class TypeSwitch       public static Switch lt TSource gt  On lt TSource gt  TSource value                return new Switch lt TSource gt  value              public sealed class Switch lt TSource gt                private readonly TSource value          private bool handled   false           internal Switch TSource value                        this value   value                     public Switch lt TSource gt  Case lt TTarget gt  Action lt TTarget gt  action              where TTarget   TSource                       if   this handled  amp  amp  this value is TTarget                                action  TTarget  this value                   this handled   true                            return this                     public void Default Action lt TSource gt  action                        if   this handled                  action this value

User · Answer

I such cases I usually end up with a list of predicates and actions  Something along these lines   class Mine       static List lt Func lt object  bool gt  gt  predicates      static List lt Action lt object gt  gt  actions       static Mine             AddAction lt A gt  o   gt  o Hop             AddAction lt B gt  o   gt  o Skip                static void AddAction lt T gt  Action lt T gt  action            predicates Add o   gt  o is T           actions Add o   gt  action  T o              static void RunAction object o            for  int i 0  o  lt  predicates Count  i                  if  predicates i  o                     actions i  o                   break                                     void Foo object o            RunAction o

User · Answer

One option is to have a dictionary from Type to Action  or some other delegate   Look up the action based on the type  and then execute it  I ve used this for factories before now

User · Answer

Switching on types is definitely lacking in C   UPDATE  in C 7   VS 2017 switching on types is supported - see Zachary Yates s answer below   In order to do this without a large if else if else statement  you ll need to work with a different structure  I wrote a blog post awhile back detailing how to build a TypeSwitch structure   https   docs microsoft com archive blogs jaredpar switching-on-types  Short version  TypeSwitch is designed to prevent redundant casting and give a syntax that is similar to a normal switch case statement  For example  here is TypeSwitch in action on a standard Windows form event  TypeSwitch Do      sender      TypeSwitch Case lt Button gt       gt  textBox1 Text    Hit a Button        TypeSwitch Case lt CheckBox gt  x   gt  textBox1 Text    Checkbox is     x Checked       TypeSwitch Default      gt  textBox1 Text    Not sure what is hovered over       The code for TypeSwitch is actually pretty small and can easily be put into your project   static class TypeSwitch       public class CaseInfo           public bool IsDefault   get  set            public Type Target   get  set            public Action lt object gt  Action   get  set               public static void Do object source  params CaseInfo   cases            var type   source GetType            foreach  var entry in cases                if  entry IsDefault    entry Target IsAssignableFrom type                     entry Action source                   break                                     public static CaseInfo Case lt T gt  Action action            return new CaseInfo                 Action   x   gt  action                Target   typeof T                        public static CaseInfo Case lt T gt  Action lt T gt  action            return new CaseInfo                 Action    x    gt  action  T x               Target   typeof T                        public static CaseInfo Default Action action            return new CaseInfo                 Action   x   gt  action                IsDefault   true

User · Answer

One option is to have a dictionary from Type to Action  or some other delegate   Look up the action based on the type  and then execute it  I ve used this for factories before now

User · Answer

I would create an interface with whatever name and method name that would make sense for your switch  let s call them respectively  IDoable that tells to implement void Do     public interface IDoable       void Do       public class A   IDoable       public void Hop                                    public void Do                 Hop             public class B   IDoable       public void Skip                                    public void Do                 Skip              and change the method as follows    void Foo lt T gt  T obj      where T   IDoable                  obj Do                   At least with that you are safe at the compilation-time and I suspect that performance-wise it s better than checking type at runtime

User · Answer

Switching on types is definitely lacking in C   UPDATE  in C 7   VS 2017 switching on types is supported - see Zachary Yates s answer below   In order to do this without a large if else if else statement  you ll need to work with a different structure  I wrote a blog post awhile back detailing how to build a TypeSwitch structure   https   docs microsoft com archive blogs jaredpar switching-on-types  Short version  TypeSwitch is designed to prevent redundant casting and give a syntax that is similar to a normal switch case statement  For example  here is TypeSwitch in action on a standard Windows form event  TypeSwitch Do      sender      TypeSwitch Case lt Button gt       gt  textBox1 Text    Hit a Button        TypeSwitch Case lt CheckBox gt  x   gt  textBox1 Text    Checkbox is     x Checked       TypeSwitch Default      gt  textBox1 Text    Not sure what is hovered over       The code for TypeSwitch is actually pretty small and can easily be put into your project   static class TypeSwitch       public class CaseInfo           public bool IsDefault   get  set            public Type Target   get  set            public Action lt object gt  Action   get  set               public static void Do object source  params CaseInfo   cases            var type   source GetType            foreach  var entry in cases                if  entry IsDefault    entry Target IsAssignableFrom type                     entry Action source                   break                                     public static CaseInfo Case lt T gt  Action action            return new CaseInfo                 Action   x   gt  action                Target   typeof T                        public static CaseInfo Case lt T gt  Action lt T gt  action            return new CaseInfo                 Action    x    gt  action  T x               Target   typeof T                        public static CaseInfo Default Action action            return new CaseInfo                 Action   x   gt  action                IsDefault   true

User · Answer

Should work with      case type      like   int i   1  bool b   true  double d   1 1  object o   i     whatever you want  switch  o        case int            Answer Content    You got the int           break      case double            Answer Content    You got the double           break      case bool            Answer Content    You got the bool           break

User · Answer

Should work with      case type      like   int i   1  bool b   true  double d   1 1  object o   i     whatever you want  switch  o        case int            Answer Content    You got the int           break      case double            Answer Content    You got the double           break      case bool            Answer Content    You got the bool           break

User · Answer

I liked Virtlink s use of implicit typing to make the switch much more readable  but I didn t like that an early-out isn t possible  and that we re doing allocations  Let s turn up the perf a little   public static class TypeSwitch       public static void On lt TV  T1 gt  TV value  Action lt T1 gt  action1          where T1   TV               if  value is T1  action1  T1 value              public static void On lt TV  T1  T2 gt  TV value  Action lt T1 gt  action1  Action lt T2 gt  action2          where T1   TV where T2   TV               if  value is T1  action1  T1 value           else if  value is T2  action2  T2 value              public static void On lt TV  T1  T2  T3 gt  TV value  Action lt T1 gt  action1  Action lt T2 gt  action2  Action lt T3 gt  action3          where T1   TV where T2   TV where T3   TV               if  value is T1  action1  T1 value           else if  value is T2  action2  T2 value           else if  value is T3  action3  T3 value                     etc      Well  that makes my fingers hurt  Let s do it in T4    lt    template debug  false  hostSpecific  true  language  C     gt   lt    output extension   cs    gt   lt    Assembly Name  System Core dll    gt   lt    import namespace  System Linq    gt    lt    import namespace  System IO    gt    lt       string GenWarning       THIS FILE IS GENERATED FROM     Path GetFileName Host TemplateFile      - ANY HAND EDITS WILL BE LOST        const int MaxCases   15    gt   lt   GenWarning  gt   using System   public static class TypeSwitch    lt   for int icase   1  icase  lt   MaxCases    icase        var types   string Join       Enumerable Range 1  icase  Select i   gt   T    i        var actions   string Join       Enumerable Range 1  icase  Select i   gt  string Format  Action lt T 0  gt  action 0    i         var wheres   string Join      Enumerable Range 1  icase  Select i   gt  string Format  where T 0    TV   i       gt       lt   GenWarning  gt       public static void On lt TV   lt   types  gt  gt  TV value   lt   actions  gt            lt   wheres  gt                if  value is T1  action1  T1 value    lt   for int i   2  i  lt   icase    i      gt          else if  value is T lt   i  gt   action lt   i  gt   T lt   i  gt  value    lt     gt          lt     gt       lt   GenWarning  gt      Adjusting Virtlink s example a little   TypeSwitch On operand       C x    gt  name   x FullName       B x    gt  name   x LongName       A x    gt  name   x Name       X x    gt  name   x ToString CultureInfo CurrentCulture        Y x    gt  name   x GetIdentifier         object x    gt  name   x ToString       Readable and fast  Now  as everybody keeps pointing out in their answers  and given the nature of this question  order is important in the type matching  Therefore    Put leaf types first  base types later  For peer types  put more likely matches first to maximize perf  This implies that there is no need for a special default case  Instead  just use the base-most type in the lambda  and put it last

User · Answer

If you know the class you are expecting but you still don t have an object you can even do this   private string GetAcceptButtonText lt T gt    where T   BaseClass  new         switch  new T                  case BaseClassReview    return  Review           case BaseClassValidate    return  Validate           case BaseClassAcknowledge    return  Acknowledge           default  return  Accept

User · Answer

For built-in types  you can use the TypeCode enumeration   Please note that GetType   is kind of slow  but probably not relevant in most situations   switch  Type GetTypeCode someObject GetType           case TypeCode Boolean          break      case TypeCode Byte          break      case TypeCode Char          break      For custom types  you can create your own enumeration  and either an interface or a base class with abstract property or method     Abstract class implementation of property  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public abstract class Foo       public abstract FooTypes FooType   get      public class FooFighter   Foo       public override FooTypes FooType   get   return FooTypes FooFighter          Abstract class implementation of method  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public abstract class Foo       public abstract FooTypes GetFooType      public class FooFighter   Foo       public override FooTypes GetFooType     return FooTypes FooFighter        Interface implementation of property  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public interface IFooType       FooTypes FooType   get      public class FooFighter   IFooType       public FooTypes FooType   get   return FooTypes FooFighter          Interface implementation of method  public enum FooTypes   FooFighter  AbbreviatedFool  Fubar  Fugu    public interface IFooType       FooTypes GetFooType      public class FooFighter   IFooType       public FooTypes GetFooType     return FooTypes FooFighter        One of my coworkers just told me about this too  This has the advantage that you can use it for literally any type of object  not just ones that you define   It has the disadvantage of being a bit larger and slower   First define a static class like this   public static class TypeEnumerator       public class TypeEnumeratorException   Exception               public Type unknownType   get  private set            public TypeEnumeratorException Type unknownType    base                         this unknownType   unknownType                      public enum TypeEnumeratorTypes    int   string   Foo   TcpClient         private static Dictionary lt Type  TypeEnumeratorTypes gt  typeDict      static TypeEnumerator                 typeDict   new Dictionary lt Type  TypeEnumeratorTypes gt             typeDict typeof int     TypeEnumeratorTypes  int          typeDict typeof string     TypeEnumeratorTypes  string          typeDict typeof Foo     TypeEnumeratorTypes  Foo          typeDict typeof System Net Sockets TcpClient     TypeEnumeratorTypes  TcpClient                 lt summary gt          Throws NullReferenceException and TypeEnumeratorException lt  summary gt           lt exception cref  System NullReferenceException  gt NullReferenceException lt  exception gt           lt exception cref  MyProject TypeEnumerator TypeEnumeratorException  gt TypeEnumeratorException lt  exception gt      public static TypeEnumeratorTypes EnumerateType object theObject                try                       return typeDict theObject GetType                       catch  KeyNotFoundException                        throw new TypeEnumeratorException theObject GetType                         And then you can use it like this   switch  TypeEnumerator EnumerateType someObject         case TypeEnumerator TypeEnumeratorTypes  int          break      case TypeEnumerator TypeEnumeratorTypes  string          break

User · Answer

With C  7  which shipped with Visual Studio 2017  Release 15     you are able to use Types in case statements  pattern matching    switch shape        case Circle c          WriteLine   circle with radius  c Radius             break      case Rectangle s when  s Length    s Height           WriteLine    s Length  x  s Height  square            break      case Rectangle r          WriteLine    r Length  x  r Height  rectangle            break      default          WriteLine   lt unknown shape gt             break      case null          throw new ArgumentNullException nameof shape        With C  6  you can use a switch statement with the nameof   operator  thanks  Joey Adams    switch o GetType   Name        case nameof AType           break      case nameof BType           break      With C  5 and earlier  you could use a switch statement  but you ll have to use a magic string containing the type name    which is not particularly refactor friendly  thanks  nukefusion   switch o GetType   Name      case  AType       break

User · Answer

I would either   use method overloading  just like x0n   or use subclasses  just like Pablo   or apply the visitor pattern

User · Answer

With C  7  which shipped with Visual Studio 2017  Release 15     you are able to use Types in case statements  pattern matching    switch shape        case Circle c          WriteLine   circle with radius  c Radius             break      case Rectangle s when  s Length    s Height           WriteLine    s Length  x  s Height  square            break      case Rectangle r          WriteLine    r Length  x  r Height  rectangle            break      default          WriteLine   lt unknown shape gt             break      case null          throw new ArgumentNullException nameof shape        With C  6  you can use a switch statement with the nameof   operator  thanks  Joey Adams    switch o GetType   Name        case nameof AType           break      case nameof BType           break      With C  5 and earlier  you could use a switch statement  but you ll have to use a magic string containing the type name    which is not particularly refactor friendly  thanks  nukefusion   switch o GetType   Name      case  AType       break

User · Answer

Create a superclass  S  and make A and B inherit from it  Then declare an abstract method on S that every subclass needs to implement   Doing this the  foo  method can also change its signature to Foo S o   making it type safe  and you don t need to throw that ugly exception

User · Answer

Create an interface IFooable  then make your A and B classes to implement a common method  which in turn calls the corresponding method you want   interface IFooable       public void Foo       class A   IFooable         other methods          public void Foo                 this Hop             class B   IFooable         other methods          public void Foo                 this Skip             class ProcessingClass       public void Foo object o                if  o    null              throw new NullRefferenceException  Null reference    o             IFooable f   o as IFooable          if  f    null                        f Foo                      else                       throw new ArgumentException  Unexpected type      o GetType                         Note  that it s better to use as instead first checking with is and then casting  as that way you make 2 casts  so it s more expensive

User · Answer

You can use pattern matching in C  7 or above   switch  foo GetType          case var type when type    typeof Player           break      case var type when type    typeof Address           break      case var type when type    typeof Department           break      case var type when type    typeof ContactType           break      default          break

User · Answer

With C  8 onwards you can make it even more concise with the new switch  And with the use of discard option   you can avoid creating innecesary variables when you don t need them  like this           return document switch               Invoice     gt   Is Invoice               ShippingList     gt   Is Shipping List                   gt   Unknown               Invoice and ShippingList are classes and document is an object that can be either of them

User · Answer

Another way would be to define an interface IThing and then implement it in both classes  here s the snipet   public interface IThing       void Move       public class ThingA   IThing       public void Move                 Hop               public void Hop                Implementation of Hop            public class ThingA   IThing       public void Move                 Skip               public void Skip               Implementation of Skip               public class Foo       static void Main String   args                    private void Foo IThing a                a Move

User · Answer

You re looking for Discriminated Unions which are a language feature of F   but you can achieve a similar effect by using a library I made  called OneOf   https   github com mcintyre321 OneOf  The major advantage over switch  and if and exceptions as control flow  is that it is compile-time safe - there is no default handler or fall through  void Foo OneOf lt A  B gt  o        o Switch          a   gt  a Hop            b   gt  b Skip              If you add a third item to o  you ll get a compiler error as you have to add a handler Func inside the switch call   You can also do a  Match which returns a value  rather than executes a statement   double Area OneOf lt Square  Circle gt  o        return o Match          square   gt  square Length   square Length          circle   gt  Math PI   circle Radius   circle Radius

User · Answer

You should really be overloading your method  not trying to do the disambiguation yourself   Most of the answers so far don t take future subclasses into account  which may lead to really terrible maintenance issues later on

User · Answer

Given inheritance facilitates an object to be recognized as more than one type  I think a switch could lead to bad ambiguity  For example   Case 1      string s    a     if  s is string  Print  Foo      else if  s is object  Print  Bar        Case 2      string s    a     if  s is object  Print  Foo      else if  s is string  Print  Bar        Because s is a string and an object  I think when you write a switch foo  you expect foo to match one and only one of the case statements  With a switch on types  the order in which you write your case statements could possibly change the result of the whole switch statement  I think that would be wrong   You could think of a compiler-check on the types of a  typeswitch  statement  checking that the enumerated types do not inherit from each other  That doesn t exist though   foo is T is not the same as foo GetType      typeof T

User · Answer

Yes  thanks to C  7 that can be achieved  Here s how it s done  using expression pattern    switch  o        case A a          a Hop            break      case B b          b Skip            break      case C             return new ArgumentException  Type C will be supported in the next version        default          return new ArgumentException  Unexpected type      o GetType

User · Answer

I liked Virtlink s use of implicit typing to make the switch much more readable  but I didn t like that an early-out isn t possible  and that we re doing allocations  Let s turn up the perf a little   public static class TypeSwitch       public static void On lt TV  T1 gt  TV value  Action lt T1 gt  action1          where T1   TV               if  value is T1  action1  T1 value              public static void On lt TV  T1  T2 gt  TV value  Action lt T1 gt  action1  Action lt T2 gt  action2          where T1   TV where T2   TV               if  value is T1  action1  T1 value           else if  value is T2  action2  T2 value              public static void On lt TV  T1  T2  T3 gt  TV value  Action lt T1 gt  action1  Action lt T2 gt  action2  Action lt T3 gt  action3          where T1   TV where T2   TV where T3   TV               if  value is T1  action1  T1 value           else if  value is T2  action2  T2 value           else if  value is T3  action3  T3 value                     etc      Well  that makes my fingers hurt  Let s do it in T4    lt    template debug  false  hostSpecific  true  language  C     gt   lt    output extension   cs    gt   lt    Assembly Name  System Core dll    gt   lt    import namespace  System Linq    gt    lt    import namespace  System IO    gt    lt       string GenWarning       THIS FILE IS GENERATED FROM     Path GetFileName Host TemplateFile      - ANY HAND EDITS WILL BE LOST        const int MaxCases   15    gt   lt   GenWarning  gt   using System   public static class TypeSwitch    lt   for int icase   1  icase  lt   MaxCases    icase        var types   string Join       Enumerable Range 1  icase  Select i   gt   T    i        var actions   string Join       Enumerable Range 1  icase  Select i   gt  string Format  Action lt T 0  gt  action 0    i         var wheres   string Join      Enumerable Range 1  icase  Select i   gt  string Format  where T 0    TV   i       gt       lt   GenWarning  gt       public static void On lt TV   lt   types  gt  gt  TV value   lt   actions  gt            lt   wheres  gt                if  value is T1  action1  T1 value    lt   for int i   2  i  lt   icase    i      gt          else if  value is T lt   i  gt   action lt   i  gt   T lt   i  gt  value    lt     gt          lt     gt       lt   GenWarning  gt      Adjusting Virtlink s example a little   TypeSwitch On operand       C x    gt  name   x FullName       B x    gt  name   x LongName       A x    gt  name   x Name       X x    gt  name   x ToString CultureInfo CurrentCulture        Y x    gt  name   x GetIdentifier         object x    gt  name   x ToString       Readable and fast  Now  as everybody keeps pointing out in their answers  and given the nature of this question  order is important in the type matching  Therefore    Put leaf types first  base types later  For peer types  put more likely matches first to maximize perf  This implies that there is no need for a special default case  Instead  just use the base-most type in the lambda  and put it last

User · Answer

I use      public T Store lt T gt                  Type t   typeof T            if  t    typeof CategoryDataStore               return  T DependencyService Get lt IDataStore lt ItemCategory gt  gt             else             return default T

User · Answer

With C  7  which shipped with Visual Studio 2017  Release 15     you are able to use Types in case statements  pattern matching    switch shape        case Circle c          WriteLine   circle with radius  c Radius             break      case Rectangle s when  s Length    s Height           WriteLine    s Length  x  s Height  square            break      case Rectangle r          WriteLine    r Length  x  r Height  rectangle            break      default          WriteLine   lt unknown shape gt             break      case null          throw new ArgumentNullException nameof shape        With C  6  you can use a switch statement with the nameof   operator  thanks  Joey Adams    switch o GetType   Name        case nameof AType           break      case nameof BType           break      With C  5 and earlier  you could use a switch statement  but you ll have to use a magic string containing the type name    which is not particularly refactor friendly  thanks  nukefusion   switch o GetType   Name      case  AType       break

User · Answer

If you were using C  4  you could make use of the new dynamic functionality to achieve an interesting alternative  I m not saying this is better  in fact it seems very likely that it would be slower  but it does have a certain elegance to it      class Thing      void Foo A a           a Hop           void Foo B b           b Skip             And the usage   object aOrB   Get AOrB    Thing t   GetThing      dynamic t  Foo aorB     The reason this works is that a C  4 dynamic method invocation has its overloads resolved at runtime rather than compile time  I wrote a little more about this idea quite recently  Again  I would just like to reiterate that this probably performs worse than all the other suggestions  I am offering it simply as a curiosity

User · Answer

I would either   use method overloading  just like x0n   or use subclasses  just like Pablo   or apply the visitor pattern

User · Answer

You should really be overloading your method  not trying to do the disambiguation yourself   Most of the answers so far don t take future subclasses into account  which may lead to really terrible maintenance issues later on

User · Answer

After having compared the options a few answers here provided to F  features  I discovered F  to have a way better support for type-based switching  although I m still sticking to C    You might want to see here and here

User · Answer

This is an alternate answer that mixes contributions from JaredPar and VirtLink answers  with the following constraints    The switch construction behaves as a function  and receives functions as parameters to cases  Ensures that it is properly built  and there always exists a default function  It returns after first match  true for JaredPar answer  not true for VirtLink one     Usage    var result       TSwitch lt string gt        On val        Case  string x    gt   is a string         Case  long x    gt   is a long         Default     gt   what is it       Code   public class TSwitch lt TResult gt        class CaseInfo lt T gt                public Type Target   get  set            public Func lt object  T gt  Func   get  set               private object  source      private List lt CaseInfo lt TResult gt  gt   cases       public static TSwitch lt TResult gt  On object source                return new TSwitch lt TResult gt                  source   source               cases   new List lt CaseInfo lt TResult gt  gt                          public TResult Default Func lt object  TResult gt  defaultFunc                var srcType    source GetType           foreach  var entry in  cases              if  entry Target IsAssignableFrom srcType                   return entry Func  source            return defaultFunc  source              public TSwitch lt TResult gt  Case lt TSource gt  Func lt TSource  TResult gt  func                 cases Add new CaseInfo lt TResult gt                        Func   x   gt  func  TSource x               Target   typeof TSource                      return this

User · Answer

Yes  thanks to C  7 that can be achieved  Here s how it s done  using expression pattern    switch  o        case A a          a Hop            break      case B b          b Skip            break      case C             return new ArgumentException  Type C will be supported in the next version        default          return new ArgumentException  Unexpected type      o GetType

User · Answer

With JaredPar s answer in the back of my head  I wrote a variant of his TypeSwitch class that uses type inference for a nicer syntax   class A   string Name   get      class B   A   string LongName   get      class C   A   string FullName   get      class X   public string ToString IFormatProvider provider     class Y   public string GetIdentifier       public string GetName object value        string name   null      TypeSwitch On value           Case  C x    gt  name   x FullName           Case  B x    gt  name   x LongName           Case  A x    gt  name   x Name           Case  X x    gt  name   x ToString CultureInfo CurrentCulture            Case  Y x    gt  name   x GetIdentifier             Default  x    gt  name   x ToString         return name      Note that the order of the Case   methods is important     Get the full and commented code for my TypeSwitch class  This is a working abbreviated version   public static class TypeSwitch       public static Switch lt TSource gt  On lt TSource gt  TSource value                return new Switch lt TSource gt  value              public sealed class Switch lt TSource gt                private readonly TSource value          private bool handled   false           internal Switch TSource value                        this value   value                     public Switch lt TSource gt  Case lt TTarget gt  Action lt TTarget gt  action              where TTarget   TSource                       if   this handled  amp  amp  this value is TTarget                                action  TTarget  this value                   this handled   true                            return this                     public void Default Action lt TSource gt  action                        if   this handled                  action this value

User · Answer

C  8 enhancements of pattern matching made it possible to do it like this  In some cases it do the job and more concise           public Animal Animal   get  set                        var animalName   Animal switch                       Cat cat   gt   Tom               Mouse mouse   gt   Jerry                   gt   unknown

User · Answer

I agree with Jon about having a hash of actions to class name   If you keep your pattern  you might want to consider using the  as  construct instead   A a   o as A  if  a    null        a Hop        return    B b   o as B  if  b    null        b Skip        return    throw new ArgumentException           The difference is that when you use the patter if  foo is Bar      Bar foo  Action      you re doing the type casting twice   Now maybe the compiler will optimize and only do that work once - but I wouldn t count on it

User · Answer

C  8 enhancements of pattern matching made it possible to do it like this  In some cases it do the job and more concise           public Animal Animal   get  set                        var animalName   Animal switch                       Cat cat   gt   Tom               Mouse mouse   gt   Jerry                   gt   unknown

User · Answer

As per C  7 0 specification  you can declare a local variable scoped in a case of a switch   object a    Hello world   switch  a        case string myString             The variable  a  is a string          break      case int myInt             The variable  a  is an int          break      case Foo myFoo             The variable  a  is of type Foo          break        This is the best way to do such a thing because it involves just casting and push-on-the-stack operations  which are the fastest operations an interpreter can run just after bitwise operations and boolean conditions     Comparing this to a Dictionary lt K  V gt   here s much less memory usage  holding a dictionary requires more space in the RAM and some computation more by the CPU for creating two arrays  one for keys and the other for values  and gathering hash codes for the keys to put values to their respective keys     So  for as far I know  I don t believe that a faster way could exist unless you want to use just an if-then-else block with the is operator as follows   object a    Hello world   if  a is string           The variable  a  is a string    else if  a is int           The variable  a  is an int       etc

User · Answer

I such cases I usually end up with a list of predicates and actions  Something along these lines   class Mine       static List lt Func lt object  bool gt  gt  predicates      static List lt Action lt object gt  gt  actions       static Mine             AddAction lt A gt  o   gt  o Hop             AddAction lt B gt  o   gt  o Skip                static void AddAction lt T gt  Action lt T gt  action            predicates Add o   gt  o is T           actions Add o   gt  action  T o              static void RunAction object o            for  int i 0  o  lt  predicates Count  i                  if  predicates i  o                     actions i  o                   break                                     void Foo object o            RunAction o

User · Answer

You can create overloaded methods   void Foo A a          a Hop        void Foo B b          b Skip        void Foo object o          throw new ArgumentException  Unexpected type      o GetType          And cast the argument to dynamic type in order to bypass static type checking   Foo  dynamic something

User · Answer

Create an interface IFooable  then make your A and B classes to implement a common method  which in turn calls the corresponding method you want   interface IFooable       public void Foo       class A   IFooable         other methods          public void Foo                 this Hop             class B   IFooable         other methods          public void Foo                 this Skip             class ProcessingClass       public void Foo object o                if  o    null              throw new NullRefferenceException  Null reference    o             IFooable f   o as IFooable          if  f    null                        f Foo                      else                       throw new ArgumentException  Unexpected type      o GetType                         Note  that it s better to use as instead first checking with is and then casting  as that way you make 2 casts  so it s more expensive

User · Answer

Try to go that way  public void Test BaseType  base        switch   base                case ConcreteType concrete              DoSomething concrete               break           case AnotherConcrete concrete              DoSomething concrete               break

User · Answer

With C  7  which shipped with Visual Studio 2017  Release 15     you are able to use Types in case statements  pattern matching    switch shape        case Circle c          WriteLine   circle with radius  c Radius             break      case Rectangle s when  s Length    s Height           WriteLine    s Length  x  s Height  square            break      case Rectangle r          WriteLine    r Length  x  r Height  rectangle            break      default          WriteLine   lt unknown shape gt             break      case null          throw new ArgumentNullException nameof shape        With C  6  you can use a switch statement with the nameof   operator  thanks  Joey Adams    switch o GetType   Name        case nameof AType           break      case nameof BType           break      With C  5 and earlier  you could use a switch statement  but you ll have to use a magic string containing the type name    which is not particularly refactor friendly  thanks  nukefusion   switch o GetType   Name      case  AType       break

User · Answer

If you know the class you are expecting but you still don t have an object you can even do this   private string GetAcceptButtonText lt T gt    where T   BaseClass  new         switch  new T                  case BaseClassReview    return  Review           case BaseClassValidate    return  Validate           case BaseClassAcknowledge    return  Acknowledge           default  return  Accept

User · Answer

I agree with Jon about having a hash of actions to class name   If you keep your pattern  you might want to consider using the  as  construct instead   A a   o as A  if  a    null        a Hop        return    B b   o as B  if  b    null        b Skip        return    throw new ArgumentException           The difference is that when you use the patter if  foo is Bar      Bar foo  Action      you re doing the type casting twice   Now maybe the compiler will optimize and only do that work once - but I wouldn t count on it

User · Answer

You re looking for Discriminated Unions which are a language feature of F   but you can achieve a similar effect by using a library I made  called OneOf   https   github com mcintyre321 OneOf  The major advantage over switch  and if and exceptions as control flow  is that it is compile-time safe - there is no default handler or fall through  void Foo OneOf lt A  B gt  o        o Switch          a   gt  a Hop            b   gt  b Skip              If you add a third item to o  you ll get a compiler error as you have to add a handler Func inside the switch call   You can also do a  Match which returns a value  rather than executes a statement   double Area OneOf lt Square  Circle gt  o        return o Match          square   gt  square Length   square Length          circle   gt  Math PI   circle Radius   circle Radius

User · Answer

I would either   use method overloading  just like x0n   or use subclasses  just like Pablo   or apply the visitor pattern

User · Answer

As per C  7 0 specification  you can declare a local variable scoped in a case of a switch   object a    Hello world   switch  a        case string myString             The variable  a  is a string          break      case int myInt             The variable  a  is an int          break      case Foo myFoo             The variable  a  is of type Foo          break        This is the best way to do such a thing because it involves just casting and push-on-the-stack operations  which are the fastest operations an interpreter can run just after bitwise operations and boolean conditions     Comparing this to a Dictionary lt K  V gt   here s much less memory usage  holding a dictionary requires more space in the RAM and some computation more by the CPU for creating two arrays  one for keys and the other for values  and gathering hash codes for the keys to put values to their respective keys     So  for as far I know  I don t believe that a faster way could exist unless you want to use just an if-then-else block with the is operator as follows   object a    Hello world   if  a is string           The variable  a  is a string    else if  a is int           The variable  a  is an int       etc

User · Answer

With C  8 onwards you can make it even more concise with the new switch  And with the use of discard option   you can avoid creating innecesary variables when you don t need them  like this           return document switch               Invoice     gt   Is Invoice               ShippingList     gt   Is Shipping List                   gt   Unknown               Invoice and ShippingList are classes and document is an object that can be either of them

User · Answer

I agree with Jon about having a hash of actions to class name   If you keep your pattern  you might want to consider using the  as  construct instead   A a   o as A  if  a    null        a Hop        return    B b   o as B  if  b    null        b Skip        return    throw new ArgumentException           The difference is that when you use the patter if  foo is Bar      Bar foo  Action      you re doing the type casting twice   Now maybe the compiler will optimize and only do that work once - but I wouldn t count on it

User · Answer

Another way would be to define an interface IThing and then implement it in both classes  here s the snipet   public interface IThing       void Move       public class ThingA   IThing       public void Move                 Hop               public void Hop                Implementation of Hop            public class ThingA   IThing       public void Move                 Skip               public void Skip               Implementation of Skip               public class Foo       static void Main String   args                    private void Foo IThing a                a Move

User · Answer

I use      public T Store lt T gt                  Type t   typeof T            if  t    typeof CategoryDataStore               return  T DependencyService Get lt IDataStore lt ItemCategory gt  gt             else             return default T

User · Answer

Yes - just use the slightly weirdly named  pattern matching  from C 7 upwards to match on class or structure   IObject concrete1   new ObjectImplementation1    IObject concrete2   new ObjectImplementation2     switch  concrete1        case ObjectImplementation1 c1  return  type 1                case ObjectImplementation2 c2  return  type 2

User · Answer

As Pablo suggests  interface approach is almost always the right thing to do to handle this  To really utilize switch  another alternative is to have a custom enum denoting your type in your classes   enum ObjectType   A  B  Default    interface IIdentifiable       ObjectType Type   get       class A   IIdentifiable       public ObjectType Type   get   return ObjectType A         class B   IIdentifiable       public ObjectType Type   get   return ObjectType B         void Foo IIdentifiable o        switch  o Type                case ObjectType A          case ObjectType B                             This is kind of implemented in BCL too  One example is MemberInfo MemberTypes  another is GetTypeCode for primitive types  like   void Foo object o        switch  Type GetTypeCode o GetType        for IConvertible  just o GetTypeCode                 case TypeCode Int16          case TypeCode Int32            etc

User · Answer

After having compared the options a few answers here provided to F  features  I discovered F  to have a way better support for type-based switching  although I m still sticking to C    You might want to see here and here

User · Answer

You can create overloaded methods   void Foo A a          a Hop        void Foo B b          b Skip        void Foo object o          throw new ArgumentException  Unexpected type      o GetType          And cast the argument to dynamic type in order to bypass static type checking   Foo  dynamic something

User · Answer

As Pablo suggests  interface approach is almost always the right thing to do to handle this  To really utilize switch  another alternative is to have a custom enum denoting your type in your classes   enum ObjectType   A  B  Default    interface IIdentifiable       ObjectType Type   get       class A   IIdentifiable       public ObjectType Type   get   return ObjectType A         class B   IIdentifiable       public ObjectType Type   get   return ObjectType B         void Foo IIdentifiable o        switch  o Type                case ObjectType A          case ObjectType B                             This is kind of implemented in BCL too  One example is MemberInfo MemberTypes  another is GetTypeCode for primitive types  like   void Foo object o        switch  Type GetTypeCode o GetType        for IConvertible  just o GetTypeCode                 case TypeCode Int16          case TypeCode Int32            etc

User · Answer

You should really be overloading your method  not trying to do the disambiguation yourself   Most of the answers so far don t take future subclasses into account  which may lead to really terrible maintenance issues later on

User · Answer

You should really be overloading your method  not trying to do the disambiguation yourself   Most of the answers so far don t take future subclasses into account  which may lead to really terrible maintenance issues later on

User · Answer

I would either   use method overloading  just like x0n   or use subclasses  just like Pablo   or apply the visitor pattern

User · Answer

Try to go that way  public void Test BaseType  base        switch   base                case ConcreteType concrete              DoSomething concrete               break           case AnotherConcrete concrete              DoSomething concrete               break

User · Answer

Another way would be to define an interface IThing and then implement it in both classes  here s the snipet   public interface IThing       void Move       public class ThingA   IThing       public void Move                 Hop               public void Hop                Implementation of Hop            public class ThingA   IThing       public void Move                 Skip               public void Skip               Implementation of Skip               public class Foo       static void Main String   args                    private void Foo IThing a                a Move

User · Answer

I such cases I usually end up with a list of predicates and actions  Something along these lines   class Mine       static List lt Func lt object  bool gt  gt  predicates      static List lt Action lt object gt  gt  actions       static Mine             AddAction lt A gt  o   gt  o Hop             AddAction lt B gt  o   gt  o Skip                static void AddAction lt T gt  Action lt T gt  action            predicates Add o   gt  o is T           actions Add o   gt  action  T o              static void RunAction object o            for  int i 0  o  lt  predicates Count  i                  if  predicates i  o                     actions i  o                   break                                     void Foo object o            RunAction o

User · Answer

If you were using C  4  you could make use of the new dynamic functionality to achieve an interesting alternative  I m not saying this is better  in fact it seems very likely that it would be slower  but it does have a certain elegance to it      class Thing      void Foo A a           a Hop           void Foo B b           b Skip             And the usage   object aOrB   Get AOrB    Thing t   GetThing      dynamic t  Foo aorB     The reason this works is that a C  4 dynamic method invocation has its overloads resolved at runtime rather than compile time  I wrote a little more about this idea quite recently  Again  I would just like to reiterate that this probably performs worse than all the other suggestions  I am offering it simply as a curiosity

User · Answer

Switching on types is definitely lacking in C   UPDATE  in C 7   VS 2017 switching on types is supported - see Zachary Yates s answer below   In order to do this without a large if else if else statement  you ll need to work with a different structure  I wrote a blog post awhile back detailing how to build a TypeSwitch structure   https   docs microsoft com archive blogs jaredpar switching-on-types  Short version  TypeSwitch is designed to prevent redundant casting and give a syntax that is similar to a normal switch case statement  For example  here is TypeSwitch in action on a standard Windows form event  TypeSwitch Do      sender      TypeSwitch Case lt Button gt       gt  textBox1 Text    Hit a Button        TypeSwitch Case lt CheckBox gt  x   gt  textBox1 Text    Checkbox is     x Checked       TypeSwitch Default      gt  textBox1 Text    Not sure what is hovered over       The code for TypeSwitch is actually pretty small and can easily be put into your project   static class TypeSwitch       public class CaseInfo           public bool IsDefault   get  set            public Type Target   get  set            public Action lt object gt  Action   get  set               public static void Do object source  params CaseInfo   cases            var type   source GetType            foreach  var entry in cases                if  entry IsDefault    entry Target IsAssignableFrom type                     entry Action source                   break                                     public static CaseInfo Case lt T gt  Action action            return new CaseInfo                 Action   x   gt  action                Target   typeof T                        public static CaseInfo Case lt T gt  Action lt T gt  action            return new CaseInfo                 Action    x    gt  action  T x               Target   typeof T                        public static CaseInfo Default Action action            return new CaseInfo                 Action   x   gt  action                IsDefault   true

User · Answer

One option is to have a dictionary from Type to Action  or some other delegate   Look up the action based on the type  and then execute it  I ve used this for factories before now

User · Answer

I such cases I usually end up with a list of predicates and actions  Something along these lines   class Mine       static List lt Func lt object  bool gt  gt  predicates      static List lt Action lt object gt  gt  actions       static Mine             AddAction lt A gt  o   gt  o Hop             AddAction lt B gt  o   gt  o Skip                static void AddAction lt T gt  Action lt T gt  action            predicates Add o   gt  o is T           actions Add o   gt  action  T o              static void RunAction object o            for  int i 0  o  lt  predicates Count  i                  if  predicates i  o                     actions i  o                   break                                     void Foo object o            RunAction o

User · Answer

Create a superclass  S  and make A and B inherit from it  Then declare an abstract method on S that every subclass needs to implement   Doing this the  foo  method can also change its signature to Foo S o   making it type safe  and you don t need to throw that ugly exception

User · Answer

If you were using C  4  you could make use of the new dynamic functionality to achieve an interesting alternative  I m not saying this is better  in fact it seems very likely that it would be slower  but it does have a certain elegance to it      class Thing      void Foo A a           a Hop           void Foo B b           b Skip             And the usage   object aOrB   Get AOrB    Thing t   GetThing      dynamic t  Foo aorB     The reason this works is that a C  4 dynamic method invocation has its overloads resolved at runtime rather than compile time  I wrote a little more about this idea quite recently  Again  I would just like to reiterate that this probably performs worse than all the other suggestions  I am offering it simply as a curiosity

User · Answer

After having compared the options a few answers here provided to F  features  I discovered F  to have a way better support for type-based switching  although I m still sticking to C    You might want to see here and here

User · Answer

This is an alternate answer that mixes contributions from JaredPar and VirtLink answers  with the following constraints    The switch construction behaves as a function  and receives functions as parameters to cases  Ensures that it is properly built  and there always exists a default function  It returns after first match  true for JaredPar answer  not true for VirtLink one     Usage    var result       TSwitch lt string gt        On val        Case  string x    gt   is a string         Case  long x    gt   is a long         Default     gt   what is it       Code   public class TSwitch lt TResult gt        class CaseInfo lt T gt                public Type Target   get  set            public Func lt object  T gt  Func   get  set               private object  source      private List lt CaseInfo lt TResult gt  gt   cases       public static TSwitch lt TResult gt  On object source                return new TSwitch lt TResult gt                  source   source               cases   new List lt CaseInfo lt TResult gt  gt                          public TResult Default Func lt object  TResult gt  defaultFunc                var srcType    source GetType           foreach  var entry in  cases              if  entry Target IsAssignableFrom srcType                   return entry Func  source            return defaultFunc  source              public TSwitch lt TResult gt  Case lt TSource gt  Func lt TSource  TResult gt  func                 cases Add new CaseInfo lt TResult gt                        Func   x   gt  func  TSource x               Target   typeof TSource                      return this

User · Answer

Given inheritance facilitates an object to be recognized as more than one type  I think a switch could lead to bad ambiguity  For example   Case 1      string s    a     if  s is string  Print  Foo      else if  s is object  Print  Bar        Case 2      string s    a     if  s is object  Print  Foo      else if  s is string  Print  Bar        Because s is a string and an object  I think when you write a switch foo  you expect foo to match one and only one of the case statements  With a switch on types  the order in which you write your case statements could possibly change the result of the whole switch statement  I think that would be wrong   You could think of a compiler-check on the types of a  typeswitch  statement  checking that the enumerated types do not inherit from each other  That doesn t exist though   foo is T is not the same as foo GetType      typeof T

User · Answer

Switching on types is definitely lacking in C   UPDATE  in C 7   VS 2017 switching on types is supported - see Zachary Yates s answer below   In order to do this without a large if else if else statement  you ll need to work with a different structure  I wrote a blog post awhile back detailing how to build a TypeSwitch structure   https   docs microsoft com archive blogs jaredpar switching-on-types  Short version  TypeSwitch is designed to prevent redundant casting and give a syntax that is similar to a normal switch case statement  For example  here is TypeSwitch in action on a standard Windows form event  TypeSwitch Do      sender      TypeSwitch Case lt Button gt       gt  textBox1 Text    Hit a Button        TypeSwitch Case lt CheckBox gt  x   gt  textBox1 Text    Checkbox is     x Checked       TypeSwitch Default      gt  textBox1 Text    Not sure what is hovered over       The code for TypeSwitch is actually pretty small and can easily be put into your project   static class TypeSwitch       public class CaseInfo           public bool IsDefault   get  set            public Type Target   get  set            public Action lt object gt  Action   get  set               public static void Do object source  params CaseInfo   cases            var type   source GetType            foreach  var entry in cases                if  entry IsDefault    entry Target IsAssignableFrom type                     entry Action source                   break                                     public static CaseInfo Case lt T gt  Action action            return new CaseInfo                 Action   x   gt  action                Target   typeof T                        public static CaseInfo Case lt T gt  Action lt T gt  action            return new CaseInfo                 Action    x    gt  action  T x               Target   typeof T                        public static CaseInfo Default Action action            return new CaseInfo                 Action   x   gt  action                IsDefault   true

User · Answer

Create a superclass  S  and make A and B inherit from it  Then declare an abstract method on S that every subclass needs to implement   Doing this the  foo  method can also change its signature to Foo S o   making it type safe  and you don t need to throw that ugly exception

User · Answer

One option is to have a dictionary from Type to Action  or some other delegate   Look up the action based on the type  and then execute it  I ve used this for factories before now

User · Answer

I agree with Jon about having a hash of actions to class name   If you keep your pattern  you might want to consider using the  as  construct instead   A a   o as A  if  a    null        a Hop        return    B b   o as B  if  b    null        b Skip        return    throw new ArgumentException           The difference is that when you use the patter if  foo is Bar      Bar foo  Action      you re doing the type casting twice   Now maybe the compiler will optimize and only do that work once - but I wouldn t count on it

[c#] Is there a better alternative than this to 'switch on type'?

Examples related to c#

Examples related to switch-statement

Examples related to system.type