Включите Перечисление (с атрибутом Флагов), не объявляя каждую возможную комбинацию?

А как насчет Dictionary , который вы заполните как

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

разложением вашего значения

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

, а затем

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

(код не проверен)

На основе вашего редактирования и вашего реального кода, я бы, вероятно, обновил метод IsValidForRequest , чтобы он выглядел примерно так:

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;
}

Перечисления флагов можно рассматривать как простой интегральный тип, в котором каждый отдельный бит соответствует одному из помеченных значений. Вы можете использовать это свойство, чтобы преобразовать значение перечисления с битовой флагом в массив логических значений, а затем отправить нужные вам методы из коррелированного массива делегатов.

РЕДАКТИРОВАТЬ: Мы, конечно, могли бы сделать этот код более компактным за счет использования LINQ и некоторых вспомогательных функций, но я думаю, что это легче понять в менее сложной форме. Это может быть тот случай, когда ремонтопригодность важнее элегантности.

Вот пример:

[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
  }
}

В качестве альтернативы, если порядок, в котором вы выполняете оценку, не имеет значения, существует более простое и ясное решение, которое также работает. Если порядок имеет значение, замените операции сдвига бит массивом, содержащим флаги в том порядке, в котором вы хотите их оценивать:

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
}