Создать общий метод, ограничивающий перечисление - PullRequest
1055 голосов
/ 17 сентября 2008

Я создаю функцию для расширения концепции Enum.Parse, которая

  • Позволяет проанализировать значение по умолчанию в случае, если значение Enum не найдено
  • Не чувствителен к регистру

Итак, я написал следующее:

public static T GetEnumFromString<T>(string value, T defaultValue) where T : Enum
{
    if (string.IsNullOrEmpty(value)) return defaultValue;
    foreach (T item in Enum.GetValues(typeof(T)))
    {
        if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
    }
    return defaultValue;
}

Я получаю сообщение об ошибке Ограничение не может быть специальным классом System.Enum.

Достаточно справедливо, но есть ли обходной путь, чтобы разрешить Generic Enum, или я собираюсь имитировать функцию Parse и передавать тип в качестве атрибута, что заставляет ваш код предъявлять ужасные требования к боксу.

РЕДАКТИРОВАТЬ Все предложения ниже были высоко оценены, спасибо.

остановились (я вышел из цикла, чтобы сохранить нечувствительность к регистру - я использую это при разборе XML)

public static class EnumUtils
{
    public static T ParseEnum<T>(string value, T defaultValue) where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum) throw new ArgumentException("T must be an enumerated type");
        if (string.IsNullOrEmpty(value)) return defaultValue;

        foreach (T item in Enum.GetValues(typeof(T)))
        {
            if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
        }
        return defaultValue;
    }
}

РЕДАКТИРОВАТЬ: (16 февраля 2015 г.) Жюльен Лебосквейн недавно опубликовал обобщенное принудительное решение с типобезопасным типом в MSIL или F # ниже, которое стоит посмотреть, и upvote. Я удалю эту правку, если раствор поднимется вверх по странице.

Ответы [ 20 ]

933 голосов
/ 17 сентября 2008

Поскольку Enum Тип реализует интерфейс IConvertible, лучшая реализация должна выглядеть примерно так:

public T GetEnumFromString<T>(string value) where T : struct, IConvertible
{
   if (!typeof(T).IsEnum) 
   {
      throw new ArgumentException("T must be an enumerated type");
   }

   //...
}

Это по-прежнему разрешает передачу типов значений, реализующих IConvertible. Хотя шансы редки.

532 голосов
/ 11 ноября 2011

Эта функция наконец поддерживается в C # 7.3!

Следующий фрагмент (из образцов dotnet ) демонстрирует, как:

public static Dictionary<int, string> EnumNamedValues<T>() where T : System.Enum
{
    var result = new Dictionary<int, string>();
    var values = Enum.GetValues(typeof(T));

    foreach (int item in values)
        result.Add(item, Enum.GetName(typeof(T), item));
    return result;
}

Убедитесь, что в вашем проекте C # установлена ​​языковая версия версии 7.3.


Оригинальный ответ ниже:

Я опоздал на игру, но я воспринял это как вызов, чтобы посмотреть, как это можно сделать. Это невозможно в C # (или VB.NET, но прокрутите вниз для F #), но возможно в MSIL. Я написал эту маленькую .... вещь

// license: http://www.apache.org/licenses/LICENSE-2.0.html
.assembly MyThing{}
.class public abstract sealed MyThing.Thing
       extends [mscorlib]System.Object
{
  .method public static !!T  GetEnumFromString<valuetype .ctor ([mscorlib]System.Enum) T>(string strValue,
                                                                                          !!T defaultValue) cil managed
  {
    .maxstack  2
    .locals init ([0] !!T temp,
                  [1] !!T return_value,
                  [2] class [mscorlib]System.Collections.IEnumerator enumerator,
                  [3] class [mscorlib]System.IDisposable disposer)
    // if(string.IsNullOrEmpty(strValue)) return defaultValue;
    ldarg strValue
    call bool [mscorlib]System.String::IsNullOrEmpty(string)
    brfalse.s HASVALUE
    br RETURNDEF         // return default it empty

    // foreach (T item in Enum.GetValues(typeof(T)))
  HASVALUE:
    // Enum.GetValues.GetEnumerator()
    ldtoken !!T
    call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
    call class [mscorlib]System.Array [mscorlib]System.Enum::GetValues(class [mscorlib]System.Type)
    callvirt instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Array::GetEnumerator() 
    stloc enumerator
    .try
    {
      CONDITION:
        ldloc enumerator
        callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
        brfalse.s LEAVE

      STATEMENTS:
        // T item = (T)Enumerator.Current
        ldloc enumerator
        callvirt instance object [mscorlib]System.Collections.IEnumerator::get_Current()
        unbox.any !!T
        stloc temp
        ldloca.s temp
        constrained. !!T

        // if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
        callvirt instance string [mscorlib]System.Object::ToString()
        callvirt instance string [mscorlib]System.String::ToLower()
        ldarg strValue
        callvirt instance string [mscorlib]System.String::Trim()
        callvirt instance string [mscorlib]System.String::ToLower()
        callvirt instance bool [mscorlib]System.String::Equals(string)
        brfalse.s CONDITION
        ldloc temp
        stloc return_value
        leave.s RETURNVAL

      LEAVE:
        leave.s RETURNDEF
    }
    finally
    {
        // ArrayList's Enumerator may or may not inherit from IDisposable
        ldloc enumerator
        isinst [mscorlib]System.IDisposable
        stloc.s disposer
        ldloc.s disposer
        ldnull
        ceq
        brtrue.s LEAVEFINALLY
        ldloc.s disposer
        callvirt instance void [mscorlib]System.IDisposable::Dispose()
      LEAVEFINALLY:
        endfinally
    }

  RETURNDEF:
    ldarg defaultValue
    stloc return_value

  RETURNVAL:
    ldloc return_value
    ret
  }
} 

