Здравствуйте, Аноним, Вы писали:

А>как избавиться от == 1, == 4 ???

Заменить на "! = 0"

А>как избавиться от == 1, == 4 ???
А>Спасибо!

если версия 3+, то можно extension:

public static class Common
{
  public static bool Has(this Permissions form, Permissions perm)
  {
    return (form & perm) == perm;
  }
}

  Permissions perm = AddNew| Import;

  miNew.Enabled = perm.Has(Permissions.AddNew);
  ...
  ...      
  miImport.Enabled = perm.Has(Permissions.Import);

Здравствуйте, Аноним, Вы писали:

А>Есть код манипулирующий пунктами меню
…
А>как избавиться от == 1, == 4 ???

    public static bool CheckFlag32<T>(this T value, T flag) where T : struct, IConvertible {
      return (value.ToUInt32(null) & flag.ToUInt32(null)) != 0;
    }

    …

А>    miNew.Enabled = perm. CheckFlag32(Permissions.AddNew);

Более удачное имя метода, надеюсь подскажет кто-то ещё

Здравствуйте, Аноним, Вы писали:
А>Есть код манипулирующий пунктами меню
А>как избавиться от == 1, == 4 ???

Зачем кастить к инту...

miImport.Enabled((perm & Permissions.Import) != 0)

Ещё повесьте на enum атрибут System.FlagsAttribute

Здравствуйте, Пельмешко, Вы писали:

П>"Битовая and" обнуляет биты, кроме не равных 1 соответственно в обоих операндах, никаких "справа от неё".
именно это я имел ввиду

П>Результат можно сравнивать на неравенство 0, а можно чётко проверить какие биты останутся после &, никакой роли в данном случае это не играет, разве что != 0 короче.
зачем и кому это нужно? если СПРАВА от and стоят значения битов 0 и 1, то сравнение со значением только бита 1 ничего не даст

Здравствуйте, <Аноним>, Вы писали:

А> зачем и кому это нужно? если СПРАВА от and стоят значения битов 0 и 1, то сравнение со значением только бита 1 ничего не даст

Делают для однородности конструкций. Чтобы избежать ошибко подобных этой:

        [Flags]
        enum E
        {
            One = 1,
            Two = 2,
            OneAndTwo = 3
        }

            const E sample = E.One;
            // здесь это не имеет значения
            bool test = (sample & E.One) != 0;   
            bool test2 = (sample & E.One) == E.One; 
            // а здесь имеет
            bool test3 = (sample & E.OneAndTwo) != 0; // true
            bool test4 = (sample & E.OneAndTwo) == E.OneAndTwo; // false

А> зачем и кому это нужно? если СПРАВА от and стоят значения битов 0 и 1, то сравнение со значением только бита 1 ничего не даст
там не если — там всегда справа от and стоят значения битов 0 и 1

я не понимаю — вы хотите доказать, что так делать не следует? тогда аргументы в студию.

а бывает всякое. когда например хочется убедится что val именно Dog, а не какойто маммал

enum Animal {
  ...,
  MammalFlag = 00010000b,
  Dog        = 00010010b,
  Cat        = 00010011b,
  ...
}

var val = Test.Cat
...
var isDog1 = ((int)val &  (int)Animal.Dog) != 0; // true
var isDog2 = val & Animal.Dog == Animal.Dog; // false

Отвечу всем сразу здесь )

Ovl>я не понимаю — вы хотите доказать, что так делать не следует? тогда аргументы в студию.
я хочу сказать, что:
1. это лишнее — лишние символы, лишнии константы (! особенно в случае если там стоят числа); сложнее воспринимаются такие дубли
2. потенциальный источник ошибок в виду таких вот повторов

тогда как сравнение с нулем однозначно говорит о проверки установленности указанных битов

Здравствуйте, Аноним, Вы писали:

А>Отвечу всем сразу здесь )

