Добрый день!

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

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 ???

Заменить на "! = 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 ???

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

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

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

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

А>Есть код манипулирующий пунктами меню
…
А>как избавиться от == 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 ???

Можно так:

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" обнуляет биты, кроме не равных 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

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

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

  x:   01011011101
  y:   00001000000

  x&y: 00001000000

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

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

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

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

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

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

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

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

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

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

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

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

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

            }
        }
    }

Это?