, которая генерирует функцию, которая будет выглядеть так, если бы она была действительной C #:

T GetEnumFromString<T>(string valueString, T defaultValue) where T : Enum

Затем с помощью следующего кода C #:

using MyThing;
// stuff...
private enum MyEnum { Yes, No, Okay }
static void Main(string[] args)
{
    Thing.GetEnumFromString("No", MyEnum.Yes); // returns MyEnum.No
    Thing.GetEnumFromString("Invalid", MyEnum.Okay);  // returns MyEnum.Okay
    Thing.GetEnumFromString("AnotherInvalid", 0); // compiler error, not an Enum
}

К сожалению, это означает, что эта часть вашего кода написана на MSIL вместо C #, с единственным дополнительным преимуществом, что вы можете ограничить этот метод System.Enum. Это также своего рода облом, потому что он собирается в отдельную сборку. Однако это не означает, что вы должны развернуть его таким образом.

Удаляя строку .assembly MyThing{} и вызывая ilasm следующим образом:

ilasm.exe /DLL /OUTPUT=MyThing.netmodule

вместо сборки вы получаете сетевой модуль.

К сожалению, VS2010 (и ранее, очевидно) не поддерживает добавление ссылок сетевого модуля, что означает, что вам придется оставлять его в 2 отдельных сборках при отладке. Единственный способ добавить их как часть вашей сборки - это запустить csc.exe самостоятельно, используя аргумент командной строки /addmodule:{files}. Это не будет слишком болезненным в сценарии MSBuild. Конечно, если вы смелый или глупый, вы можете каждый раз запускать csc самостоятельно. И это, безусловно, усложняется, поскольку доступ к нему требуется нескольким сборкам.

Итак, это МОЖЕТ быть сделано в .Net. Это стоит дополнительных усилий? Ну, я думаю, что я позволю вам принять решение по этому вопросу.


F # Решение как альтернатива

Дополнительный кредит: получается, что общее ограничение на enum возможно по крайней мере на одном другом языке .NET, кроме MSIL: F #.

