пример - msdn enum c#




Создать общий метод, ограничивающий T до Enum (14)

Я создаю функцию для расширения концепции 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;
}

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

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

EDIT Все предложения ниже были высоко оценены, спасибо.

Устроились (я вышел из цикла, чтобы поддерживать нечувствительность к регистру - я использую это при анализе 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;
    }
}

EDIT: (16 февраля 2015 г.) Жюльен Лебоскейн недавно опубликовал обобщенное универсальное решение для компилятора в MSIL или F # ниже, которое стоит посмотреть и повысить. Я удалю это редактирование, если решение пузырится дальше страницы.


C # ≥ 7,3

Начиная с C # 7.3 (доступно в Visual Studio 2017 ≥ v.15.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 и любым типом интерфейса.


Эта функция, наконец, поддерживается в 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

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

К сожалению, VS2010 (и раньше, очевидно) не поддерживает добавление ссылок netmodule, а это означает, что вам придется оставить его в двух отдельных сборках при отладке. Единственный способ добавить их как часть вашей сборки - это запустить сам 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

Это проще в обслуживании, так как это хорошо известный язык с полной поддержкой IDE Visual Studio, но для этого вам по-прежнему нужен отдельный проект. Однако он, естественно, производит значительно разные ИЛ (код очень отличается), и он полагается на библиотеку 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);

Интересно, что это возможно в других языках (Managed C ++, IL напрямую).

Цитировать:

... Оба ограничения на самом деле производят действительный IL и могут также потребляться C #, если они написаны на другом языке (вы можете объявить эти ограничения в управляемом C ++ или IL).

Кто знает


Как указывалось в других ответах ранее; в то время как это невозможно выразить в исходном коде, это действительно можно сделать на уровне IL. Ответ @ Кристофер Курренс показывает, как это делают ИЛ.

С помощью Fody s Add-In ExtraConstraints.Fody этого достаточно простой способ, в комплекте с инструментами построения. Просто добавьте свои пакеты ExtraConstraints.Fody ( Fody , ExtraConstraints.Fody ) в свой проект и добавьте ограничения следующим образом (Выдержка из Readme of ExtraConstraints):

public void MethodWithEnumConstraint<[EnumConstraint] T>() {...}

public void MethodWithTypeEnumConstraint<[EnumConstraint(typeof(ConsoleColor))] T>() {...}

и Fody добавит необходимый IL для присутствия ограничения. Также обратите внимание на дополнительную функцию ограничения делегатов:

public void MethodWithDelegateConstraint<[DelegateConstraint] T> ()
{...}

public void MethodWithTypeDelegateConstraint<[DelegateConstraint(typeof(Func<int>))] T> ()
{...}

Что касается Enums, вы можете также обратить внимание на очень интересный Enums.NET .


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

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;
      }
}

Поскольку тип 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 . Однако шансы редки.


Также следует учитывать, что, поскольку выпуск 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, см. Следующий снимок экрана:

EDIT 1 - Требуемая версия Visual Studio и рассмотрение ReSharper

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

Pls также отмечает, что в моем случае ReSharper 2018.1 с момента написания этого EDIT еще не поддерживает 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 или выше.


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

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());
}

Я инкапсулировал решение Vivek в класс утилиты, который можно использовать повторно. Обратите внимание, что вы все равно должны определять ограничения типа «где T: struct, IConvertible» для вашего типа.

using System;

internal static class EnumEnforcer
{
    /// <summary>
    /// Makes sure that generic input parameter is of an enumerated type.
    /// </summary>
    /// <typeparam name="T">Type that should be checked.</typeparam>
    /// <param name="typeParameterName">Name of the type parameter.</param>
    /// <param name="methodName">Name of the method which accepted the parameter.</param>
    public static void EnforceIsEnum<T>(string typeParameterName, string methodName)
        where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            string message = string.Format(
                "Generic parameter {0} in {1} method forces an enumerated type. Make sure your type parameter {0} is an enum.",
                typeParameterName,
                methodName);

            throw new ArgumentException(message);
        }
    }

    /// <summary>
    /// Makes sure that generic input parameter is of an enumerated type.
    /// </summary>
    /// <typeparam name="T">Type that should be checked.</typeparam>
    /// <param name="typeParameterName">Name of the type parameter.</param>
    /// <param name="methodName">Name of the method which accepted the parameter.</param>
    /// <param name="inputParameterName">Name of the input parameter of this page.</param>
    public static void EnforceIsEnum<T>(string typeParameterName, string methodName, string inputParameterName)
        where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            string message = string.Format(
                "Generic parameter {0} in {1} method forces an enumerated type. Make sure your input parameter {2} is of correct type.",
                typeParameterName,
                methodName,
                inputParameterName);

            throw new ArgumentException(message);
        }
    }

    /// <summary>
    /// Makes sure that generic input parameter is of an enumerated type.
    /// </summary>
    /// <typeparam name="T">Type that should be checked.</typeparam>
    /// <param name="exceptionMessage">Message to show in case T is not an enum.</param>
    public static void EnforceIsEnum<T>(string exceptionMessage)
        where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException(exceptionMessage);
        }
    }
}

Я любил решение Кристофера Карренса с помощью IL, но для тех, кто не хочет заниматься сложным делом, включая MSIL, в свой процесс сборки, я написал аналогичную функцию на C #.

Обратите внимание, что вы не можете использовать общие ограничения, например where T : Enum потому что Enum является специальным типом. Поэтому я должен проверить, действительно ли данный родовой тип перечислит.

Моя функция:

public static T GetEnumFromString<T>(string strValue, T defaultValue)
{
    // Check if it realy enum at runtime 
    if (!typeof(T).IsEnum)
        throw new ArgumentException("Method GetEnumFromString can be used with enums only");

    if (!string.IsNullOrEmpty(strValue))
    {
        IEnumerator enumerator = Enum.GetValues(typeof(T)).GetEnumerator();
        while (enumerator.MoveNext())
        {
            T temp = (T)enumerator.Current;
            if (temp.ToString().ToLower().Equals(strValue.Trim().ToLower()))
                return temp;
        }
    }

    return defaultValue;
}

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

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;
}

Я создал расширение Метод, to get integer value from enum взглянуть на реализацию метода

public static int ToInt<T>(this T soure) where T : IConvertible//enum
{
    if (typeof(T).IsEnum)
    {
        return (int) (IConvertible)soure;// the tricky part
    }
    //else
    //    throw new ArgumentException("T must be an enumerated type");
    return soure.ToInt32(CultureInfo.CurrentCulture);
}

это использование

MemberStatusEnum.Activated.ToInt()// using extension Method
(int) MemberStatusEnum.Activated //the ordinary way

В java вы будете использовать ...

    SomeClass<T extends enum> {
}

Довольно просто.


Если это нормально использовать прямое литье после этого, я думаю, вы можете использовать System.Enumбазовый класс в своем методе, где это необходимо. Вам просто нужно тщательно менять параметры типа. Таким образом, реализация метода будет выглядеть так:

public static class EnumUtils
{
    public static Enum GetEnumFromString(string value, Enum defaultValue)
    {
        if (string.IsNullOrEmpty(value)) return defaultValue;
        foreach (Enum item in Enum.GetValues(defaultValue.GetType()))
        {
            if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
        }
        return defaultValue;
    }
}

Затем вы можете использовать его так:

var parsedOutput = (YourEnum)EnumUtils.GetEnumFromString(someString, YourEnum.DefaultValue);




generic-constraints