Skip to main content

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).

Comments

  1. :) Daca faci switch pe type ai o problema mult mai mare decat "cum sa faci". Think polymorphism :)

    ReplyDelete

Post a Comment

Popular posts from this blog

Windows Docker Containers can make WIN32 API calls, use COM and ASP.NET WebForms

After the last post , I received two interesting questions related to Docker and Windows. People were interested if we do Win32 API calls from a Docker container and if there is support for COM. WIN32 Support To test calls to WIN32 API, let’s try to populate SYSTEM_INFO class. [StructLayout(LayoutKind.Sequential)] public struct SYSTEM_INFO { public uint dwOemId; public uint dwPageSize; public uint lpMinimumApplicationAddress; public uint lpMaximumApplicationAddress; public uint dwActiveProcessorMask; public uint dwNumberOfProcessors; public uint dwProcessorType; public uint dwAllocationGranularity; public uint dwProcessorLevel; public uint dwProcessorRevision; } ... [DllImport("kernel32")] static extern void GetSystemInfo(ref SYSTEM_INFO pSI); ... SYSTEM_INFO pSI = new SYSTEM_INFO(

Azure AD and AWS Cognito side-by-side

In the last few weeks, I was involved in multiple opportunities on Microsoft Azure and Amazon, where we had to analyse AWS Cognito, Azure AD and other solutions that are available on the market. I decided to consolidate in one post all features and differences that I identified for both of them that we should need to take into account. Take into account that Azure AD is an identity and access management services well integrated with Microsoft stack. In comparison, AWS Cognito is just a user sign-up, sign-in and access control and nothing more. The focus is not on the main features, is more on small things that can make a difference when you want to decide where we want to store and manage our users.  This information might be useful in the future when we need to decide where we want to keep and manage our users.  Feature Azure AD (B2C, B2C) AWS Cognito Access token lifetime Default 1h – the value is configurable 1h – cannot be modified

What to do when you hit the throughput limits of Azure Storage (Blobs)

In this post we will talk about how we can detect when we hit a throughput limit of Azure Storage and what we can do in that moment. Context If we take a look on Scalability Targets of Azure Storage ( https://azure.microsoft.com/en-us/documentation/articles/storage-scalability-targets/ ) we will observe that the limits are prety high. But, based on our business logic we can end up at this limits. If you create a system that is hitted by a high number of device, you can hit easily the total number of requests rate that can be done on a Storage Account. This limits on Azure is 20.000 IOPS (entities or messages per second) where (and this is very important) the size of the request is 1KB. Normally, if you make a load tests where 20.000 clients will hit different blobs storages from the same Azure Storage Account, this limits can be reached. How we can detect this problem? From client, we can detect that this limits was reached based on the HTTP error code that is returned by HTTP