C#: Enum.IsDefined для комбинированных флагов

В перечислениях на основе флагов речь идет о том, установлен бит или нет. Таким образом, для «ExportFormat», если установлен бит 1, это формат CSV, даже если может быть установлено больше битов. Установлено ли для битов 1 и 2 недопустимое значение? Это субъективно: с точки зрения значений как группы, это недопустимо (для набора битов 1 и 2 не определен битовый шаблон), однако, поскольку каждое значение является битом, если рассматривать их по отдельности, может случиться так, что значение с установленными битами 1 и 2 является действительным.

Если передать значение 0011111011, это действительное значение? Ну, это зависит от того, что вы ищете: если вы смотрите на все значение, то это недопустимое значение, но если вы смотрите на отдельные биты, это нормальное значение: в нем установлены биты, которые не определены, но это нормально, так как перечисления на основе флагов проверяются «по битам»: вы не сравниваете их со значением, вы проверяете, установлен ли бит или нет.

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

Мы знаем, что значение перечисления, преобразованное в строку, никогда не будет начинаться с цифры, но всегда будет начинаться с недопустимого значения. Вот самое простое решение:

public static bool IsDefinedEx(this Enum yourEnum)
{
    char firstDigit = yourEnum.ToString()[0];
    if (Char.IsDigit(firstDigit) || firstDigit == '-')  // Account for signed enums too..
        return false;

    return true;
}

Используйте этот метод расширения вместо стандартного IsDefined, и это должно решить вашу проблему.

Я бы работал на уровне бит и проверял, все ли биты, установленные в новом значении, установлены в вашем значении All:

if ( ! (All & NewValue) == NewValue )

Вы должны сами увидеть, как лучше всего это сделать, возможно, вам нужно привести все значения к типу int, а затем выполнить побитовое сравнение.

Вот небольшой метод расширения, который делает это эффективно.

static void Main(string[] args)
{
  var x = ExportFormat.Csv | ExportFormat.Excel;
  var y = ExportFormat.Csv | ExportFormat.Word;
  var z = (ExportFormat)16; //undefined value

  var xx = x.IsDefined();  //true
  var yy = y.IsDefined();  //false
  var zz = z.IsDefined();  //false
}

public static bool IsDefined(this Enum value)
{
  if (value == null) return false;
  foreach (Enum item in Enum.GetValues(value.GetType()))
    if (item.HasFlag(value)) return true;
  return false;
}

[Flags]
public enum ExportFormat                                      
{
  None = 0,
  Csv = 1,
  Tsv = 2,
  Excel = 4,
  Word = 8,
  All = Excel | Csv | Tsv
}

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

static void Main(string[] args)
{
  var x = ExportFormat.Csv | ExportFormat.Excel;
  var y = ExportFormat.Csv | ExportFormat.Word;
  var z = (ExportFormat)16; //undefined value

  var xx = x.IsDefined();  //true
  var yy = y.IsDefined();  //true
  var zz = z.IsDefined();  //false
}

public static bool IsDefined(this ExportFormat value)
{
  var max = Enum.GetValues(typeof(ExportFormat)).Cast<ExportFormat>()
    .Aggregate((e1,e2) =>  e1 | e2);
  return (max & value) == value;
}

И если вы используете C# 4.0, где поддерживается DLR, вы можете использовать следующий классный независимый метод расширения:

public static bool IsDefined(this Enum value)
{
  dynamic dyn = value;
  var max = Enum.GetValues(value.GetType()).Cast<dynamic>().
    Aggregate((e1,e2) =>  e1 | e2);
  return (max & dyn) == dyn;
}

Примечание. Это необходимо сделать так, поскольку:

1. Операторы | и & нельзя применять к операндам типа Enum и Enum.
2. Эти операторы определены в компиляторе и не отражаются, поэтому нет никакого способа получить их с помощью выражений отражения/Linq, поверьте мне - я пробовал все это...

может попробовать поймать с разбором?
какие значения вы не хотите передавать?

    public T Value
    {
        get { return value; }
        set
        {
            try
            {
                Enum.Parse(typeof(T), value.ToString());
            }
            catch 
            {
                throw new ArgumentOutOfRangeException("value", value, "Value not defined in enum, " + typeof(T).Name);
            }
            if (!this.value.Equals(value))
            {
                this.value = value;

                PropertyChangedEventHandler handler = PropertyChanged;
                if (handler != null)
                    handler(this, new PropertyChangedEventArgs("Value"));
            }
        }
    }

Я знаю, что в этой ветке давно не было ответа, но я решил, что ответ на нее с помощью встроенной функции хорош для тех, кто посещает это после меня.

Используя исходное перечисление OP, вы можете проанализировать значение с битовой маской, используя следующий код.

    ExportFormat format;
    if (!Enum.TryParse<ExportFormat>(value.ToString(), out format))
    {
      // Could not parse
    }

Надеюсь, это поможет.

Вот как это сделать (использует Linq):

    private static bool IsDefined<T>(long value) where T : struct
    {
        var max = Enum.GetValues(typeof(T)).Cast<T>()
            .Select(v => Convert.ToInt64(v)).
            Aggregate((e1, e2) => e1 | e2);
        return (max & value) == value;
    }

Взгляните на IsValid метод библиотеки Enums.NET:

var validExportFormat = ExportFormat.Excel | ExportFormat.Csv;
validExportFormat.IsValid(EnumValidation.IsValidFlagCombination); // => true

var invalidExportFormat = (ExportFormat)100;
invalidExportFormat.IsValid(EnumValidation.IsValidFlagCombination); // => false

Любая допустимая комбинация значений перечисления дает нечисловое значение:

public static class EnumExtensions
{
    public static bool IsDefined(this Enum value) => !ulong.TryParse(value.ToString(), out _);
}

См. здесь. Довольно много кода.