Por toda a minha vida, não me lembro como definir, excluir, alternar ou testar um pouco em um campo de bits. Ou não tenho certeza ou os confundo porque raramente preciso deles. Portanto, seria bom ter uma "folha de dicas".

Por exemplo:

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

ou

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

Você pode dar exemplos de todas as outras operações comuns, de preferência na sintaxe C # usando uma enumeração [Flags]?

Eu trabalhei mais nessas extensões - Você pode encontrar o código aqui

Eu escrevi alguns métodos de extensão que estendem o System.Enum que eu uso frequentemente ... Não estou afirmando que são à prova de balas, mas eles ajudaram ... Comentários removidos ...

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

    }
}

Então eles são usados ​​como o seguinte

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

No .NET 4, agora você pode escrever:

flags.HasFlag(FlagsEnum.Bit4)

O idioma é usar o operador bit a bit ou igual para definir bits:

flags |= 0x04;

Para limpar um pouco, o idioma é usar bit a bit e com negação:

flags &= ~0x04;

Às vezes, você tem um deslocamento que identifica seu bit e, em seguida, o idioma é usá-lo combinado com o deslocamento para a esquerda:

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

@Desenhou

Observe que, exceto nos casos mais simples, o Enum.HasFlag acarreta uma penalidade de alto desempenho em comparação à gravação manual do código. Considere o seguinte código:

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

Mais de 10 milhões de iterações, o método de extensão HasFlags ocupa 4793 ms, em comparação com os 27 ms da implementação padrão em bits.

Infelizmente, as operações de enumeração de sinalizador do .NET são bastante limitadas. Na maioria das vezes, os usuários ficam com a lógica de operação bit a bit.

No .NET 4, HasFlagfoi adicionado o método Enumque ajuda a simplificar o código do usuário, mas infelizmente há muitos problemas com ele.

1. HasFlag não é seguro quanto ao tipo, pois aceita qualquer tipo de argumento de valor de enumeração, não apenas o tipo de enumeração especificado.
2. HasFlagé ambíguo se verifica se o valor possui todos ou alguns dos sinalizadores fornecidos pelo argumento de valor da enumeração. É tudo a propósito.
3. HasFlag é bastante lento, pois requer boxe, o que causa alocações e, portanto, mais coleta de lixo.

Em parte devido ao suporte limitado do .NET para enumerações de flag, escrevi a biblioteca OSS Enums.NET, que aborda cada um desses problemas e facilita muito o tratamento de enumerações de flag.

Abaixo estão algumas das operações que ele fornece, juntamente com suas implementações equivalentes, usando apenas a estrutura .NET.

Combinar sinalizadores

.INTERNET             flags | otherFlags

Enums.NET flags.CombineFlags(otherFlags)

Remover sinalizadores

.INTERNET             flags & ~otherFlags

Enums.NET flags.RemoveFlags(otherFlags)

Sinalizadores comuns

.INTERNET             flags & otherFlags

Enums.NET flags.CommonFlags(otherFlags)

Alternar sinalizadores

.INTERNET             flags ^ otherFlags

Enums.NET flags.ToggleFlags(otherFlags)

Tem todas as bandeiras

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

Enums.NET flags.HasAllFlags(otherFlags)

Tem sinalizadores

.INTERNET             (flags & otherFlags) != 0

Enums.NET flags.HasAnyFlags(otherFlags)

Obter sinalizadores

.INTERNET

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

Estou tentando incorporar essas melhorias no .NET Core e, eventualmente, no .NET Framework completo. Você pode conferir minha proposta aqui .

Sintaxe C ++, assumindo que o bit 0 é LSB, assumindo que os sinalizadores não tenham assinatura longa:

Verifique se definido:

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

Verifique se não estiver definido:

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

Conjunto:

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

Claro:

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

Alternancia:

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

Para obter o melhor desempenho e zero lixo, use o seguinte:

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

Para testar um pouco, faça o seguinte: (supondo que sinalizadores seja um número de 32 bits)

Bit de teste:

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

flags = flags ^ 0x08;

flags = flags & 0xFFFFFF7F;

Isso foi inspirado pelo uso de Sets como indexadores no Delphi, quando:

/// 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];

  }
}

As operações C ++ são: & | ^ ~ (para e, ou, xor e não operações bit a bit). Também são interessantes >> e <<, que são operações de deslocamento de bits.

Portanto, para testar um bit sendo definido em um sinalizador, você usaria: se (flags & 8) // testes o bit 4 foi definido