Como você passa vários valores enum em C #?

Às vezes, ao ler o código C # de outras pessoas, vejo um método que aceitará vários valores enum em um único parâmetro. Sempre achei que era legal, mas nunca olhei para isso.

Bem, agora eu acho que posso ter uma necessidade, mas não sei como

1. configurar a assinatura do método para aceitar isso
2. trabalhar com os valores do método
3. definir o enum

para conseguir esse tipo de coisa.

[Serializable]
[ComVisible(true)]
public enum DayOfWeek
{ 
    Sunday = 0,   
    Monday = 1,   
    Tuesday = 2,   
    Wednesday = 3,   
    Thursday = 4,   
    Friday = 5,    
    Saturday = 6
}

Eu quero passar um ou mais dos valores DayOfWeek para meu método. Serei capaz de usar este enum específico como está? Como faço as 3 coisas listadas acima?

Ao definir o enum, apenas atribua-o com [Flags], defina os valores para potências de dois e funcionará desta forma.

Nada mais muda, a não ser passar vários valores para uma função.

Por exemplo:

[Flags]
enum DaysOfWeek
{
   Sunday = 1,
   Monday = 2,
   Tuesday = 4,
   Wednesday = 8,
   Thursday = 16,
   Friday = 32,
   Saturday = 64
}

public void RunOnDays(DaysOfWeek days)
{
   bool isTuesdaySet = (days & DaysOfWeek.Tuesday) == DaysOfWeek.Tuesday;

   if (isTuesdaySet)
      //...
   // Do your work here..
}

public void CallMethodWithTuesdayAndThursday()
{
    this.RunOnDays(DaysOfWeek.Tuesday | DaysOfWeek.Thursday);
}

Para obter mais detalhes, consulte a documentação do MSDN sobre Tipos de Enumeração .

Edite em resposta aos acréscimos à pergunta.

Você não poderá usar aquele enum como está, a menos que queira fazer algo como passá-lo como um array / coleção / array de parâmetros. Isso permitiria passar vários valores. A sintaxe dos sinalizadores requer que o Enum seja especificado como sinalizadores (ou para bastardizar a linguagem de uma forma que não foi projetada).

Acho que a solução mais elegante é usar HasFlag ():

    [Flags]
    public enum DaysOfWeek
    {
        Sunday = 1,
        Monday = 2,
        Tuesday = 4,
        Wednesday = 8,
        Thursday = 16,
        Friday = 32,
        Saturday = 64
    }

    public void RunOnDays(DaysOfWeek days)
    {
        bool isTuesdaySet = days.HasFlag(DaysOfWeek.Tuesday);

        if (isTuesdaySet)
        {
            //...
        }
    }

    public void CallMethodWithTuesdayAndThursday()
    {
        RunOnDays(DaysOfWeek.Tuesday | DaysOfWeek.Thursday);
    }

Eu apoio a resposta de Reed. No entanto, ao criar o enum, você deve especificar os valores para cada membro do enum para que ele crie uma espécie de campo de bits. Por exemplo:

[Flags]
public enum DaysOfWeek
{
    Sunday = 1,
    Monday = 2,
    Tuesday = 4,
    Wednesday = 8,
    Thursday = 16,
    Friday = 32,
    Saturday = 64,

    None = 0,
    All = Weekdays | Weekend,
    Weekdays = Monday | Tuesday | Wednesday | Thursday | Friday,
    Weekend = Sunday | Saturday,
    // etc.
}

Em minha situação particular, gostaria de usar o System.DayOfWeek

Você não pode usar o System.DayOfWeek como uma [Flags]enumeração porque você não tem controle sobre ele. Se você deseja ter um método que aceita múltiplos, DayOfWeekentão você terá que usar a paramspalavra - chave

void SetDays(params DayOfWeek[] daysToSet)
{
    if (daysToSet == null || !daysToSet.Any())
        throw new ArgumentNullException("daysToSet");

    foreach (DayOfWeek day in daysToSet)
    {
        // if( day == DayOfWeek.Monday ) etc ....
    }
}