Ovl>>я не понимаю — вы хотите доказать, что так делать не следует? тогда аргументы в студию.
А>я хочу сказать, что:
А>1. это лишнее — лишние символы, лишнии константы (! особенно в случае если там стоят числа); сложнее воспринимаются такие дубли
А>2. потенциальный источник ошибок в виду таких вот повторов

А>тогда как сравнение с нулем однозначно говорит о проверки установленности указанных битов

это говорит о проверки установленности битов. только не указанных, а гарантированно одного из них. возможно даже некоторых. вот и думайте что будет большей ошибой — принять газ за тормоз или наличие основного и вспомогательного тормозов (образно говоря).

1) какие лишние константы? это просто пример. они все могут быть "нужными". что подразумевается под дублями?
2) нераскрыта тема ошибок.

Добрый день!

Есть код манипулирующий пунктами меню

public enum Permissions {
         AddNew = 1,    
         Read = 2,     
         Import = 4   
};

   Permissions perm = AddNew| Import;

    miNew.Enabled =((int)perm & (int)Permissions.AddNew)== 1 
     ...
     ...      
    miImport.Enabled((int)perm & (int)Permissions.Import) == 4

как избавиться от == 1, == 4 ???


Спасибо!

Здравствуйте, Аноним, Вы писали:

А>Есть код манипулирующий пунктами меню
А>как избавиться от == 1, == 4 ???

Можно так:

miNew.Enabled =((int)perm & (int)Permissions.AddNew)== (int)Permissions.AddNew);

Здравствуйте, Undying, Вы писали:

U>

U>miNew.Enabled =((int)perm & (int)Permissions.AddNew)== (int)Permissions.AddNew);
U>

а можно вопрос? зачем многие так делают? они понимают, что это лишнее, и что достаточно сравнивать с нулем, т.к. битовая and обнуляет все биты кроме перечисленных занчений справа от нее?

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Undying, Вы писали:

U>>

U>>miNew.Enabled =((int)perm & (int)Permissions.AddNew)== (int)Permissions.AddNew);
U>>

А>а можно вопрос? зачем многие так делают? они понимают, что это лишнее, и что достаточно сравнивать с нулем, т.к. битовая and обнуляет все биты кроме перечисленных занчений справа от нее?

"Битовая and" обнуляет биты, кроме не равных 1 соответственно в обоих операндах, никаких "справа от неё".
Результат можно сравнивать на неравенство 0, а можно чётко проверить какие биты останутся после &, никакой роли в данном случае это не играет, разве что != 0 короче.

Здравствуйте, Аноним, Вы писали:
А> зачем и кому это нужно? если СПРАВА от and стоят значения битов 0 и 1, то сравнение со значением только бита 1 ничего не даст

Не понимаю чего Вас не устраивает У вас есть несколько бит, надо проверить какой-нибудь из них, делаем AND:

  x:   01011011101
  y:   00001000000

  x&y: 00001000000

  x&y != 0
  x&y == y

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

Здравствуйте, Аноним, Вы писали:

    public static class EnumHelper
    {
        public static bool IsFlagSet<T>(this T value, T flag)
            where T: struct
        {
            Debug.Assert(typeof(T).IsEnum);

            var underlying = Enum.GetUnderlyingType(typeof(T));

            if (underlying == typeof(int))
                return IsInt32FlagSet((int)(object)value, (int)(object)flag);

            throw new NotSupportedException();
        }

        static bool IsInt32FlagSet(int value, int flag)
        {
            return (value & flag) == flag;
        }
    }

Здравствуйте, Аноним, Вы писали:

А>Добрый день!

А>Есть код манипулирующий пунктами меню

    [Flags]
    public enum Permissions
    {
        AddNew = 1,
        Read = 2,
        Import = 4
    }

    class Program
    {
        static void Main( string[] args )
        {
            Permissions perms = Permissions.AddNew | Permissions.Read;
            if ( ( perms & Permissions.Read ) == Permissions.Read )
            {

            }
        }
    }

Это?