T를 Enum으로 제한하는 일반 메서드 만들기

StackOverflow https://stackoverflow.com/questions/79126

문제

확장하는 기능을 구축 중입니다. 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;
    }
}

편집하다: (2015년 2월 16일) Julien Lebosquain이 최근 게시했습니다. MSIL 또는 F#의 컴파일러 강제 형식 안전 일반 솔루션 아래에 한 번 볼만한 가치가 있으며 공감할 가치가 있습니다.솔루션이 페이지 위로 올라오면 이 편집 내용을 제거하겠습니다.

도움이 되었습니까?

해결책

부터 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에서 마침내 지원됩니다!

다음 스니펫( 닷넷 샘플)는 다음 방법을 보여줍니다.

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
}

불행하게도 이는 C# 대신 MSIL로 코드의 이 부분을 작성해야 함을 의미하며, 유일한 추가 이점은 이 방법을 다음과 같이 제한할 수 있다는 것입니다. System.Enum.또한 별도의 어셈블리로 컴파일되기 때문에 다소 당황스럽습니다.그러나 이것이 반드시 그런 방식으로 배포해야 한다는 의미는 아닙니다.

라인을 제거해서 .assembly MyThing{} 다음과 같이 ilasm을 호출합니다.

ilasm.exe /DLL /OUTPUT=MyThing.netmodule

어셈블리 대신 넷모듈을 얻습니다.

불행하게도 VS2010(및 그 이전 버전)은 netmodule 참조 추가를 지원하지 않습니다. 즉, 디버깅할 때 2개의 별도 어셈블리에 남겨 두어야 합니다.어셈블리의 일부로 추가할 수 있는 유일한 방법은 다음을 사용하여 csc.exe를 직접 실행하는 것입니다. /addmodule:{files} 명령줄 인수.그렇지 않을 것이다 ~도 MSBuild 스크립트에서는 고통스럽습니다.물론, 당신이 용감하거나 멍청하다면 매번 수동으로 csc를 직접 실행할 수 있습니다.그리고 여러 어셈블리에서 액세스해야 하므로 확실히 더 복잡해집니다.

따라서 .Net에서 수행할 수 있습니다.추가 노력을 기울일 가치가 있나요?음, 그건 당신이 결정하도록 할게요.

대안으로 F# 솔루션

추가 크레딧:에 대한 일반적인 제한이 있는 것으로 나타났습니다. enum MSIL 외에 하나 이상의 다른 .NET 언어에서 가능합니다.에프#.

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

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를 유형 시스템으로 제한합니다. object, system.valuetype, system.enum 및 모든 인터페이스 유형으로 제한합니다.

편집하다

이제 질문에 대한 답변이 훌륭해졌습니다. 줄리앙 레보스퀘인.나는 또한 그의 대답을 다음과 같이 확장하고 싶습니다. 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 사용자의 명확성을 위해
  • 추가적인 제약 조건 확인을 위해 더 많은 인터페이스 제약 조건을 추가하세요.
  • 허락하다 TryParse 핸들 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;
    }
}

T 유형이 열거형인지 확인하고 그렇지 않은 경우 예외를 발생시키는 클래스에 대한 정적 생성자를 정의할 수 있습니다.이는 Jeffery Richter가 그의 책 CLR via 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)를 사용하여 문자열을 열거형으로 변환할 수 있습니다.마지막 true 매개변수는 입력의 대소문자를 무시하기 위한 것입니다.

또한 Enum 제약 조건을 사용하는 C# 7.3 릴리스는 추가 검사 등을 수행할 필요 없이 기본적으로 지원된다는 점도 고려해야 합니다.

따라서 앞으로 프로젝트의 언어 버전을 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에게 감사드립니다.

제 경우에는 이 EDIT를 작성하는 시점의 ReSharper 2018.1이 아직 C# 7.3을 지원하지 않는다는 점도 참고해주세요.ReSharper를 활성화하면 Enum 제약 조건이 오류로 강조 표시됩니다. 'System.Array', 'System.Delegate', 'System.Enum', 'System.ValueType', 'object'를 유형 매개 변수 제약 조건으로 사용할 수 없습니다..ReSharper는 다음 문제에 대한 빠른 수정 방법을 제안합니다. 메소드의 유형 매개변수 T의 'Enum' 제약 조건을 제거합니다.

그러나 ReSharper를 일시적으로 끄는 경우 도구 -> 옵션 -> ReSharper Ultimate -> 일반 VS 15.7 이상 및 C# 7.3 이상을 사용하면 구문이 완벽하게 괜찮다는 것을 알 수 있습니다.

dimarzionist로 샘플을 수정했습니다.이 버전은 Enum에서만 작동하며 구조체는 통과하지 못합니다. 

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

나는 코드를 조금 개선하려고 노력했습니다.

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

열거형 값과 연결된 텍스트와 함께 열거형을 사용해야 하는 특정 요구 사항이 있습니다.예를 들어 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());
}

이것이 도움이 되기를 바랍니다:

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

흥미롭게도 이것은 분명히 다른 언어에서는 가능 (관리형 C++, IL을 직접).

