Comment passez-vous plusieurs valeurs d'énumération en C #?

Parfois, lors de la lecture du code C # des autres, je vois une méthode qui acceptera plusieurs valeurs d'énumération dans un seul paramètre. J'ai toujours pensé que c'était plutôt chouette, mais je ne l'ai jamais regardé.

Eh bien, maintenant je pense que j'en ai peut-être besoin, mais je ne sais pas comment

1. configurer la signature de méthode pour accepter cela
2. travailler avec les valeurs de la méthode
3. définir l'énumération

pour réaliser ce genre de chose.

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

Je souhaite pouvoir transmettre une ou plusieurs des valeurs DayOfWeek à ma méthode. Est-ce que je pourrai utiliser cette énumération particulière telle quelle? Comment faire les 3 choses ci-dessus?

Lorsque vous définissez l'énumération, attribuez-la simplement avec [Flags], définissez les valeurs sur des puissances de deux, et cela fonctionnera de cette façon.

Rien d'autre ne change, à part le passage de plusieurs valeurs dans une fonction.

Par exemple:

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

Pour plus de détails, consultez la documentation de MSDN sur les types d'énumération .

Modifier en réponse aux ajouts à la question.

Vous ne pourrez pas utiliser cette énumération telle quelle, à moins que vous ne vouliez faire quelque chose comme la passer en tant que tableau array / collection / params. Cela vous permettrait de transmettre plusieurs valeurs. La syntaxe des indicateurs nécessite que Enum soit spécifié comme indicateurs (ou pour bâtarder le langage d'une manière qui n'est pas conçue).

Je pense que la solution la plus élégante est d'utiliser 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);
    }

Je seconde la réponse de Reed. Cependant, lors de la création de l'énumération, vous devez spécifier les valeurs de chaque membre d'énumération pour créer une sorte de champ de bits. Par exemple:

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

Dans ma situation particulière, je souhaite utiliser le System.DayOfWeek

Vous ne pouvez pas utiliser le System.DayOfWeek comme une [Flags]énumération car vous n'avez aucun contrôle dessus. Si vous souhaitez avoir une méthode qui accepte plusieurs, DayOfWeekvous devrez utiliser le paramsmot - clé

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

Sinon, vous pouvez créer votre propre [Flags]énumération comme indiqué par de nombreux autres répondeurs et utiliser des comparaisons au niveau du bit.

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

Vous devez spécifier les nombres et les incrémenter comme ceci car il stocke les valeurs de manière bit à bit.

Ensuite, définissez simplement votre méthode pour prendre cette énumération

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

et pour l'appeler faites quelque chose comme

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

Pour vérifier si l'une des valeurs d'énumération a été incluse, vérifiez-les à l'aide d'opérations au niveau du bit comme

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
    }

appeler la méthode dans ce format

MethodName (DaysOfWeek.Tuesday | DaysOfWeek.Thursday);

Implémentez une méthode EnumToArray pour obtenir les options passé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();
        }

Marquez votre énumération avec l'attribut [Flags]. Assurez-vous également que toutes vos valeurs sont mutuellement exclusives (deux valeurs ne peuvent pas s'additionner) comme 1,2,4,8,16,32,64 dans votre cas

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

Lorsque vous avez une méthode qui accepte une énumération DayOfWeek, utilisez l'opérateur binaire ou (|) pour utiliser plusieurs membres ensemble. Par exemple:

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

Pour vérifier si le paramètre contient un membre spécifique, utilisez l' opérateur binaire and (&) avec le membre que vous recherchez.

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

Reed Copsey a raison et j'ajouterais au message d'origine si je le pouvais, mais je ne peux pas donc je devrai répondre à la place.

Il est dangereux d'utiliser simplement [Flags] sur n'importe quelle ancienne énumération. Je pense que vous devez modifier explicitement les valeurs d'énumération en puissances de deux lorsque vous utilisez des indicateurs, pour éviter les conflits dans les valeurs. Consultez les instructions pour FlagsAttribute et Enum .

Avec l'aide des réponses affichées et celles-ci:

1. FlagsAttribute Class (Regardez la comparaison de l'utilisation et de la non utilisation de l'attribut [Flags])
2. Attribut Enum Flags

J'ai l'impression de bien le comprendre.

Merci.

Quelque chose de cette nature devrait montrer ce que vous recherchez:

[Flags]
public enum SomeName
{
    Name1,
    Name2
}

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