Bayrakları olan bir Enum değerlerini nasıl yineleyebilirim?

Bayrak numaralandıran bir değişkenim varsa, bu belirli değişkendeki bit değerleri üzerinde bir şekilde yineleme yapabilir miyim? Yoksa tüm numaralandırmayı yinelemek ve hangilerinin ayarlandığını kontrol etmek için Enum.GetValues ​​kullanmam gerekir mi?

static IEnumerable<Enum> GetFlags(Enum input)
{
    foreach (Enum value in Enum.GetValues(input.GetType()))
        if (input.HasFlag(value))
            yield return value;
}

İşte soruna bir Linq çözümü.

public static IEnumerable<Enum> GetFlags(this Enum e)
{
      return Enum.GetValues(e.GetType()).Cast<Enum>().Where(e.HasFlag);
}

Bildiğim kadarıyla her bileşeni elde etmek için herhangi bir yerleşik yöntem yok. Ama bunları elde etmenin bir yolu:

[Flags]
enum Items
{
    None = 0x0,
    Foo  = 0x1,
    Bar  = 0x2,
    Baz  = 0x4,
    Boo  = 0x6,
}

var value = Items.Foo | Items.Bar;
var values = value.ToString()
                  .Split(new[] { ", " }, StringSplitOptions.None)
                  .Select(v => (Items)Enum.Parse(typeof(Items), v));

// This method will always end up with the most applicable values
value = Items.Bar | Items.Baz;
values = value.ToString()
              .Split(new[] { ", " }, StringSplitOptions.None)
              .Select(v => (Items)Enum.Parse(typeof(Items), v)); // Boo

Bunun Enumyerine bayrakları döndürmek için dizeyi oluşturmak için dahili olarak neyin yapılacağını uyarladım . Reflektördeki koda bakabilirsiniz ve aşağı yukarı eşdeğer olmalıdır. Birden çok bit içeren değerlerin olduğu genel kullanım durumları için iyi sonuç verir.

static class EnumExtensions
{
    public static IEnumerable<Enum> GetFlags(this Enum value)
    {
        return GetFlags(value, Enum.GetValues(value.GetType()).Cast<Enum>().ToArray());
    }

    public static IEnumerable<Enum> GetIndividualFlags(this Enum value)
    {
        return GetFlags(value, GetFlagValues(value.GetType()).ToArray());
    }

    private static IEnumerable<Enum> GetFlags(Enum value, Enum[] values)
    {
        ulong bits = Convert.ToUInt64(value);
        List<Enum> results = new List<Enum>();
        for (int i = values.Length - 1; i >= 0; i--)
        {
            ulong mask = Convert.ToUInt64(values[i]);
            if (i == 0 && mask == 0L)
                break;
            if ((bits & mask) == mask)
            {
                results.Add(values[i]);
                bits -= mask;
            }
        }
        if (bits != 0L)
            return Enumerable.Empty<Enum>();
        if (Convert.ToUInt64(value) != 0L)
            return results.Reverse<Enum>();
        if (bits == Convert.ToUInt64(value) && values.Length > 0 && Convert.ToUInt64(values[0]) == 0L)
            return values.Take(1);
        return Enumerable.Empty<Enum>();
    }

    private static IEnumerable<Enum> GetFlagValues(Type enumType)
    {
        ulong flag = 0x1;
        foreach (var value in Enum.GetValues(enumType).Cast<Enum>())
        {
            ulong bits = Convert.ToUInt64(value);
            if (bits == 0L)
                //yield return value;
                continue; // skip the zero value
            while (flag < bits) flag <<= 1;
            if (flag == bits)
                yield return value;
        }
    }
}

Uzantı yöntemi GetIndividualFlags(), bir tür için tüm bağımsız bayrakları alır. Böylece birden çok bit içeren değerler dışarıda bırakılır.

var value = Items.Bar | Items.Baz;
value.GetFlags();           // Boo
value.GetIndividualFlags(); // Bar, Baz

Birkaç yıl sonra, biraz daha deneyimle buna geri dönersek, yalnızca tek bitlik değerler için nihai cevabım, en düşük bitten en yüksek bit'e geçerken, Jeff Mercado'nun iç rutininin hafif bir çeşidi:

public static IEnumerable<Enum> GetUniqueFlags(this Enum flags)
{
    ulong flag = 1;
    foreach (var value in Enum.GetValues(flags.GetType()).Cast<Enum>())
    {
        ulong bits = Convert.ToUInt64(value);
        while (flag < bits)
        {
            flag <<= 1;
        }

        if (flag == bits && flags.HasFlag(value))
        {
            yield return value;
        }
    }
}