type MyThing =
    static member GetEnumFromString<'T when 'T :> Enum> str defaultValue: 'T =
        /// protect for null (only required in interop with C#)
        let str = if isNull str then String.Empty else str

        Enum.GetValues(typedefof<'T>)
        |> Seq.cast<_>
        |> Seq.tryFind(fun v -> String.Compare(v.ToString(), str.Trim(), true) = 0)
        |> function Some x -> x | None -> defaultValue

Этот вариант проще поддерживать, поскольку он является хорошо известным языком с полной поддержкой Visual Studio IDE, но для него вам все равно нужен отдельный проект. Тем не менее, он, естественно, производит значительно другой IL (код очень отличается ) и опирается на библиотеку FSharp.Core, которая, как и любая другая внешняя библиотека, должна стать частью вашего дистрибутива.

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

// works, result is inferred to have type StringComparison
var result = MyThing.GetEnumFromString("OrdinalIgnoreCase", StringComparison.Ordinal);
// type restriction is recognized by C#, this fails at compile time
var result = MyThing.GetEnumFromString("OrdinalIgnoreCase", 42);
182 голосов
/ 15 февраля 2015

C # ≥ 7,3

Начиная с C # 7.3 (доступно в Visual Studio 2017 ≥ v15.7), этот код теперь полностью действителен:

public static TEnum Parse<TEnum>(string value)
where TEnum : struct, Enum { ... }

C # ≤ 7,2

Вы можете использовать реальное ограничение перечисления, применяемое компилятором, если будете использовать наследование ограничений. Следующий код определяет одновременно ограничения class и struct:

public abstract class EnumClassUtils<TClass>
where TClass : class
{

    public static TEnum Parse<TEnum>(string value)
    where TEnum : struct, TClass
    {
        return (TEnum) Enum.Parse(typeof(TEnum), value);
    }

}

public class EnumUtils : EnumClassUtils<Enum>
{
}

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

EnumUtils.Parse<SomeEnum>("value");

Примечание: это специально указано в спецификации языка C # 5.0:

Если параметр типа S зависит от параметра типа T, то: [...] Это действительно для S иметь ограничение типа значения и T иметь ссылочный тип ограничение. Фактически это ограничивает T типами System.Object, System.ValueType, System.Enum и любой тип интерфейса.

30 голосов
/ 24 мая 2013

Редактировать

На этот вопрос теперь великолепно ответил Julien Lebosquain . Я также хотел бы дополнить его ответ ignoreCase, defaultValue и необязательными аргументами, добавив при этом TryParse и ParseOrDefault.

public abstract class ConstrainedEnumParser<TClass> where TClass : class
// value type constraint S ("TEnum") depends on reference type T ("TClass") [and on struct]
{
    // internal constructor, to prevent this class from being inherited outside this code
    internal ConstrainedEnumParser() {}
    // Parse using pragmatic/adhoc hard cast:
    //  - struct + class = enum
    //  - 'guaranteed' call from derived <System.Enum>-constrained type EnumUtils
    public static TEnum Parse<TEnum>(string value, bool ignoreCase = false) where TEnum : struct, TClass
    {
        return (TEnum)Enum.Parse(typeof(TEnum), value, ignoreCase);
    }
    public static bool TryParse<TEnum>(string value, out TEnum result, bool ignoreCase = false, TEnum defaultValue = default(TEnum)) where TEnum : struct, TClass // value type constraint S depending on T
    {
        var didParse = Enum.TryParse(value, ignoreCase, out result);
        if (didParse == false)
        {
            result = defaultValue;
        }
        return didParse;
    }
    public static TEnum ParseOrDefault<TEnum>(string value, bool ignoreCase = false, TEnum defaultValue = default(TEnum)) where TEnum : struct, TClass // value type constraint S depending on T
    {
        if (string.IsNullOrEmpty(value)) { return defaultValue; }
        TEnum result;
        if (Enum.TryParse(value, ignoreCase, out result)) { return result; }
        return defaultValue;
    }
}

public class EnumUtils: ConstrainedEnumParser<System.Enum>
// reference type constraint to any <System.Enum>
{
    // call to parse will then contain constraint to specific <System.Enum>-class
}

Примеры использования:

WeekDay parsedDayOrArgumentException = EnumUtils.Parse<WeekDay>("monday", ignoreCase:true);
WeekDay parsedDayOrDefault;
bool didParse = EnumUtils.TryParse<WeekDay>("clubs", out parsedDayOrDefault, ignoreCase:true);
parsedDayOrDefault = EnumUtils.ParseOrDefault<WeekDay>("friday", ignoreCase:true, defaultValue:WeekDay.Sunday);

Старый

Мои старые улучшения Ответ Вивека с помощью комментариев и «новых» разработок:

  • используйте TEnum для ясности для пользователей
  • добавить дополнительные ограничения интерфейса для дополнительной проверки ограничений
  • let TryParse handle ignoreCase с существующим параметром (введено в VS2010 / .Net 4)
  • при желании можно использовать общее default значение (введено в VS2005 / .Net 2)
  • использовать необязательные аргументы (введено в VS2010 / .Net 4) со значениями по умолчанию для defaultValue и ignoreCase

в результате:

public static class EnumUtils
{
    public static TEnum ParseEnum<TEnum>(this string value,
                                         bool ignoreCase = true,
                                         TEnum defaultValue = default(TEnum))
        where TEnum : struct,  IComparable, IFormattable, IConvertible
    {
        if ( ! typeof(TEnum).IsEnum) { throw new ArgumentException("TEnum must be an enumerated type"); }
        if (string.IsNullOrEmpty(value)) { return defaultValue; }
        TEnum lResult;
        if (Enum.TryParse(value, ignoreCase, out lResult)) { return lResult; }
        return defaultValue;
    }
}
18 голосов
/ 17 сентября 2008

Вы можете определить статический конструктор для класса, который будет проверять, что тип T является перечислением, и выдает исключение, если это не так. Этот метод упоминается Джеффри Рихтером в его книге CLR через C #.

internal sealed class GenericTypeThatRequiresAnEnum<T> {
    static GenericTypeThatRequiresAnEnum() {
        if (!typeof(T).IsEnum) {
        throw new ArgumentException("T must be an enumerated type");
        }
    }
}

Затем в методе разбора вы можете просто использовать Enum.Parse (typeof (T), input, true) для преобразования строки в перечисление. Последний истинный параметр предназначен для игнорирования регистра ввода.

13 голосов
/ 10 мая 2018

Следует также учитывать, что, поскольку выпуск C # 7.3 с использованием ограничений Enum поддерживается "из коробки" без необходимости дополнительной проверки и прочего.

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

    private static T GetEnumFromString<T>(string value, T defaultValue) where T : Enum
    {
        // Your code goes here...
    }

Если вы не знаете, как изменить языковую версию на C # 7.3, см. Следующий снимок экрана: enter image description here

РЕДАКТИРОВАТЬ 1 - Требуемая версия Visual Studio и учитывая ReSharper

Чтобы Visual Studio мог распознать новый синтаксис, вам нужна версия не ниже 15.7. Вы также можете найти это в примечаниях к выпуску Microsoft, см. Замечания к выпуску Visual Studio 2017 15.7 . Спасибо @MohamedElshawaf за указание на этот действительный вопрос.

Просьба также заметить, что в моем случае ReSharper 2018.1 на момент написания этой редакции еще не поддерживал C # 7.3. После активации ReSharper ограничение Enum выделяется как ошибка, сообщающая мне Невозможно использовать 'System.Array', 'System.Delegate', 'System.Enum', 'System.ValueType', 'object' в качестве ограничения параметра типа . В качестве быстрого исправления ReSharper предлагает Снять ограничение 'Enum' для параметра типа T метода

Однако, если вы временно отключите ReSharper в Инструменты -> Параметры -> ReSharper Ultimate -> Общие , вы увидите, что синтаксис отлично работает, если вы используете VS 15.7 или выше и C # 7.3 или выше.

11 голосов
/ 17 сентября 2008

Я модифицировал образец от димарзиониста. Эта версия будет работать только с Enums и не пропускать структуры.

public static T ParseEnum<T>(string enumString)
    where T : struct // enum 
    {
    if (String.IsNullOrEmpty(enumString) || !typeof(T).IsEnum)
       throw new Exception("Type given must be an Enum");
    try
    {

       return (T)Enum.Parse(typeof(T), enumString, true);
    }
    catch (Exception ex)
    {
       return default(T);
    }
}
9 голосов
/ 16 декабря 2010

Я попытался немного улучшить код:

public T LoadEnum<T>(string value, T defaultValue = default(T)) where T : struct, IComparable, IFormattable, IConvertible
{
    if (Enum.IsDefined(typeof(T), value))
    {
        return (T)Enum.Parse(typeof(T), value, true);
    }
    return defaultValue;
}
5 голосов
/ 18 апреля 2010

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

public static class XmlEnumExtension
{
    public static string ReadXmlEnumAttribute(this Enum value)
    {
        if (value == null) throw new ArgumentNullException("value");
        var attribs = (XmlEnumAttribute[]) value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof (XmlEnumAttribute), true);
        return attribs.Length > 0 ? attribs[0].Name : value.ToString();
    }

    public static T ParseXmlEnumAttribute<T>(this string str)
    {
        foreach (T item in Enum.GetValues(typeof(T)))
        {
            var attribs = (XmlEnumAttribute[])item.GetType().GetField(item.ToString()).GetCustomAttributes(typeof(XmlEnumAttribute), true);
            if(attribs.Length > 0 && attribs[0].Name.Equals(str)) return item;
        }
        return (T)Enum.Parse(typeof(T), str, true);
    }
}

public enum MyEnum
{
    [XmlEnum("First Value")]
    One,
    [XmlEnum("Second Value")]
    Two,
    Three
}

 static void Main()
 {
    // Parsing from XmlEnum attribute
    var str = "Second Value";
    var me = str.ParseXmlEnumAttribute<MyEnum>();
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
    // Parsing without XmlEnum
    str = "Three";
    me = str.ParseXmlEnumAttribute<MyEnum>();
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
    me = MyEnum.One;
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
}
4 голосов
/ 17 сентября 2008

Надеюсь, это полезно:

public static TValue ParseEnum<TValue>(string value, TValue defaultValue)
                  where TValue : struct // enum 
{
      try
      {
            if (String.IsNullOrEmpty(value))
                  return defaultValue;
            return (TValue)Enum.Parse(typeof (TValue), value);
      }
      catch(Exception ex)
      {
            return defaultValue;
      }
}
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...