Наиболее распространенные побитовые операции C# над перечислениями

Question

Наиболее распространенные побитовые операции C# над перечислениями

На всю жизнь я не могу вспомнить, как устанавливать, удалять, переключать или тестировать немного в битовом поле. Либо я не уверен, либо я их перепутал, потому что они мне редко нужны. Так что было бы неплохо иметь "бит-шпаргалку".

Например:

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

или же

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

Можете ли вы привести примеры всех других общих операций, предпочтительно в синтаксисе C# с использованием перечисления [Flags]?

219

c# .net enums bit-manipulation flags

Источник

user15328 18 сен '08 в 15:46

11 ответов

Другие вопросы по тегам c# .net enums bit-manipulation flags

user17091 06 янв '09 в 16:31 2009-01-06 16:31 · Answer 1 · 2009-01-06 16:31

Я проделал еще несколько работ над этими расширениями - вы можете найти код здесь

Я написал несколько методов расширения, которые расширяют System.Enum, которые я часто использую... Я не утверждаю, что они пуленепробиваемые, но они помогли... Комментарии удалены...

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

    }
}

Затем они используются следующим образом

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

user24874 30 май '11 в 17:48 2011-05-30 17:48 · Answer 2 · 2011-05-30 17:48

В.NET 4 теперь вы можете написать:

flags.HasFlag(FlagsEnum.Bit4)

119

Источник

user24874 30 май '11 в 17:48

user7154 18 сен '08 в 15:50 2008-09-18 15:50 · Answer 3 · 2008-09-18 15:50

Идиома состоит в том, чтобы использовать битовый или равный оператор для установки битов:

flags |= 0x04;

Чтобы немного прояснить, идиома заключается в использовании побитового и с отрицанием:

flags &= ~0x04;

Иногда у вас есть смещение, которое идентифицирует ваш бит, и тогда идиома состоит в том, чтобы использовать их в сочетании со сдвигом влево:

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

user275594 24 авг '11 в 19:51 2011-08-24 19:51 · Answer 4 · 2011-08-24 19:51

@Нарисовалась

Обратите внимание, что за исключением простейших случаев, Enum.HasFlag влечет за собой значительное снижение производительности по сравнению с написанием кода вручную. Рассмотрим следующий код:

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

Более 10 миллионов итераций, метод расширения HasFlags занимает колоссальные 4793 мс, по сравнению с 27 мс для стандартной побитовой реализации.

user8137269 14 июн '17 в 17:27 2017-06-14 17:27 · Answer 5 · 2017-06-14 17:27

Встроенные в.NET операции перечисления флагов, к сожалению, весьма ограничены. Большую часть времени пользователям приходится разбираться с логикой побитовой операции.

В.NET 4 метод HasFlag был добавлен в Enum что помогает упростить код пользователя, но, к сожалению, с ним много проблем.

HasFlag не является типобезопасным, поскольку принимает любой тип аргумента значения перечисления, а не только данный тип перечисления.
HasFlag неоднозначно, проверяет ли он, имеет ли значение все или какие-либо из флагов, предоставленных аргументом значения перечисления. Это все кстати.
HasFlag довольно медленный, так как требует бокса, который вызывает выделение ресурсов и, следовательно, сборку мусора.

Отчасти из-за ограниченной поддержки.NET перечислений флагов я написал библиотеку OSS Enums.NET, которая решает каждую из этих проблем и значительно облегчает работу с перечислениями флагов.

Ниже приведены некоторые операции, которые он предоставляет вместе с их эквивалентными реализациями, использующими только.NET Framework.

Объединить флаги

.СЕТЬ flags | otherFlags

Enums.NET flags.CombineFlags(otherFlags)

Удалить флаги

.СЕТЬ flags & ~otherFlags

Enums.NET flags.RemoveFlags(otherFlags)

Общие флаги

.СЕТЬ flags & otherFlags

Enums.NET flags.CommonFlags(otherFlags)

Переключить флаги

.СЕТЬ flags ^ otherFlags

Enums.NET flags.ToggleFlags(otherFlags)

Имеет все флаги

.СЕТЬ (flags & otherFlags) == otherFlags или же flags.HasFlag(otherFlags)

Enums.NET flags.HasAllFlags(otherFlags)

Есть флаги

.СЕТЬ (flags & otherFlags) != 0

Enums.NET flags.HasAnyFlags(otherFlags)

