Come si passano più valori enum in C #?

A volte, durante la lettura del codice C # di altri, vedo un metodo che accetta più valori enum in un singolo parametro. Ho sempre pensato che fosse abbastanza carino, ma non l'ho mai esaminato.

Bene, ora penso di averne bisogno, ma non so come farlo

1. impostare la firma del metodo per accettarlo
2. lavorare con i valori nel metodo
3. definire l'enumerazione

per ottenere questo genere di cose.

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

Voglio essere in grado di trasferire uno o più valori DayOfWeek al mio metodo. Potrò usare questo particolare enum così com'è? Come faccio le 3 cose sopra elencate?

Quando definisci l'enumerazione, attribuiscilo con [Flags], imposta i valori a potenze di due e funzionerà in questo modo.

Nient'altro cambia, a parte il passaggio di più valori in una funzione.

Per esempio:

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

Per ulteriori dettagli, vedere la documentazione di MSDN sui tipi di enumerazione .

Modifica in risposta alle aggiunte alla domanda.

Non sarai in grado di usare quell'enumerazione così com'è, a meno che tu non voglia fare qualcosa come passarlo come array / collection / params. Ciò ti consentirebbe di trasmettere più valori. La sintassi dei flag richiede che Enum sia specificato come flag (o per imbastardizzare il linguaggio in un modo che non è stato progettato).

Penso che la soluzione più elegante sia usare 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);
    }

Secondo la risposta di Reed. Tuttavia, quando si crea l'enumerazione, è necessario specificare i valori per ogni membro dell'enumerazione in modo che crei una sorta di campo di bit. Per esempio:

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

Nella mia situazione particolare, vorrei utilizzare System.DayOfWeek

Non è possibile utilizzare System.DayOfWeek come [Flags]enumerazione perché non si ha alcun controllo su di esso. Se desideri avere un metodo che accetta più, DayOfWeekdovrai utilizzare la paramsparola chiave

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

Altrimenti puoi creare la tua [Flags]enumerazione come delineato da numerosi altri risponditori e utilizzare confronti bit per bit.

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

Devi specificare i numeri e incrementarli in questo modo perché memorizza i valori in modo bit per bit.

Quindi definisci il tuo metodo per prendere questo enum

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

e per chiamarlo fai qualcosa di simile

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

Per verificare se uno dei valori enum è stato incluso, controllali usando operazioni bit per bit come

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
    }

chiama il metodo in questo formato

MethodName (DaysOfWeek.Tuesday | DaysOfWeek.Th Thursday);

Implementa un metodo EnumToArray per far passare le opzioni

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

Contrassegna la tua enumerazione con l'attributo [Flags]. Assicurati inoltre che tutti i tuoi valori si escludano a vicenda (due valori non possono sommarsi per essere uguali a un altro) come 1,2,4,8,16,32,64 nel tuo caso

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

Quando si dispone di un metodo che accetta un'enumerazione DayOfWeek, utilizzare l'operatore bit per bit o (|) per utilizzare più membri insieme. Per esempio:

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

Per verificare se il parametro contiene un membro specifico, utilizzare l' operatore bit per bit e (&) con il membro che si sta verificando.

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

Reed Copsey ha ragione e vorrei aggiungere al post originale se potessi, ma non posso quindi dovrò rispondere invece.

È pericoloso usare solo [Flags] su qualsiasi vecchia enumerazione. Credo che sia necessario modificare esplicitamente i valori enum in potenze di due quando si usano i flag, per evitare conflitti nei valori. Vedere le linee guida per FlagsAttribute ed Enum .

Con l'aiuto delle risposte pubblicate e di queste:

1. FlagsAttribute Class (guarda il confronto tra l'utilizzo e il non utilizzo dell'attributo [Flags])
2. Attributo flag di enumerazione

Mi sento come se lo capissi abbastanza bene.

Grazie.

Qualcosa di questa natura dovrebbe mostrare quello che stai cercando:

[Flags]
public enum SomeName
{
    Name1,
    Name2
}

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