Cum putem sa verificam tipul unei variabile intr-un SWITCH

Sunt momente cand avem nevoie de a face anumite actiuni in functie de tipul variabilei. Din pacate SWITCH-ul nu ne permite acest lucru in mod direct si suntem nevoiți sa apelam la IF..ELSE.

if (item is int)
{...}
else if (item is string)
{...}
else if (item is DateTime)
{...}
else if (item is ...)

Codul pe care il obtinem nu este foarte lizibil. Daca totusi am vrea sa folosim SWITCH am fi nevoiti sa lucram cu string-uri obtinand ceva asemanator cu:

swtich( v.GetType().Name)
{
   case typeof(int).Name:
   ...
   break;
   case typeof(DateTime).Name:
   ...
   break;
   ...
}

Parca e mai bine decat codul precedent, dar ceea ce nu e tocmai bine este ca lucram cu string-uri. O solutie la aceasta problema este sa folosim TypeCode. Acest enum contine toate tipurile built-in din .NET.

switch( Type.GetTypeCode(v.GetType)))
{
   case TypeCode.Int32:
   ...
   break;
   case TypeCode.DateTime:
   ...
   break;
   ...
}

In cazul in care lucram doar cu tipurile built-in din .NET totul este perfect. Ceea ce imi place la TypeCode este ca are valori precum "Empty" sau "DBNull". Dar ce ne facem daca lucram cu vectori, cu liste generice sau cu entități proprii. In acest caz TypeCode nu mai poate fi folosit. Pentru acest caz eu am gasit doua rezolvari. O solutie este sa ne folosim de un dicționar de forma:

Dictionary<Type, int>

sau

Dictionary<Type, [CustomEnum]>

In cazul acesta am putea sa adaugam la initializarea dictionarului toate tipurile cu care lucram, iar apoi sa scriem un switch asemanator cu acesta:

swtich( types[v.GetType()])     // types - este o instanta a dictionarului in care avem toate tipurile cu care lucram.
{
   case 0:     //sau case CustomEnum.Int32
   ...
   break;
   case 1:     //sau case CustomEnum.DateTime
   ...
   break;
   ...
}

Urmatoarea solutie pe care o propun este sa ne definim o clasa CustomSwitch iar pentru fiecare case in parte sa ne definim actiunea dorita. Putem sa ne definim modelul si intr-un mod fluent, a.i. la final sa putem aveam ceva asemanator cu:

var customSwitch = new CustomSwitch(v)
   .Case<int>( x => ...actiune... );
   .Case<DateTime>( x => ...actiune... );

Mai jos puteti sa gasiti implemenentarea pentru CustomSwitch:

public class CustomSwitch
   {
       public CustomSwitch(Object obj)
       {
           Obj = obj;
       }

       public Object Obj { get; set; }
   }
public static class CustomSwitchExtensions
{
   public static CustomSwitch Case<T>( this CustomSwitch cs,Action<T> action)
       where T : class
   {
       var obj = s.Obj as T;
       if (obj != null)
       {
           action(obj);
           return null;
       }
   }
} 

La aceasta implementare s-ar mai putea adauga si un flag care sa permita un mecanism de fall through si prin celelalte case-uri. Din cele doua variante propuse as alege a doua varianta doar in cazul in care as avea nevoie si de un mecanism de fall through. De exemplu in cazul in care as avea nevoie sa execut doua case-uri pentru un obiect( ex. in cazul in care implementateaza interfata IA o actiune, si pentru interfata IB o alta actiune).