인용하려면:

...두 제약 조건 모두 실제로 유효한 IL을 생성하며 다른 언어로 작성된 경우 C#에서도 사용할 수 있습니다. 이러한 제약 조건은 관리되는 C++ 또는 IL에서 선언할 수 있습니다.

누가 알아

이것이 제가 생각하는 것입니다.답변과 MSDN을 결합하여

public static TEnum ParseToEnum<TEnum>(this string text) where TEnum : struct, IConvertible, IComparable, IFormattable
{
    if (string.IsNullOrEmpty(text) || !typeof(TEnum).IsEnum)
        throw new ArgumentException("TEnum must be an Enum type");

    try
    {
        var enumValue = (TEnum)Enum.Parse(typeof(TEnum), text.Trim(), true);
        return enumValue;
    }
    catch (Exception)
    {
        throw new ArgumentException(string.Format("{0} is not a member of the {1} enumeration.", text, typeof(TEnum).Name));
    }
}

MSDN 소스

기존 답변은 C# <=7.2부터 적용됩니다.그러나 C# 언어가 있습니다. 기능 요청 (에 묶여 코어FX 기능 요청) 다음을 허용합니다.

public class MyGeneric<TEnum> where TEnum : System.Enum
{ }

이 글을 쓰는 시점에는 언어 개발 회의에서 "토론 중"이라는 기능이 나와 있습니다.

편집하다

에 따라 나팔님의 정보입니다. 이는 C#에 도입되었습니다. 7.3.

나는 항상 이것을 좋아했습니다(적절하게 수정할 수 있음).

public static IEnumerable<TEnum> GetEnumValues()
{
  Type enumType = typeof(TEnum);

  if(!enumType.IsEnum)
    throw new ArgumentException("Type argument must be Enum type");

  Array enumValues = Enum.GetValues(enumType);
  return enumValues.Cast<TEnum>();
}

저는 IL을 사용하는 Christopher Currens의 솔루션을 좋아했지만 빌드 프로세스에 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;
}

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

확장 메서드를 만들었습니다. 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

이전에 다른 답변에서 언급했듯이;이는 소스 코드로 표현할 수 없지만 실제로 IL 수준에서 수행할 수 있습니다.@크리스토퍼 커렌스 답변 IL이 어떻게 하는지 보여줍니다.

와 함께 포디s 애드인 ExtraConstraints.Fody 이를 달성하기 위한 빌드 도구를 갖춘 매우 간단한 방법이 있습니다.너겟 패키지를 추가하기만 하면 됩니다(Fody, ExtraConstraints.Fody)를 프로젝트에 추가하고 다음과 같이 제약 조건을 추가합니다(ExtraConstraints Readme에서 발췌).

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> ()
{...}

Enum과 관련하여 매우 흥미로운 점에 주목하고 싶을 수도 있습니다. Enums.NET.

나중에 직접 캐스팅을 사용해도 괜찮다면 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);

완전성을 위해 다음은 Java 솔루션입니다.C#에서도 같은 작업을 수행할 수 있다고 확신합니다.코드 어디에서나 유형을 지정할 필요가 없습니다. 대신 구문 분석하려는 문자열에 유형을 지정하면 됩니다.

문제는 문자열이 어떤 열거형과 일치할지 알 수 있는 방법이 없다는 것입니다. 따라서 대답은 해당 문제를 해결하는 것입니다.

문자열 값만 허용하는 대신 "enumeration.value" 형식의 값과 열거형을 모두 포함하는 문자열을 허용합니다.작업 코드는 다음과 같습니다. Java 1.8 이상이 필요합니다.그러면 단순히 color="red" 대신 color="Color.red"와 같은 내용이 표시되므로 XML이 더 정확해집니다.

열거형 이름 점 값 이름이 포함된 문자열을 사용하여 acceptEnumeratedValue() 메서드를 호출합니다.

이 메서드는 형식적으로 열거된 값을 반환합니다.

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;


public class EnumFromString {

    enum NumberEnum {One, Two, Three};
    enum LetterEnum {A, B, C};


    Map<String, Function<String, ? extends Enum>> enumsByName = new HashMap<>();

    public static void main(String[] args) {
        EnumFromString efs = new EnumFromString();

        System.out.print("\nFirst string is NumberEnum.Two - enum is " + efs.acceptEnumeratedValue("NumberEnum.Two").name());
        System.out.print("\nSecond string is LetterEnum.B - enum is " + efs.acceptEnumeratedValue("LetterEnum.B").name());

    }

    public EnumFromString() {
        enumsByName.put("NumberEnum", s -> {return NumberEnum.valueOf(s);});
        enumsByName.put("LetterEnum", s -> {return LetterEnum.valueOf(s);});
    }

    public Enum acceptEnumeratedValue(String enumDotValue) {

        int pos = enumDotValue.indexOf(".");

        String enumName = enumDotValue.substring(0, pos);
        String value = enumDotValue.substring(pos + 1);

        Enum enumeratedValue = enumsByName.get(enumName).apply(value);

        return enumeratedValue;
    }


}
라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top