SetDays( DayOfWeek.Monday, DayOfWeek.Sunday );

Caso contrário, você pode criar sua própria [Flags]enumeração conforme descrito por vários outros respondentes e usar comparações bit a bit.

[Flags]
public enum DaysOfWeek
{
  Mon = 1,
  Tue = 2,
  Wed = 4,
  Thur = 8,
  Fri = 16,
  Sat = 32,
  Sun = 64
}

Você tem que especificar os números e incrementá-los assim, porque isso está armazenando os valores de forma bit a bit.

Em seguida, apenas defina seu método para obter este enum

public void DoSomething(DaysOfWeek day)
{
  ...
}

e chamá-lo de fazer algo como

DoSomething(DaysOfWeek.Mon | DaysOfWeek.Tue) // Both Monday and Tuesday

Para verificar se um dos valores enum foi incluído, verifique-os usando operações bit a bit como

public void DoSomething(DaysOfWeek day)
{
  if ((day & DaysOfWeek.Mon) == DaysOfWeek.Mon) // Does a bitwise and then compares it to Mondays enum value
  {
    // Monday was passed in
  }
}

[Flags]
    public enum DaysOfWeek{


        Sunday = 1 << 0,
        Monday = 1 << 1,
        Tuesday = 1 << 2,
        Wednesday = 1 << 3,
        Thursday = 1 << 4,
        Friday =  1 << 5,
        Saturday =  1 << 6
    }

chame o método neste formato

MethodName (DaysOfWeek.T Terça | DaysOfWeek.Thucted);

Implementar um método EnumToArray para passar as opções

private static void AddEntryToList(DaysOfWeek days, DaysOfWeek match, List<string> dayList, string entryText) {
            if ((days& match) != 0) {
                dayList.Add(entryText);
            }
        }

        internal static string[] EnumToArray(DaysOfWeek days) {
            List<string> verbList = new List<string>();

            AddEntryToList(days, HttpVerbs.Sunday, dayList, "Sunday");
            AddEntryToList(days, HttpVerbs.Monday , dayList, "Monday ");
            ...

            return dayList.ToArray();
        }

Marque seu enum com o atributo [Sinalizadores]. Além disso, certifique-se de que todos os seus valores sejam mutuamente exclusivos (dois valores não podem somar igual a outro) como 1,2,4,8,16,32,64 no seu caso

[Flags]
public enum DayOfWeek
{ 
Sunday = 1,   
Monday = 2,   
Tuesday = 4,   
Wednesday = 8,   
Thursday = 16,   
Friday = 32,    
Saturday = 64
}

Quando você tem um método que aceita um enum DayOfWeek, use o bit a bit ou o operador (|) para usar vários membros juntos. Por exemplo:

MyMethod(DayOfWeek.Sunday|DayOfWeek.Tuesday|DayOfWeek.Friday)

Para verificar se o parâmetro contém um membro específico, use o bit a bit e o operador (&) com o membro que você está verificando.

if(arg & DayOfWeek.Sunday == DayOfWeek.Sunday)
Console.WriteLine("Contains Sunday");

Reed Copsey está correto e eu acrescentaria à postagem original se pudesse, mas não posso, então terei de responder.

É perigoso usar apenas [Sinalizadores] em qualquer enum antigo. Acredito que você tenha que alterar explicitamente os valores de enum para potências de dois ao usar sinalizadores, para evitar conflitos nos valores. Consulte as diretrizes para FlagsAttribute e Enum .

Com a ajuda das respostas postadas e estas:

1. Classe FlagsAttribute ( observe a comparação entre usar e não usar o atributo [Flags])
2. Atributo de sinalizadores de Enum

Eu sinto que entendo muito bem.

Obrigado.

Algo dessa natureza deve mostrar o que você está procurando:

[Flags]
public enum SomeName
{
    Name1,
    Name2
}

public class SomeClass()
{
    public void SomeMethod(SomeName enumInput)
    {
        ...
    }
}