¿Cómo se pasan múltiples valores enum en C#?

Question

Algunas veces, al leer el código C# de otros, veo un método que aceptará múltiples valores enum en un solo parámetro. Siempre pensé que era algo ordenado, pero nunca lo analicé.

Bueno, ahora creo que puede tener una necesidad de ella, pero no saben cómo

1. creó la firma del método para aceptar este
2. trabajo con los valores en el método
3. define la enumeración

para lograr este tipo de cosas.

---

En mi situación particular, me gustaría utilizar el System.DayOfWeek, que se define como:

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

Quiero ser capaz de pasar uno o más de los valores DAYOFWEEK a mi método. ¿Podré usar esta enumeración particular tal como es? ¿Cómo hago las 3 cosas enumeradas arriba?

Answer 1

Cuando define la enumeración, simplemente la atribuye con [Banderas], establezca valores en potencias de dos, y funcionará de esta manera.

Nada más cambia, aparte de pasar múltiples valores en una función.

Por ejemplo:

[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 más detalles, véase MSDN's documentation on Enumeration Types.

---

Editar en respuesta a las preguntas añadidas.

No podrá usar esa enumeración como está, a menos que desee hacer algo así como pasarlo como una matriz/colección/params. Eso te permitiría pasar múltiples valores. La sintaxis de los indicadores requiere que Enum se especifique como indicadores (o para bastardear el idioma de una manera que no está diseñada).

Answer 2

Algo de esta naturaleza debe mostrar lo que busca:

[Flags] 
public enum SomeName 
{ 
    Name1, 
    Name2 
} 

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

Answer 3

Me segunda respuesta de Reed. Sin embargo, al crear la enumeración, debe especificar los valores para cada miembro enum, por lo que constituye un campo de tipo de bit. Por ejemplo:

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

Answer 4

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

llamada al método en este formato

MethodName (DaysOfWeek.Tuesday | DaysOfWeek.Thursday);

implementar un método EnumToArray para obtener las opciones pasó

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

Answer 5

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

Se tiene que especificar los números, y el incremento ellos de esta manera, ya que es el almacenamiento de los valores de una forma bit a bit.

A continuación, sólo definen el método de tomar esta enumeración

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

y llamarlo hacer algo como

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

Para comprobar si uno de los valores de enumeración se incluyó comprobarlas usando operaciones 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 
    } 
} 

Answer 6

Marque su enum con el atributo [Flags]. También asegúrese de que todos sus valores son excluyentes entre sí (dos valores no se pueden añadir hasta igualar otra) como 1,2,4,8,16,32,64 en su caso

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

Cuando se tiene una método que acepta una enumeración DayOfWeek utiliza el operador bit a bit (|) para usar múltiples miembros juntos. Por ejemplo:

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

Para comprobar si el parámetro contiene un miembro específico, utilice el nivel de bits y operador (&) con el miembro que está mirando para.

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

Answer 7

Reed Copsey es correcta y que se sumaría a la entrada original si pudiera, pero no puedo, así que tendrá lugar para responder.

Es peligroso usar [Banderas] en cualquier enumeración anterior. Creo que tienes que cambiar explícitamente los valores enum a potencias de dos cuando uses banderas, para evitar conflictos en los valores. Vea el guidelines for FlagsAttribute and Enum.

Answer 8

Con la ayuda de las respuestas publicadas y éstos:

1. FlagsAttribute Class (Mira la comparación de usar y no usar el [Banderas] atributo)
2. Enum Flags Attribute

me siento como Lo entiendo bastante bien.

Gracias.

Answer 9

En mi situación particular, me gustaría usar la System.DayOfWeek

No se puede utilizar el System.DayOfWeek como una enumeración [Flags] porque no tiene control sobre él. Si usted desea tener un método que acepta múltiples DayOfWeek entonces usted tendrá que utilizar la palabra clave params

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

De lo contrario puede crear su propia enumeración [Flags] como se indica por numerosos otro personal de respuesta y el uso de comparaciones a nivel de bit.

Answer 10

creo que la solución más elegante es 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); 
    }