Проверка значений перечисления

ИМХО, сообщение, помеченное как ответ, неверно.
Проверка 9X_validate параметров и данных - одна из тех вещей, которые 9X_visual-c# мне вверенили несколько десятилетий назад.

ПОЧЕМУ

Проверка 9X_validation необходима, поскольку перечислению может 9X_validator быть присвоено практически любое целочисленное 9X_visual-c# значение, не вызывая ошибки.
Я потратил 9X_c-sharp много дней на изучение проверки перечисления 9X_c# C#, потому что во многих случаях это необходимая 9X_form-validation функция.

ГДЕ

Основная цель проверки enum для 9X_input-validation меня - проверка данных, прочитанных из файла: вы 9X_validate никогда не узнаете, был ли файл поврежден, изменен 9X_input-validation извне или был специально взломан.
И с проверкой 9X_validator enum данных приложения, вставленных из буфера 9X_c#-language обмена: вы никогда не узнаете, редактировал 9X_validate ли пользователь содержимое буфера обмена.

Тем 9X_enumerations не менее, я провел дни, исследуя и тестируя 9X_visual-c# множество методов, включая профилирование 9X_enum производительности каждого метода, который 9X_c#-language я мог найти или разработать.

Выполнение вызовов 9X_validator чего-либо в System.Enum происходит настолько 9X_c#-language медленно, что это заметно снижает производительность 9X_validator функций, содержащих сотни или тысячи объектов, которые 9X_validation имеют одно или несколько перечислений в 9X_enum своих свойствах, которые должны быть проверены 9X_enum на наличие границ.

Итог: держитесь подальше 9X_c#.net от всего в классе System.Enum при проверке значений 9X_c#-language перечисления, это ужасно медленно.

РЕЗУЛЬТАТ

Метод, который 9X_form-validation я в настоящее время использую для проверки 9X_c-sharp перечисления, вероятно, вызовет у многих 9X_c#.net программистов закатные глаза, но, по-моему, это 9X_form-validation наименьшее зло для моего конкретного дизайна 9X_.cs-file приложения.

Я определяю одну или две константы, которые 9X_enumerations являются верхней и (необязательно) нижней 9X_c#-language границей перечисления, и использую их в 9X_validations паре операторов if() для проверки.
Одним 9X_validations из недостатков является то, что вы должны 9X_enums обязательно обновить константы при изменении 9X_validate перечисления.
Этот метод также работает 9X_validations только в том случае, если стиль перечисления 9X_validation является «автоматическим», где каждый элемент 9X_c#.net перечисления представляет собой инкрементное 9X_c#.net целочисленное значение, такое как 0,1,2,3,4, .... Он 9X_enum не будет работать должным образом с флагами 9X_enums или перечислениями, которые имеют значения, которые 9X_input-validation не являются инкрементными.

Также обратите 9X_validations внимание, что этот метод почти так же быстр, как 9X_c-sharp и обычный, если "<" ">" на обычных int32 9X_validator (которые набрали 38 000 тиков в моих тестах).

Например:

public const MyEnum MYENUM_MINIMUM = MyEnum.One; public const MyEnum MYENUM_MAXIMUM = MyEnum.Four; public enum MyEnum { One, Two, Three, Four }; public static MyEnum Validate(MyEnum value) { if (value < MYENUM_MINIMUM) { return MYENUM_MINIMUM; } if (value > MYENUM_MAXIMUM) { return MYENUM_MAXIMUM; } return value; } 

ЭФФЕКТИВНОСТЬ

Для 9X_c-sharp тех, кому интересно, я описал следующие 9X_enum варианты проверки enum, и вот результаты.

Профилирование 9X_validation выполнялось при компиляции выпуска в цикле 9X_enums из миллиона раз для каждого метода со случайным 9X_c-sharp целочисленным входным значением. Каждый 9X_enumerations тест проводился более 10 раз и усреднялся. Результаты 9X_visual-c# тиков включают общее время выполнения, которое 9X_form-validation будет включать генерацию случайных чисел 9X_.cs-file и т. Д., Но они будут постоянными во всех 9X_enums тестах. 1 тик = 10 нс.

Обратите внимание, что 9X_c# приведенный здесь код не является полным 9X_input-validation тестовым кодом, это только базовый метод 9X_validator проверки перечисления. Было также много 9X_validator дополнительных вариантов, которые были протестированы, и 9X_visual-c# все они дали результаты, аналогичные тем, которые 9X_enumerations показаны здесь, когда тестировалось 1 800 9X_enums 000 тиков.

