Przez całe życie nie pamiętam, jak ustawić, usunąć, przełączyć lub przetestować trochę na polu bitowym. Albo nie jestem pewien, albo je mieszam, ponieważ rzadko ich potrzebuję. Tak więc byłoby miło mieć „ściągawkę”.

Na przykład:

flags = flags | FlagsEnum.Bit4;  // Set bit 4.

lub

if ((flags & FlagsEnum.Bit4)) == FlagsEnum.Bit4) // Is there a less verbose way?

Czy możesz podać przykłady wszystkich innych typowych operacji, najlepiej w składni C # przy użyciu wyliczenia [Flagi]?

Popracowałem trochę nad tymi rozszerzeniami - kod można znaleźć tutaj

Napisałem kilka metod rozszerzenia, które rozszerzają System.Enum, których często używam ... Nie twierdzę, że są kuloodporne, ale pomogły ... Komentarze zostały usunięte ...

namespace Enum.Extensions {

    public static class EnumerationExtensions {

        public static bool Has<T>(this System.Enum type, T value) {
            try {
                return (((int)(object)type & (int)(object)value) == (int)(object)value);
            } 
            catch {
                return false;
            }
        }

        public static bool Is<T>(this System.Enum type, T value) {
            try {
                return (int)(object)type == (int)(object)value;
            }
            catch {
                return false;
            }    
        }


        public static T Add<T>(this System.Enum type, T value) {
            try {
                return (T)(object)(((int)(object)type | (int)(object)value));
            }
            catch(Exception ex) {
                throw new ArgumentException(
                    string.Format(
                        "Could not append value from enumerated type '{0}'.",
                        typeof(T).Name
                        ), ex);
            }    
        }


        public static T Remove<T>(this System.Enum type, T value) {
            try {
                return (T)(object)(((int)(object)type & ~(int)(object)value));
            }
            catch (Exception ex) {
                throw new ArgumentException(
                    string.Format(
                        "Could not remove value from enumerated type '{0}'.",
                        typeof(T).Name
                        ), ex);
            }  
        }

    }
}

Następnie są używane w następujący sposób

SomeType value = SomeType.Grapes;
bool isGrapes = value.Is(SomeType.Grapes); //true
bool hasGrapes = value.Has(SomeType.Grapes); //true

value = value.Add(SomeType.Oranges);
value = value.Add(SomeType.Apples);
value = value.Remove(SomeType.Grapes);

bool hasOranges = value.Has(SomeType.Oranges); //true
bool isApples = value.Is(SomeType.Apples); //false
bool hasGrapes = value.Has(SomeType.Grapes); //false

W .NET 4 możesz teraz pisać:

flags.HasFlag(FlagsEnum.Bit4)

Idiom polega na użyciu operatora bitowego lub równego do ustawienia bitów:

flags |= 0x04;

Aby trochę wyczyścić, idiomem jest użycie bitowe i z negacją:

flags &= ~0x04;

Czasami masz przesunięcie, które identyfikuje twój bit, a następnie idiomem jest użycie ich w połączeniu z przesunięciem w lewo:

flags |= 1 << offset;
flags &= ~(1 << offset);

@Rysował

Zauważ, że z wyjątkiem najprostszych przypadków Enum.HasFlag niesie ze sobą wysoką wydajność w porównaniu do ręcznego pisania kodu. Rozważ następujący kod:

[Flags]
public enum TestFlags
{
    One = 1,
    Two = 2,
    Three = 4,
    Four = 8,
    Five = 16,
    Six = 32,
    Seven = 64,
    Eight = 128,
    Nine = 256,
    Ten = 512
}


class Program
{
    static void Main(string[] args)
    {
        TestFlags f = TestFlags.Five; /* or any other enum */
        bool result = false;

        Stopwatch s = Stopwatch.StartNew();
        for (int i = 0; i < 10000000; i++)
        {
            result |= f.HasFlag(TestFlags.Three);
        }
        s.Stop();
        Console.WriteLine(s.ElapsedMilliseconds); // *4793 ms*

        s.Restart();
        for (int i = 0; i < 10000000; i++)
        {
            result |= (f & TestFlags.Three) != 0;
        }
        s.Stop();
        Console.WriteLine(s.ElapsedMilliseconds); // *27 ms*        

        Console.ReadLine();
    }
}

Ponad 10 milionów iteracji metoda rozszerzenia HasFlags zajmuje aż 4793 ms, w porównaniu do 27 ms dla standardowej implementacji bitowej.

Wbudowane operacje wyliczania flag .NET są niestety dość ograniczone. Przez większość czasu użytkownicy nie są w stanie zrozumieć logiki operacji bitowej.

W .NET 4 HasFlagdodano metodę, Enumktóra pomaga uprościć kod użytkownika, ale niestety jest z nim wiele problemów.

1. HasFlag nie jest bezpieczny dla typu, ponieważ przyjmuje dowolny typ argumentu wartości wyliczeniowej, nie tylko dany typ wyliczenia.
2. HasFlagjest niejednoznaczny, czy sprawdza, czy wartość ma wszystkie czy jakiekolwiek flagi dostarczone przez argument wartości wyliczeniowej. Nawiasem mówiąc, to wszystko.
3. HasFlag jest raczej powolny, ponieważ wymaga boksu, który powoduje przydziały, a tym samym więcej śmieci.