Получить флаги

.СЕТЬ

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

Я пытаюсь включить эти улучшения в.NET Core и, возможно, в конечном итоге в полную версию.NET Framework. Вы можете проверить мое предложение здесь.

user17833 18 сен '08 в 15:57 2008-09-18 15:57 · Answer 6 · 2008-09-18 15:57

Синтаксис C++, предполагая, что бит 0 равен LSB, предполагая, что flags не имеет длинных знаков:

Проверьте, установлено ли:

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

Проверьте, не установлено ли:

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

Задавать:

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

Очистить:

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

Переключение:

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

user9004349 03 мар '19 в 20:19 2019-03-03 20:19 · Answer 7 · 2019-03-03 20:19

Для лучшей производительности и отсутствия мусора используйте это:

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

user6789816 15 июл '21 в 18:26 2021-07-15 18:26 · Answer 8 · 2021-07-15 18:26

Побитовое () руководство по перечислению

Старый, но хотел попробовать шпаргалку, хотя бы для моей справки:

Примеры

      [Flags]
enum E {
    A = 0b1,
    B = 0b10,
    C = 0b100
}

E e = E.A;        // Assign (e = A)
e |= E.B | E.C;   // Add    (e = A, B, C)
e &= ~E.A & ~E.B; // Remove (e = C) -- alt syntax: &= ~(E.A | E.B)
e ^= E.A | E.C;   // Toggle (e = A)
e.HasFlag(E.A);   // Test   (returns true)

// Testing multiple flags using bit operations:
bool hasAandB = ( e & (E.A | E.B) ) == (E.A | E.B);

Бонус: определение `Flags`перечисление

Обычно мы используем целые числа следующим образом:

      [Flags]
enum E {
    A = 1,
    B = 2,
    C = 4,
    // etc.

Но когда мы приближаемся к большим числам, вычислить следующее значение становится не так просто:

        // ...
  W = 4194304,
  X = 8388608,
  // ..

Однако есть пара альтернатив: двоичные и шестнадцатеричные литералы.

Для Binary просто добавьте 0в конце предыдущего значения:

      [Flags]
enum E {
    A = 0b1,
    B = 0b10,
    C = 0b100,
    // ...
    W = 0b100_0000_0000_0000_0000_0000,
    X = 0b1000_0000_0000_0000_0000_0000,

Шестнадцатеричный также имеет удобный шаблон и может выглядеть немного менее уродливо: циклически перебирать 1, 2, 4,8, добавляя ноль после каждой полной итерации.

      [Flags]
enum E {
    A = 0x1,
    B = 0x2,
    C = 0x4,
    D = 0x8,
    E = 0x10, // 16
    E = 0x20, // 32, etc.
    // ...
    W = 0x400000,
    X = 0x800000,

user15484 18 сен '08 в 16:00 2008-09-18 16:00 · Answer 9 · 2008-09-18 16:00

Чтобы проверить немного, вы должны сделать следующее: (при условии, что флаги - это 32-битное число)

Тестовый бит:

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

(Если бит 4 установлен, то он имеет значение true) Переключить назад (1 - 0 или 0 - 1):

flags = flags ^ 0x08;

Сбросить бит 4 в ноль:

flags = flags & 0xFFFFFF7F;

3

Источник

user15484 18 сен '08 в 16:00

user1173769 09 мар '12 в 22:09 2012-03-09 22:09 · Answer 10 · 2012-03-09 22:09

Это было вдохновлено использованием Sets в качестве индексаторов в Delphi, когда:

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

  }
}

user16035 18 сен '08 в 15:50 2008-09-18 15:50 · Answer 11 · 2008-09-18 15:50

C++ операции: & | ^ ~ (для и, или, xor и не побитовых операций). Также представляют интерес >> и <<, которые являются операциями битового сдвига.

Таким образом, чтобы проверить бит, установленный во флаге, вы должны использовать: if (flags & 8) //tests бит 4 установлен

1

Источник

user16035 18 сен '08 в 15:50

Наиболее распространенные побитовые операции C# над перечислениями

11 ответов

Объединить флаги

Удалить флаги

Общие флаги

Переключить флаги

Имеет все флаги

Есть флаги

Получить флаги

Побитовое () руководство по перечислению

Примеры

Бонус: определение Flagsперечисление

Бонус: определение `Flags`перечисление