От самого медленного к самому 9X_enumerations быстрому с округленными результатами, надеюсь, без 9X_form-validation опечаток.

Границы, определенные в методе = 13 600 000 тиков

public static T Clamp(T value) { int minimum = Enum.GetValues(typeof(T)).GetLowerBound(0); int maximum = Enum.GetValues(typeof(T)).GetUpperBound(0); if (Convert.ToInt32(value) < minimum) { return (T)Enum.ToObject(typeof(T), minimum); } if (Convert.ToInt32(value) > maximum) { return (T)Enum.ToObject(typeof(T), maximum); } return value; } 

Enum.IsDefined = 1 800 000 9X_validate тиков
Примечание: эта версия кода не ограничивает 9X_form-validation минимальное / максимальное значение, но 9X_validations возвращает значение по умолчанию, если оно 9X_c#.net выходит за границы.

public static T ValidateItem(T eEnumItem) { if (Enum.IsDefined(typeof(T), eEnumItem) == true) return eEnumItem; else return default(T); } 

System.Enum Convert Int32 с приведением типов = 1 800 000 тиков

public static Enum Clamp(this Enum value, Enum minimum, Enum maximum) { if (Convert.ToInt32(value) < Convert.ToInt32(minimum)) { return minimum; } if (Convert.ToInt32(value) > Convert.ToInt32(maximum)) { return maximum; } return value; } 

if() Мин. / Макс. Константы = 43 9X_.cs-file 000 тиков = победитель в 42 раза и в 316 9X_validate раз быстрее.

public static MyEnum Clamp(MyEnum value) { if (value < MYENUM_MINIMUM) { return MYENUM_MINIMUM; } if (value > MYENUM_MAXIMUM) { return MYENUM_MAXIMUM; } return value; } 

-eol-

Как уже упоминалось, Enum.IsDefined работает медленно, о 9X_.cs-file чем вы должны знать, если он находится в 9X_validate цикле.

При выполнении множественных сравнений 9X_enums более быстрый метод - сначала поместить 9X_validator значения в HashSet. Затем просто используйте Contains, чтобы 9X_validation проверить, действительно ли значение, например:

int userInput = 4; // below, Enum.GetValues converts enum to array. We then convert the array to hashset. HashSet validVals = new HashSet((int[])Enum.GetValues(typeof(MyEnum))); // the following could be in a loop, or do multiple comparisons, etc. if (validVals.Contains(userInput)) { // is valid } 

Вот быстрое универсальное решение, использующее 9X_validation статически построенный HashSet.

Вы можете определить 9X_enums это один раз в своем наборе инструментов, а 9X_form-validation затем использовать его для всей проверки 9X_.cs-file перечисления.

public static class EnumHelpers { /// 

/// Returns whether the given enum value is a defined value for its type. /// Throws if the type parameter is not an enum type. ///

 public static bool IsDefined(T enumValue) { if (typeof(T).BaseType != typeof(System.Enum)) throw new ArgumentException($"{nameof(T)} must be an enum type."); return EnumValueCache.DefinedValues.Contains(enumValue); } /// 

/// Statically caches each defined value for each enum type for which this class is accessed. /// Uses the fact that static things exist separately for each distinct type parameter. ///

 internal static class EnumValueCache { public static HashSet DefinedValues { get; } static EnumValueCache() { if (typeof(T).BaseType != typeof(System.Enum)) throw new Exception($"{nameof(T)} must be an enum type."); DefinedValues = new HashSet((T[])System.Enum.GetValues(typeof(T))); } } } 

Обратите внимание, что этот 9X_validate подход легко распространяется и на анализ 9X_c-sharp перечисления, используя словарь со строковыми 9X_c-sharp ключами (учитывая нечувствительность к регистру 9X_c-sharp и числовые строковые представления).

Брэд Абрамс специально предостерегает от 9X_enum Enum.IsDefined в своем посте The Danger of Oversimplification.