Po części ze względu na ograniczone wsparcie .NET dla wyliczeń flag, napisałem bibliotekę OSS Enums.NET, która rozwiązuje każdy z tych problemów i znacznie ułatwia radzenie sobie z wyliczeniami flag.

Poniżej znajdują się niektóre operacje, które udostępnia wraz z ich równoważnymi implementacjami przy użyciu samego środowiska .NET.

Połącz flagi

.NETTO             flags | otherFlags

Enums.NET flags.CombineFlags(otherFlags)

Usuń flagi

.NETTO             flags & ~otherFlags

Enums.NET flags.RemoveFlags(otherFlags)

Wspólne flagi

.NETTO             flags & otherFlags

Enums.NET flags.CommonFlags(otherFlags)

Przełącz flagi

.NETTO             flags ^ otherFlags

Enums.NET flags.ToggleFlags(otherFlags)

Ma wszystkie flagi

.NET             (flags & otherFlags) == otherFlags lubflags.HasFlag(otherFlags)

Enums.NET flags.HasAllFlags(otherFlags)

Ma dowolne flagi

.NETTO             (flags & otherFlags) != 0

Enums.NET flags.HasAnyFlags(otherFlags)

Zdobądź flagi

.NETTO

Enumerable.Range(0, 64)
  .Where(bit => ((flags.GetTypeCode() == TypeCode.UInt64 ? (long)(ulong)flags : Convert.ToInt64(flags)) & (1L << bit)) != 0)
  .Select(bit => Enum.ToObject(flags.GetType(), 1L << bit))`

Enums.NET flags.GetFlags()

Usiłuję włączyć te ulepszenia do .NET Core i być może pełnej wersji .NET Framework. Możesz sprawdzić moją propozycję tutaj .

Składnia C ++, przy założeniu, że bit 0 to LSB, przy założeniu, że flagi są bez znaku długie:

Sprawdź, czy zestaw:

flags & (1UL << (bit to test# - 1))

Sprawdź, jeśli nie ustawiono:

invert test !(flag & (...))

Zestaw:

flag |= (1UL << (bit to set# - 1))

Jasny:

flag &= ~(1UL << (bit to clear# - 1))

Przełącznik:

flag ^= (1UL << (bit to set# - 1))

Aby uzyskać najlepszą wydajność i zero śmieci, użyj tego:

using System;
using T = MyNamespace.MyFlags;

namespace MyNamespace
{
    [Flags]
    public enum MyFlags
    {
        None = 0,
        Flag1 = 1,
        Flag2 = 2
    }

    static class MyFlagsEx
    {
        public static bool Has(this T type, T value)
        {
            return (type & value) == value;
        }

        public static bool Is(this T type, T value)
        {
            return type == value;
        }

        public static T Add(this T type, T value)
        {
            return type | value;
        }

        public static T Remove(this T type, T value)
        {
            return type & ~value;
        }
    }
}

Aby przetestować bit, wykonaj następujące czynności: (zakładając, że flagi są liczbą 32-bitową)

Bit testowy:

if((flags & 0x08) == 0x08)

flags = flags ^ 0x08;

flags = flags & 0xFFFFFF7F;

Zostało to zainspirowane użyciem Setów jako indeksatorów w Delphi, gdy:

/// Example of using a Boolean indexed property
/// to manipulate a [Flags] enum:

public class BindingFlagsIndexer
{
  BindingFlags flags = BindingFlags.Default;

  public BindingFlagsIndexer()
  {
  }

  public BindingFlagsIndexer( BindingFlags value )
  {
     this.flags = value;
  }

  public bool this[BindingFlags index]
  {
    get
    {
      return (this.flags & index) == index;
    }
    set( bool value )
    {
      if( value )
        this.flags |= index;
      else
        this.flags &= ~index;
    }
  }

  public BindingFlags Value 
  {
    get
    { 
      return flags;
    } 
    set( BindingFlags value ) 
    {
      this.flags = value;
    }
  }

  public static implicit operator BindingFlags( BindingFlagsIndexer src )
  {
     return src != null ? src.Value : BindingFlags.Default;
  }

  public static implicit operator BindingFlagsIndexer( BindingFlags src )
  {
     return new BindingFlagsIndexer( src );
  }

}

public static class Class1
{
  public static void Example()
  {
    BindingFlagsIndexer myFlags = new BindingFlagsIndexer();

    // Sets the flag(s) passed as the indexer:

    myFlags[BindingFlags.ExactBinding] = true;

    // Indexer can specify multiple flags at once:

    myFlags[BindingFlags.Instance | BindingFlags.Static] = true;

    // Get boolean indicating if specified flag(s) are set:

    bool flatten = myFlags[BindingFlags.FlattenHierarchy];

    // use | to test if multiple flags are set:

    bool isProtected = ! myFlags[BindingFlags.Public | BindingFlags.NonPublic];

  }
}

Operacje w C ++ to: & | ^ ~ (dla i, lub, xor i nie bitowych). Interesujące są również >> i <<, które są operacjami przesunięcia bitów.

Tak więc, aby sprawdzić, czy bit jest ustawiony w fladze, użyłbyś: if (flagi i 8) // testy bit 4 został ustawiony