c# - multiple - ¿Cómo usar switch-case en un tipo?

switch case in c# example

Question

Posible duplicado:
¿Hay una alternativa mejor que esta para ''activar el tipo''?

Necesito recorrer todas las propiedades de mi clase y verificar si es el tipo de int que necesito para hacer algo, si su cadena ... luego hacer algo Lo necesito usando switch-case. Aquí estoy usando el interruptor de la siguiente manera, pero pide alguna constante. Vea el código a continuación:

 public static bool ValidateProperties(object o)
{
if(o !=null)
{
var sourceType = o.GetType();
var properties = sourceType.GetProperties(BindingFlags.Public | BindingFlags.Static);
foreach (var property in properties)
{
var type = property.GetType();
switch (type)
{
*case typeof(int):* getting error here
// d
}
}
}
}

También quiero saber, ¿qué verificación debo usar, typeof (int) o typeof (Int32)?

Answer 1

No puede utilizar un bloque de interruptor para probar valores de tipo Type . La compilación de tu código debería darte un error diciendo algo como:

Una expresión de conmutador o una etiqueta de caso debe ser un tipo bool, char, string, integral, enum, o un tipo anulable correspondiente

Tendrá que usar las instrucciones if - else lugar.

También: typeof(int) y typeof(Int32) son equivalentes. int es una palabra clave e Int32 es el nombre de tipo.

ACTUALIZAR

Si espera que la mayoría de los tipos sean intrínsecos, puede mejorar el rendimiento utilizando un bloque de interruptores con Type.GetTypeCode(...) .

Por ejemplo:

switch (Type.GetTypeCode(type))
{
case TypeCode.Int32:
// It''s an int
break;
case TypeCode.String:
// It''s a string
break;
// Other type code cases here...
default:
// Fallback to using if-else statements...
if (type == typeof(MyCoolType))
{
// ...
}
else if (type == typeof(MyOtherType))
{
// ...
} // etc...
}

Answer 2

Por lo general, la solución más fácil es activar el nombre de tipo:

switch (type.Name)
{
case "Int32":
...
}

Answer 3

Una forma buena y extensible de hacer esto es hacer un diccionario de tipos y delegados del tipo apropiado, en función de lo que quiera hacer con los valores de ese tipo.

Por ejemplo:

var typeProcessorMap = new Dictionary<Type, Delegate>
{
{ typeof(int), new Action<int>(i => { /* do something with i */ }) },
{ typeof(string), new Action<string>(s => { /* do something with s */ }) },
};

Y entonces:

void ValidateProperties(object o)
{
var t = o.GetType();
typeProcessorMap[t].DynamicInvoke(o); // invoke appropriate delegate
}

Esta solución es extensible, configurable incluso en tiempo de ejecución, y siempre que mantenga las claves y los tipos de valores de delegado en typeProcessorMap coincidentes correctamente, también es de tipo seguro.

Véalo en acción .

Answer 4

Esta "respuesta" es una elaboración de la respuesta de Jon. (Marcado CW)

Para el registro, DynamicInvoke es un poco lento. Para ilustrar esto, considere el siguiente programa:

void Main()
{
Func<int, string> myFunc = i => i.ToString();
myFunc.DynamicInvoke(1); // Invoke once so initial run costs are not considered
myFunc(1);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < 1000000; i++)
myFunc.DynamicInvoke(1);
stopwatch.Stop();
var elapsed = stopwatch.Elapsed;
stopwatch.Restart();
for (int i = 0; i < 1000000; i++)
myFunc(1);
stopwatch.Stop();
var elapsed2 = stopwatch.Elapsed;
Console.WriteLine("DynamicInvoke: " + elapsed);
Console.WriteLine("Direct Invocation: " + elapsed2);
}

Imprime:

DynamicInvoke: 00: 00: 03.1959900
Invocación directa: 00: 00: 00.0735220

Lo que significa que DynamicInvoke (en este caso simple) es 42 veces más lento que la invocación directa.