Лучший способ избавиться 9X_validation от этого требования (то есть от необходимости 9X_visual-c# проверять перечисления) — это удалить способы, в 9X_validate которых пользователи могут ошибиться, например, какое-либо 9X_validate поле ввода. Используйте перечисления с раскрывающимися 9X_validate списками, например, чтобы использовать только 9X_c-sharp действительные перечисления.

Этот ответ является ответом на ответ deegee, который 9X_visual-c# вызывает проблемы с производительностью 9X_enums System.Enum, поэтому его не следует воспринимать 9X_form-validation как мой предпочтительный общий ответ, более 9X_enum адресный для проверки enum в сценариях с 9X_c#.net жесткой производительностью.

Если у вас есть 9X_c#-language критически важная проблема производительности, когда 9X_csharp медленный, но функциональный код запускается 9X_form-validation в жестком цикле, я бы лично посмотрел на 9X_validator то, чтобы вывести этот код из цикла, если 9X_.cs-file это возможно, вместо того, чтобы решать 9X_c# за счет сокращения функциональности. Ограничение 9X_form-validation кода поддержкой только непрерывных перечислений 9X_visual-c# может стать кошмаром для поиска ошибки, если, например, кто-то 9X_enumerations в будущем решит отказаться от некоторых 9X_input-validation значений перечисления. Упрощенно вы можете 9X_c# просто вызвать Enum.GetValues ​​один раз, в 9X_validate самом начале, чтобы избежать срабатывания 9X_validate всех отражений и т. Д. Тысячи раз. Это должно 9X_enums дать вам немедленный рост производительности. Если 9X_.cs-file вам нужна более высокая производительность 9X_form-validation и вы знаете, что многие из ваших перечислений 9X_c# являются смежными (но вы все равно хотите 9X_validation поддерживать перечисления с gappy), вы можете 9X_validate пойти еще дальше и сделать что-то вроде:

public abstract class EnumValidator where TEnum : struct, IConvertible { protected static bool IsContiguous { get { int[] enumVals = Enum.GetValues(typeof(TEnum)).Cast().ToArray(); int lowest = enumVals.OrderBy(i => i).First(); int highest = enumVals.OrderByDescending(i => i).First(); return !Enumerable.Range(lowest, highest).Except(enumVals).Any(); } } public static EnumValidator Create() { if (!typeof(TEnum).IsEnum) { throw new ArgumentException("Please use an enum!"); } return IsContiguous ? (EnumValidator)new ContiguousEnumValidator() : new JumbledEnumValidator(); } public abstract bool IsValid(int value); } public class JumbledEnumValidator : EnumValidator where TEnum : struct, IConvertible { private readonly int[] _values; public JumbledEnumValidator() { _values = Enum.GetValues(typeof (TEnum)).Cast().ToArray(); } public override bool IsValid(int value) { return _values.Contains(value); } } public class ContiguousEnumValidator : EnumValidator where TEnum : struct, IConvertible { private readonly int _highest; private readonly int _lowest; public ContiguousEnumValidator() { List enumVals = Enum.GetValues(typeof (TEnum)).Cast().ToList(); _lowest = enumVals.OrderBy(i => i).First(); _highest = enumVals.OrderByDescending(i => i).First(); } public override bool IsValid(int value) { return value >= _lowest && value <= _highest; } } 

Где 9X_validations ваш цикл выглядит примерно так:

//Pre import-loop EnumValidator< MyEnum > enumValidator = EnumValidator< MyEnum >.Create(); while(import) //Tight RT loop. { bool isValid = enumValidator.IsValid(theValue); } 

Я уверен, что 9X_c# классы EnumValidator можно было бы написать 9X_input-validation более эффективно (это всего лишь небольшая 9X_c-sharp демонстрация), но, честно говоря, кого волнует, что 9X_validator происходит вне цикла импорта? Единственный 9X_c-sharp бит, который должен быть сверхбыстрым, - это 9X_c#-language внутри цикла. Это было причиной выбора маршрута 9X_validate абстрактного класса, чтобы избежать ненужного 9X_csharp if-enumContiguous-then-else в цикле (фабрика 9X_enums Create по существу делает это заранее). Вы 9X_enums заметите немного лицемерия, для краткости 9X_.cs-file этот код ограничивает функциональность int-enum. Я 9X_enums должен использовать IConvertible, а не использовать 9X_c-sharp int напрямую, но этот ответ уже достаточно 9X_form-validation многословен!

Основываясь на ответе Тимо, я создал следующий 9X_validate метод расширения (синтаксис C# 6), чтобы 9X_enumerations предоставить быстрое универсальное решение.

Это 9X_validator позволяет избежать проблем с производительностью, связанных 9X_enum с Enum.IsDefined, а в качестве бонуса предоставляет более 9X_c#-language чистый синтаксис.

public static class EnumHelpers { /// 

/// Returns whether the given enum value is a defined value for its type. ///

 public static bool IsDefined(this T enumValue) where T : Enum => EnumValueCache.DefinedValues.Contains(enumValue); /// 

/// Caches the defined values for each enum type for which this class is accessed. ///

 private static class EnumValueCache where T : Enum { public static readonly HashSet DefinedValues = new HashSet((T[])Enum.GetValues(typeof(T))); } } 

Использование:

if (!myEnumValue.IsDefined()) // ... 

Вот как я это делаю, основываясь на нескольких 9X_c# сообщениях в Интернете. Причина в том, чтобы 9X_validation убедиться, что перечисления, отмеченные 9X_csharp атрибутом Flags, также могут быть успешно проверены.

public static TEnum ParseEnum(string valueString, string parameterName = null) { var parsed = (TEnum)Enum.Parse(typeof(TEnum), valueString, true); decimal d; if (!decimal.TryParse(parsed.ToString(), out d)) { return parsed; } if (!string.IsNullOrEmpty(parameterName)) { throw new ArgumentException(string.Format("Bad parameter value. Name: {0}, value: {1}", parameterName, valueString), parameterName); } else { throw new ArgumentException("Bad value. Value: " + valueString); } } 

Вы можете использовать FluentValidation 9X_enums для своего проекта. Вот простой пример для 9X_form-validation «Enum Validation»

Давайте создадим класс 9X_c-sharp EnumValidator с помощью FluentValidation;

public class EnumValidator : AbstractValidator where TEnum : struct, IConvertible, IComparable, IFormattable { public EnumValidator(string message) { RuleFor(a => a).Must(a => typeof(TEnum).IsEnum).IsInEnum().WithMessage(message); } } 

Теперь 9X_form-validation мы создали наш класс enumvalidator; давайте 9X_enums создадим класс для вызова класса enumvalidor;

 public class Customer { public string Name { get; set; } public Address address{ get; set; } public AddressType type {get; set;} } public class Address { public string Line1 { get; set; } public string Line2 { get; set; } public string Town { get; set; } public string County { get; set; } public string Postcode { get; set; } 

}

public enum AddressType { HOME, WORK } 

Пришло 9X_validations время вызвать наш валидатор перечисления 9X_validation для типа адреса в классе клиента.

public class CustomerValidator : AbstractValidator { public CustomerValidator() { RuleFor(x => x.type).SetValidator(new EnumValidator("errormessage"); } } 

Объяснить масштабирование производительности 9X_enums конкретно по методу Тимо/Мэтта Дженкинса: Рассмотрим 9X_c# следующий код:

//System.Diagnostics - Stopwatch //System - ConsoleColor //System.Linq - Enumerable Stopwatch myTimer = Stopwatch.StartNew(); int myCyclesMin = 0; int myCyclesCount = 10000000; long myExt_IsDefinedTicks; long myEnum_IsDefinedTicks; foreach (int lCycles in Enumerable.Range(myCyclesMin, myCyclesMax)) { Console.WriteLine(string.Format("Cycles: {0}", lCycles)); myTimer.Restart(); foreach (int _ in Enumerable.Range(0, lCycles)) { ConsoleColor.Green.IsDefined(); } myExt_IsDefinedTicks = myTimer.ElapsedTicks; myTimer.Restart(); foreach (int _ in Enumerable.Range(0, lCycles)) { Enum.IsDefined(typeof(ConsoleColor), ConsoleColor.Green); } myEnum_IsDefinedTicks = myTimer.E Console.WriteLine(string.Format("object.IsDefined() Extension Elapsed: {0}", myExt_IsDefinedTicks.ToString())); Console.WriteLine(string.Format("Enum.IsDefined(Type, object): {0}", myEnum_IsDefinedTicks.ToString())); if (myExt_IsDefinedTicks == myEnum_IsDefinedTicks) { Console.WriteLine("Same"); } else if (myExt_IsDefinedTicks < myEnum_IsDefinedTicks) { Console.WriteLine("Extension"); } else if (myExt_IsDefinedTicks > myEnum_IsDefinedTicks) { Console.WriteLine("Enum"); } } 

Вывод начинается следующим 9X_enums образом:

Cycles: 0 object.IsDefined() Extension Elapsed: 399 Enum.IsDefined(Type, object): 31 Enum Cycles: 1 object.IsDefined() Extension Elapsed: 213654 Enum.IsDefined(Type, object): 1077 Enum Cycles: 2 object.IsDefined() Extension Elapsed: 108 Enum.IsDefined(Type, object): 112 Extension Cycles: 3 object.IsDefined() Extension Elapsed: 9 Enum.IsDefined(Type, object): 30 Extension Cycles: 4 object.IsDefined() Extension Elapsed: 9 Enum.IsDefined(Type, object): 35 Extension 

Похоже, это указывает на высокую 9X_validations стоимость установки статического объекта 9X_c#.net hashset (в моей среде примерно 15-20 мс. Изменение 9X_validations того, какой метод вызывается первым, не 9X_c#-language меняет того факта, что первый вызов метода 9X_c#.net расширения (для настройки статического хэш-набора) довольно 9X_form-validation длинный. Enum.IsDefined(typeof(T), object) также длиннее обычного для первого 9X_validator цикла, но, что интересно, гораздо меньше.

Исходя 9X_enum из этого, кажется, что Enum.IsDefined(typeof(T), object) на самом деле быстрее 9X_validation до lCycles = 50000 или около того.

Я не уверен, почему Enum.IsDefined(typeof(T), object) становится 9X_validator быстрее как при 2, так и при 3 поиске, прежде 9X_c# чем начнет расти. Ясно, что происходит какой-то 9X_validate внутренний процесс, так как object.IsDefined() также занимает 9X_c#-language заметно больше времени для первых 2 поисков, прежде 9X_validation чем он начнет быстро истекать кровью.

Другой 9X_c# способ сформулировать это так: если вам 9X_c-sharp нужно выполнить множество операций поиска 9X_c#.net с любой другой удаленно длительной операцией 9X_enum (например, файловой операцией, такой как 9X_enumerations открытие), которая добавит несколько миллисекунд, первоначальная 9X_validate настройка для object.IsDefined() будет поглощена (особенно 9X_form-validation если асинхронный) и становятся практически 9X_validation незаметными. В этот момент Enum.IsDefined(typeof(T), object) выполняется 9X_form-validation примерно в 5 раз дольше.

В принципе, если 9X_c# у вас нет буквально тысяч вызовов для одного 9X_c-sharp и того же Enum, я не уверен, как хеширование 9X_validator содержимого сэкономит вам время при выполнении 9X_.cs-file вашей программы. Enum.IsDefined(typeof(T), object) может иметь концептуальные 9X_validation проблемы с производительностью, но, в конечном 9X_validations счете, он достаточно быстр, пока он вам 9X_enum не понадобится тысячи раз для одного и того 9X_visual-c# же перечисления.

Интересно отметить, что 9X_enumerations реализация ValueCache в качестве гибридного 9X_enums словаря дает время запуска, которое достигает 9X_enum паритета с Enum.IsDefined(typeof(T), object) за ~1500 итераций. Конечно, использование 9X_validate HashSet проходит через ~ 50 КБ.

Итак, мой 9X_form-validation совет: если вся ваша программа проверяет 9X_validate одно и то же перечисление (проверка разных 9X_form-validation перечислений вызывает одинаковый уровень 9X_.cs-file задержки запуска, один раз для каждого отдельного 9X_c#.net перечисления) менее 1500 раз, используйте 9X_enum Enum.IsDefined(typeof(T), object). Если у вас от 1500 до 50 КБ, используйте 9X_enumerations HybridDictionary для своего хеш-набора, начальное 9X_form-validation заполнение кеша происходит примерно в 10 9X_validate раз быстрее. Что-нибудь более 50 тысяч итераций, HashSet 9X_c-sharp является довольно явным победителем.

Также 9X_validations имейте в виду, что мы говорим в Ticks. В 9X_enumerations .Net 10 000 тиков — это 1 мс.

Для полного 9X_.cs-file раскрытия информации я также протестировал 9X_enums List в качестве кеша, и он занимает около 9X_c# 1/3 времени заполнения хэш-набора, однако 9X_c-sharp для любого перечисления более 9 или около 9X_enum того элементов это намного медленнее, чем 9X_form-validation любой другой метод. Если все ваши перечисления 9X_enum меньше 9 элементов (или еще меньше), это 9X_visual-c# может быть самый быстрый подход.

Кэш, определенный 9X_validate как HybridDictionary (да, ключи и значения 9X_c#-language одинаковы. Да, его немного сложнее читать, чем 9X_enums более простые ответы, упомянутые выше):

//System.Collections.Specialized - HybridDictionary private static class EnumHybridDictionaryValueCache where T : Enum { static T[] enumValues = (T[])Enum.GetValues(typeof(T)); static HybridDictionary PopulateDefinedValues() { HybridDictionary myDictionary = new HybridDictionary(enumValues.Length); foreach (T lEnumValue in enumValues) { //Has to be unique, values are actually based on the int value. Enums with multiple aliases for one value will fail without checking. //Check implicitly by using assignment. myDictionary[lEnumValue] = lEnumValue; } return myDictionary; } public static readonly HybridDictionary DefinedValues = PopulateDefinedValues(); }