Jak przekazać wiele wartości wyliczenia w języku C #?

Czasami podczas czytania kodu C # innych osób widzę metodę, która akceptuje wiele wartości wyliczenia w jednym parametrze. Zawsze myślałem, że to całkiem fajne, ale nigdy się nad tym nie zastanawiałem.

Cóż, teraz myślę, że mogę tego potrzebować, ale nie wiem jak

1. ustaw podpis metody, aby to zaakceptować
2. pracować z wartościami w metodzie
3. zdefiniować wyliczenie

aby osiągnąć tego rodzaju rzeczy.

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

Chcę mieć możliwość przekazania jednej lub więcej wartości DayOfWeek do mojej metody. Czy będę mógł używać tego konkretnego wyliczenia w obecnej postaci? Jak mam wykonać 3 rzeczy wymienione powyżej?

Kiedy definiujesz wyliczenie, po prostu przypisz mu [Flags], ustaw wartości na potęgę dwójki i będzie działać w ten sposób.

Nic innego się nie zmienia, poza przekazywaniem wielu wartości do funkcji.

Na przykład:

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

Aby uzyskać więcej informacji, zobacz dokumentację MSDN dotyczącą typów wyliczenia .

Edytuj w odpowiedzi na dodatki do pytania.

Nie będziesz mógł użyć tego wyliczenia w takiej postaci, w jakiej jest, chyba że chcesz zrobić coś takiego, jak przekazanie go jako tablica / kolekcja / tablica parametrów. Umożliwiłoby to przekazanie wielu wartości. Składnia flag wymaga, aby wyliczenie było określone jako flagi (lub aby język był bastardowany w sposób, który nie został zaprojektowany).

Myślę, że bardziej eleganckim rozwiązaniem jest użycie 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);
    }

Druga odpowiedź Reeda. Jednak podczas tworzenia wyliczenia należy określić wartości dla każdego elementu członkowskiego wyliczenia, aby było to pole bitowe. Na przykład:

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

W mojej konkretnej sytuacji chciałbym skorzystać z System.DayOfWeek

Nie możesz użyć System.DayOfWeek jako [Flags]wyliczenia, ponieważ nie masz nad nim kontroli. Jeśli chcesz mieć metodę, która akceptuje wiele DayOfWeek, będziesz musiał użyć paramssłowa kluczowego

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

W przeciwnym razie możesz utworzyć własne [Flags]wyliczenie opisane przez wielu innych respondentów i użyć porównań bitowych.

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

Musisz określić liczby i zwiększać je w ten sposób, ponieważ przechowuje wartości w sposób bitowy.

Następnie po prostu zdefiniuj metodę, aby wziąć to wyliczenie

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

i nazwać to czymś w rodzaju

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

Aby sprawdzić, czy jedna z wartości wyliczenia została uwzględniona, sprawdź je za pomocą operacji bitowych, takich jak

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
    }

wywołaj metodę w tym formacie

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

Zaimplementuj metodę EnumToArray, aby uzyskać przekazane opcje

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

Oznacz swoje wyliczenie atrybutem [Flags]. Upewnij się również, że wszystkie twoje wartości wykluczają się wzajemnie (dwie wartości nie mogą się sumować, aby się równać), jak 1,2,4,8,16,32,64 w twoim przypadku

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

Jeśli masz metodę, która akceptuje wyliczenie DayOfWeek, użyj operatora bitowego lub (|), aby używać wielu elementów członkowskich razem. Na przykład:

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

Aby sprawdzić, czy parametr zawiera określony element członkowski, użyj bitowego i operatora (&) dla elementu członkowskiego, którego szukasz.

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

Reed Copsey ma rację i dodałbym do oryginalnego postu, gdybym mógł, ale nie mogę, więc zamiast tego będę musiał odpowiedzieć.

Używanie [Flags] po prostu do starego wyliczenia jest niebezpieczne. Uważam, że podczas używania flag należy jawnie zmienić wartości wyliczenia na potęgi dwóch, aby uniknąć kolizji wartości. Zobacz wytyczne dotyczące FlagsAttribute i Enum .

Za pomocą opublikowanych odpowiedzi i tych:

1. Klasa FlagsAttribute (spójrz na porównanie używania i niestosowania atrybutu [Flags])
2. Atrybut flagi wyliczenia

Czuję, że całkiem dobrze to rozumiem.

Dzięki.

Coś takiego powinno wskazywać, czego szukasz:

[Flags]
public enum SomeName
{
    Name1,
    Name2
}

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