Como faço para ligar um enum que tem o conjunto de atributos de bandeiras (ou mais precisamente é usado para operações de bits)?

Eu quero ser capaz de acertar todos os casos em um switch que corresponda aos valores declarados.

O problema é que, se eu tenho o seguinte enum

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

e eu quero usar um 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>

Se "theCheckType" estiver definido como CheckType.Form | CheckType.TempData Eu quero acertar ambos os casos. Obviamente, ele não vai acertar os dois no meu exemplo por causa da quebra, mas fora isso também falhar porque CheckType.Form não é igual ao CheckType.Form | CheckType.TempData

A única solução então, como posso ver, é justificar todas as combinações possíveis dos valores enum?

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>

Mas isso realmente não é muito desejado (pois crescerá rapidamente muito grande)

Agora eu tenho 3 Se as condições logo após eachother vez

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>

Mas isso também significa que, se eu tiver um enum com 20 valores, ele terá que passar por 20 condições If a cada vez, em vez de "saltar" para apenas os "casos" necessários, como quando usar um switch.

Existe alguma solução mágica para resolver este problema?

Eu pensei na possibilidade de percorrer os valores declarados e, em seguida, usar o switch, em seguida, ele só iria acertar o switch para cada valor declarado, mas eu não sei como vai funcionar e se vice de desempenho é uma boa idéia ( em comparação com um monte de se)

Existe uma maneira fácil de percorrer todos os valores enum declarados?

Eu só posso usar ToString () e dividir por "," e, em seguida, percorrer o array e analisar cada string.

ATUALIZAR:

Eu vejo que não fiz um bom trabalho explicando. Meu exemplo é simples (tentei simplificar meu cenário).

Eu o uso para um ActionMethodSelectorAttribute no Asp.net MVC para determinar se um método deve estar disponível ao resolver o url / route.

Eu faço isso declarando algo assim no método

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

Isso significa que ele deve verificar se o Form ou TempData possui uma chave especificada para que o método esteja disponível.

Os métodos que ele estará chamando (doSomething (), doSomethingElse () e doWhatever () no meu exemplo anterior) terão bool como valor de retorno e serão chamados com um parâmetro (coletas diferentes que não compartilham uma interface que pode ser usado - veja meu código de exemplo no link abaixo etc).

Para dar uma idéia melhor do que estou fazendo, colei um exemplo simples do que realmente estou fazendo no pastebin - ele pode ser encontrado aquihttp://pastebin.com/m478cc2b8