¿Cómo puedo activar una enumeración que tiene el atributo de banderas establecido (o más precisamente se usa para operaciones de bit)?

Quiero poder golpear todos los casos en un interruptor que coincida con los valores declarados.

El problema es que si tengo la siguiente enumeración

<code>[Flags()]public enum CheckType
{
    Form = 1,   
    QueryString = 2,
    TempData = 4,
}
</code>

y quiero usar un interruptor como este

<code>switch(theCheckType)
{
   case CheckType.Form:
       DoSomething(/*Some type of collection is passed */);
       break;

   case CheckType.QueryString:
       DoSomethingElse(/*Some other type of collection is passed */);
       break;

   case CheckType.TempData
       DoWhatever(/*Some different type of collection is passed */);
       break;
}
</code>

Si "theCheckType" se establece en CheckType.Form | CheckType.TempData Quiero que golpee ambos casos. Obviamente, no afectará a ambos en mi ejemplo debido a la interrupción, pero aparte de eso, también falla porque CheckType.Form no es igual a CheckType.Form | CheckType.TempData

¿La única solución entonces, como puedo ver, es hacer un caso para cada combinación posible de los valores de enumeración?

Algo como

<code>    case CheckType.Form | CheckType.TempData:
        DoSomething(/*Some type of collection is passed */);
        DoWhatever(/*Some different type of collection is passed */);
        break;

    case CheckType.Form | CheckType.TempData | CheckType.QueryString:
        DoSomething(/*Some type of collection is passed */);
        DoSomethingElse(/*Some other type of collection is passed */);
        break;

... and so on...
</code>

Pero eso realmente no es muy deseado (ya que crecerá rápidamente muy grande)

En este momento tengo 3 Si las condiciones justo después de otro lugar en su lugar

Algo como

<code>if ((_CheckType & CheckType.Form) != 0)
{
    DoSomething(/*Some type of collection is passed */);
}

if ((_CheckType & CheckType.TempData) != 0)
{
    DoWhatever(/*Some type of collection is passed */);
}

....
</code>

Pero eso también significa que si tengo una enumeración con 20 valores, tiene que pasar por 20 Si las condiciones se activan cada vez en lugar de "saltar" solo al "caso" / 's necesario cuando se usa un interruptor.

¿Hay alguna solución mágica para resolver este problema?

He pensado en la posibilidad de recorrer los valores declarados y luego usar el interruptor, luego solo presionaría el interruptor para cada valor declarado, pero no sé cómo funcionará y si el vicio de rendimiento es una buena idea ( en comparación con un montón de si es)?

¿Hay una manera fácil de recorrer todos los valores de enumeración declarados?

Solo se me ocurre usar ToString () y dividir por "," y luego recorrer la matriz y analizar cada cadena.

ACTUALIZAR:

Veo que no he hecho un buen trabajo explicando. Mi ejemplo es simple (intentado simplificar mi escenario).

Lo uso para un ActionMethodSelectorAttribute en Asp.net MVC para determinar si un método debería estar disponible al resolver la url / ruta.

Lo hago declarando algo así en el método.

<code>[ActionSelectorKeyCondition(CheckType.Form | CheckType.TempData, "SomeKey")]
public ActionResult Index()
{
    return View();
} 
</code>

Eso significaría que debería verificar si el formulario o TempData tienen una clave como se especifica para que el método esté disponible.

Los métodos a los que llamará (doSomething (), doSomethingElse () y doWhatever () en mi ejemplo anterior) realmente tendrán bool como valor de retorno y se llamarán con un parámetro (diferentes colecciones que no comparten una interfaz que puede ser utilizado - ver mi código de ejemplo en el enlace de abajo, etc).

Con suerte, para dar una mejor idea de lo que estoy haciendo, he pegado un ejemplo simple de lo que realmente estoy haciendo en pastebin: se puede encontrar aquíhttp://pastebin.com/m478cc2b8