İşe yarıyor gibi görünüyor ve birkaç yıl önceki itirazlarıma rağmen, burada HasFlag kullanıyorum, çünkü bit tabanlı karşılaştırmalar kullanmaktan çok daha okunaklı ve yapacağım her şey için hız farkı önemsiz. (O zamandan beri HasFlag'lerin hızını artırmış olmaları tamamen mümkündür, tek bildiğim ... Test etmedim.)

@ Greg'in yönteminden çıkmak, ancak C # 7.3'ten yeni bir özellik eklemek, Enumkısıtlama:

public static IEnumerable<T> GetUniqueFlags<T>(this Enum flags)
    where T : Enum    // New constraint for C# 7.3
{
    foreach (Enum value in Enum.GetValues(flags.GetType()))
        if (flags.HasFlag(value))
            yield return (T)value;
}

Yeni kısıtlama yoluyla döküm zorunda kalmadan, bu uzantı yöntem sağlar (int)(object)e, ve kullanabilir HasFlagdoğrudan yöntem ve bir döküm Tden value.

C # 7.3 ayrıca delagates için kısıtlamalar ekledi ve unmanaged.

@ RobinHood70 tarafından sağlanan yanıt için +1. Metodun genel bir versiyonunun benim için uygun olduğunu buldum.

public static IEnumerable<T> GetUniqueFlags<T>(this Enum flags)
{
    if (!typeof(T).IsEnum)
        throw new ArgumentException("The generic type parameter must be an Enum.");

    if (flags.GetType() != typeof(T))
        throw new ArgumentException("The generic type parameter does not match the target type.");

    ulong flag = 1;
    foreach (var value in Enum.GetValues(flags.GetType()).Cast<T>())
    {
        ulong bits = Convert.ToUInt64(value);
        while (flag < bits)
        {
            flag <<= 1;
        }

        if (flag == bits && flags.HasFlag(value as Enum))
        {
            yield return value;
        }
    }
}

@AustinWBryan için C # 7.3'ü çözüm alanına taşıdığı için EDIT And +1.

public static IEnumerable<T> GetUniqueFlags<T>(this T flags) where T : Enum
{
    ulong flag = 1;
    foreach (var value in Enum.GetValues(flags.GetType()).Cast<T>())
    {
        ulong bits = Convert.ToUInt64(value);
        while (flag < bits)
        {
            flag <<= 1;
        }

        if (flag == bits && flags.HasFlag(value as Enum))
        {
            yield return value;
        }
    }
}

Tüm değerleri yinelemenize gerek yok. sadece belirli bayraklarınızı şu şekilde kontrol edin:

if((myVar & FlagsEnum.Flag1) == FlagsEnum.Flag1) 
{
   //do something...
}

veya ( pstrjds'nin yorumlarda söylediği gibi ) aşağıdaki gibi kullanımını kontrol edebilirsiniz:

if(myVar.HasFlag(FlagsEnum.Flag1))
{
   //do something...
}

Yaptığım şey yaklaşımımı değiştirmekti, yöntemin input parametresini tür olarak yazmak yerine, enumonu enumtype ( MyEnum[] myEnums) türünün bir dizisi olarak yazdım, bu şekilde diziyi döngü içinde bir switch ifadesiyle yineledim.

Başlangıç ​​olmasına rağmen yukarıdaki cevaplardan memnun kalmadı.

Burada bazı farklı kaynakları bir araya getirdikten sonra:
Bu konudaki önceki poster SO QnA Code Project Enum Flags Gönderiyi
Kontrol Et
Great Enum <T> Utility

Bunu ben yarattım, ne düşündüğünüzü bana bildirin.
Parametreler:: bir bayrak değeri olarak
bool checkZeroizin vermesini söyler 0. Varsayılan olarak input = 0boş döner.
bool checkFlags: öznitelikle Enumdekore edilip edilmediğini kontrol etmesini söyler [Flags].
PS. Şu anda checkCombinators = false, bitlerin birleşimi olan herhangi bir enum değerini görmezden gelmeye zorlayacak alg'ı bulmak için zamanım yok.

    public static IEnumerable<TEnum> GetFlags<TEnum>(this TEnum input, bool checkZero = false, bool checkFlags = true, bool checkCombinators = true)
    {
        Type enumType = typeof(TEnum);
        if (!enumType.IsEnum)
            yield break;

        ulong setBits = Convert.ToUInt64(input);
        // if no flags are set, return empty
        if (!checkZero && (0 == setBits))
            yield break;

        // if it's not a flag enum, return empty
        if (checkFlags && !input.GetType().IsDefined(typeof(FlagsAttribute), false))
            yield break;

        if (checkCombinators)
        {
            // check each enum value mask if it is in input bits
            foreach (TEnum value in Enum<TEnum>.GetValues())
            {
                ulong valMask = Convert.ToUInt64(value);

                if ((setBits & valMask) == valMask)
                    yield return value;
            }
        }
        else
        {
            // check each enum value mask if it is in input bits
            foreach (TEnum value in Enum <TEnum>.GetValues())
            {
                ulong valMask = Convert.ToUInt64(value);

                if ((setBits & valMask) == valMask)
                    yield return value;
            }
        }

    }

Bu, burada kullanmak yield returnüzere güncellediğim Yardımcı Sınıf Enum <T> 'nu kullanır GetValues:

public static class Enum<TEnum>
{
    public static TEnum Parse(string value)
    {
        return (TEnum)Enum.Parse(typeof(TEnum), value);
    }

    public static IEnumerable<TEnum> GetValues()   
    {
        foreach (object value in Enum.GetValues(typeof(TEnum)))
            yield return ((TEnum)value);
    }
}  

Son olarak, işte bunun kullanımına bir örnek:

    private List<CountType> GetCountTypes(CountType countTypes)
    {
        List<CountType> cts = new List<CountType>();

        foreach (var ct in countTypes.GetFlags())
            cts.Add(ct);

        return cts;
    }

Greg'in yukarıdaki cevabına dayanarak, bu aynı zamanda numaralandırmanızda Yok = 0 gibi bir 0 değerine sahip olduğunuz durumu da dikkate alır. Bu durumda, bu değer üzerinde yineleme yapmamalıdır.

public static IEnumerable<Enum> ToEnumerable(this Enum input)
{
    foreach (Enum value in Enum.GetValues(input.GetType()))
        if (input.HasFlag(value) && Convert.ToInt64(value) != 0)
            yield return value;
}

Numaralandırmadaki tüm bayrakların tüm temel numaralandırma türünü ve Tümü = ~ 0 ve Tümü = EnumValue1 | EnumValue2 | EnumValue3 | ...

Enum'dan bir Yineleyici kullanabilirsiniz. MSDN kodundan başlayarak:

public class DaysOfTheWeek : System.Collections.IEnumerable
{
    int[] dayflag = { 1, 2, 4, 8, 16, 32, 64 };
    string[] days = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
    public string value { get; set; }

    public System.Collections.IEnumerator GetEnumerator()
    {
        for (int i = 0; i < days.Length; i++)
        {
            if value >> i & 1 == dayflag[i] {
                yield return days[i];
            }
        }
    }
}

Test edilmedi, bu yüzden bir hata yaptıysam beni aramaktan çekinmeyin. (açıkçası yeniden giren değil.) Önceden değer atamanız veya enum.dayflag ve enum.days kullanan başka bir işleve bölmeniz gerekir. Anahatla bir yere gidebilirsin.

Aşağıdaki kod kadar iyi olabilir:

public static string GetEnumString(MyEnum inEnumValue)
{
    StringBuilder sb = new StringBuilder();

    foreach (MyEnum e in Enum.GetValues(typeof(MyEnum )))
    {
        if ((e & inEnumValue) != 0)
        {
           sb.Append(e.ToString());
           sb.Append(", ");
        }
    }

   return sb.ToString().Trim().TrimEnd(',');
}

Yalnızca enum değeri değerde bulunduğunda içeri girer

Tüm cevaplar basit bayraklarla iyi çalışıyor, bayraklar birleştirildiğinde muhtemelen sorunlara gireceksiniz.

[Flags]
enum Food
{
  None=0
  Bread=1,
  Pasta=2,
  Apples=4,
  Banana=8,
  WithGluten=Bread|Pasta,
  Fruits = Apples | Banana,
}

Enum değerinin bir kombinasyon olup olmadığını test etmek için muhtemelen bir kontrol eklemeniz gerekir. İhtiyaçlarınızı karşılamak için muhtemelen burada Henk van Boeijen tarafından yayınlanan bir şeye ihtiyacınız olacaktır (biraz aşağı kaydırmanız gerekir)

Yeni Enum kısıtlamasını ve dönüştürmeyi önlemek için jenerikleri kullanan uzantı yöntemi:

public static class EnumExtensions
{
    public static T[] GetFlags<T>(this T flagsEnumValue) where T : Enum
    {
        return Enum
            .GetValues(typeof(T))
            .Cast<T>()
            .Where(e => flagsEnumValue.HasFlag(e))
            .ToArray();
    }
}

Bunu doğrudan int türüne dönüştürerek yapabilirsiniz, ancak tür denetimini kaybedersiniz. Bence en iyi yol, önerime benzer bir şey kullanmak. Tüm yol boyunca uygun türü korur. Dönüştürmeye gerek yok. Performansa biraz vuruş katacak olan boks nedeniyle mükemmel değil.

Mükemmel değil (boks), ama hiçbir uyarı olmadan işi yapıyor ...

/// <summary>
/// Return an enumerators of input flag(s)
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static IEnumerable<T> GetFlags<T>(this T input)
{
    foreach (Enum value in Enum.GetValues(input.GetType()))
    {
        if ((int) (object) value != 0) // Just in case somebody has defined an enum with 0.
        {
            if (((Enum) (object) input).HasFlag(value))
                yield return (T) (object) value;
        }
    }
}

Kullanımı:

    FileAttributes att = FileAttributes.Normal | FileAttributes.Compressed;
    foreach (FileAttributes fa in att.GetFlags())
    {
        ...
    }