Activar Enum (con el atributo Flags) sin declarar todas las combinaciones posibles?

Las enumeraciones de Flags se pueden tratar como un tipo integral simple en el que cada bit individual corresponde a uno de los valores marcados. Puede explotar esta propiedad para convertir el valor de enumeración marcado por bits en una matriz de booleanos y, a continuación, enviar los métodos que le interesan desde una matriz correlacionada de delegados.

EDITAR: Ciertamente podríamos hacer este código más compacto a través del uso de LINQ y algunas funciones auxiliares, pero creo que es más fácil de entender en el menor forma sofisticada. Este puede ser el caso donde el mantenimiento triunfa sobre la elegancia.

Aquí hay un ejemplo:

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

void PerformActions( CheckType c )
{
  // array of bits set in the parameter {c}
  bool[] actionMask = { false, false, false };
  // array of delegates to the corresponding actions we can invoke...
  Action availableActions = { DoSomething, DoSomethingElse, DoAnotherThing };

  // disassemble the flags into a array of booleans
  for( int i = 0; i < actionMask.Length; i++ )
    actionMask[i] = (c & (1 << i)) != 0;

  // for each set flag, dispatch the corresponding action method
  for( int actionIndex = 0; actionIndex < actionMask.Length; actionIndex++ )
  {
      if( actionMask[actionIndex])
          availableActions[actionIndex](); // invoke the corresponding action
  }
}

Alternativamente, si el orden en el que evalúas no importa, aquí hay una solución más simple y clara que funciona igual de bien. Si el orden importa, reemplace las operaciones de desplazamiento de bits con un array que contenga los indicadores en el orden en el que desea evaluarlos:

int flagMask = 1 << 31; // start with high-order bit...
while( flagMask != 0 )   // loop terminates once all flags have been compared
{
  // switch on only a single bit...
  switch( theCheckType & flagMask )
  {
   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;
  }

  flagMask >>= 1;  // bit-shift the flag value one bit to the right
}

¿Qué hay de un Dictionary<CheckType,Action> que llenarás como

dict.Add(CheckType.Form, DoSomething);
dict.Add(CheckType.TempDate, DoSomethingElse);
...

Una descomposición de su valor

flags = Enum.GetValues(typeof(CheckType)).Where(e => (value & (CheckType)e) == (CheckType)e).Cast<CheckType>();

Y luego

foreach (var flag in flags)
{
   if (dict.ContainsKey(flag)) dict[flag]();
}

(código no probado)

Solo use HasFlag

if(theCheckType.HasFlag(CheckType.Form)) DoSomething(...);
if(theCheckType.HasFlag(CheckType.QueryString)) DoSomethingElse(...);
if(theCheckType.HasFlag(CheckType.TempData)) DoWhatever(...);

Con C # 7 ahora puedes escribir algo como esto:

public void Run(CheckType checkType)
{
    switch (checkType)
    {
        case var type when CheckType.Form == (type & CheckType.Form):
            DoSomething(/*Some type of collection is passed */);
            break;

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

        case var type when CheckType.TempData == (type & CheckType.TempData):
            DoWhatever(/*Some different type of collection is passed */);
            break;
    }
}

Basado en su edición y su código de la vida real, probablemente actualizaría el método IsValidForRequest para que se vea algo como esto:

public sealed override bool IsValidForRequest
    (ControllerContext cc, MethodInfo mi)
{
    _ControllerContext = cc;

    var map = new Dictionary<CheckType, Func<bool>>
        {
            { CheckType.Form, () => CheckForm(cc.HttpContext.Request.Form) },
            { CheckType.Parameter,
                () => CheckParameter(cc.HttpContext.Request.Params) },
            { CheckType.TempData, () => CheckTempData(cc.Controller.TempData) },
            { CheckType.RouteData, () => CheckRouteData(cc.RouteData.Values) }
        };

    foreach (var item in map)
    {
        if ((item.Key & _CheckType) == item.Key)
        {
            if (item.Value())
            {
                return true;
            }
        }
    }
    return false;
}

Debería ser posible en C # 7

switch (t1)
    {
        case var t when t.HasFlag(TST.M1):
            {
                break;
            }
        case var t when t.HasFlag(TST.M2):
            {
                break;
            }

La forma más fácil es simplemente realizar una enumeración ORed, en su caso podría hacer lo siguiente:

[Flags()]public enum CheckType
{
    Form = 1,   
    QueryString = 2,
    TempData = 4,
    FormQueryString = Form | QueryString,
    QueryStringTempData = QueryString | TempData,
    All = FormQueryString | TempData
}

Una vez que tenga la configuración enum, ahora es fácil realizar su instrucción switch.

Por ejemplo, si he establecido lo siguiente:

var chkType = CheckType.Form | CheckType.QueryString;

Puedo usar la siguiente declaración switch de la siguiente manera:

switch(chkType){
 case CheckType.Form:
   // Have Form
 break;
 case CheckType.QueryString:
   // Have QueryString
 break;
 case CheckType.TempData:
  // Have TempData
 break;
 case CheckType.FormQueryString:
  // Have both Form and QueryString
 break;
 case CheckType.QueryStringTempData:
  // Have both QueryString and TempData
 break;
 case CheckType.All:
  // All bit options are set
 break;
}

Mucho más limpio y no necesita usar una instrucción if con HasFlag. Puede hacer cualquier combinación que desee y luego hacer que la declaración switch sea fácil de Leer.

Yo recomendaría romper su enums, trate de ver si usted no está mezclando diferentes cosas en el mismo enum. Puede configurar múltiples enums para reducir el número de casos.