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.