질문자 :johnc
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일) Christopher Currens는 아래의 MSIL 또는 F#에서 컴파일러 적용 유형 안전 일반 솔루션을 게시했습니다. 솔루션이 페이지 위로 더 많이 올라오면 이 편집을 제거하겠습니다.
편집 2: (2021년 4월 13일) 이것이 이제 해결되고 지원되었으므로 C# 7.3 이후로 허용되는 답변을 변경했습니다. 하지만 최상위 답변을 완전히 정독하는 것은 학문적, 역사적, 관심에 가치가 있습니다. :)
Enum Type은 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에서 지원됩니다!
다음 스니펫( 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 }
불행히도 이것은 코드의 이 부분을 C# 대신 MSIL로 작성해야 한다는 것을 의미합니다. 유일한 추가 이점은 System.Enum 이 메서드를 제한할 수 있다는 것입니다. 또한 별도의 어셈블리로 컴파일되기 때문에 일종의 골칫거리입니다. 그러나 그렇다고 해서 그런 식으로 배포해야 하는 것은 아닙니다.
.assembly MyThing{} 줄을 제거하고 다음과 같이 ilasm을 호출합니다.
ilasm.exe /DLL /OUTPUT=MyThing.netmodule
어셈블리 대신 netmodule을 얻습니다.
불행히도 VS2010(및 이전 버전)은 netmodule 참조 추가를 지원하지 않습니다. 즉, 디버깅할 때 2개의 개별 어셈블리에 남겨두어야 합니다. 어셈블리의 일부로 추가할 수 있는 유일한 방법은 /addmodule:{files} 명령줄 인수를 사용하여 csc.exe를 직접 실행하는 것입니다. MSBuild 스크립트에서 너무 고통스럽지 않습니다. 물론 용감하거나 어리석다면 매번 수동으로 csc를 실행할 수 있습니다. 그리고 여러 어셈블리가 액세스해야 하므로 확실히 더 복잡해집니다.
따라서 .Net에서 수행할 수 있습니다. 추가 노력을 기울일 가치가 있습니까? 음, 그건 당신이 결정하도록 할게요.
대안으로 F# 솔루션
추가 크레딧: MSIL: F# 외에 적어도 하나의 다른 .NET 언어에서 enum 에 대한 일반 제한이 가능하다는 것이 밝혀졌습니다.
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
제약 조건 상속을 남용하여 실제 컴파일러에서 enum 제약 조건을 적용하도록 할 수 있습니다. 다음 코드는 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 유형 및 모든 인터페이스 유형으로 제한합니다.
편집하다
이제 Julien Lebosquain 이 질문에 훌륭하게 답변했습니다. TryParse 및 ParseOrDefault ignoreCase , defaultValue 및 선택적 인수로 그의 대답을 확장하고 싶습니다.
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);
오래된
의견 및 '새로운' 개발을 사용하여 Vivek의 답변 에 대한 이전 개선 사항:
- 사용자를 위한 명확성을 위해
TEnum 사용 - 추가 제약 조건 검사를 위해 더 많은 인터페이스 제약 조건 추가
-
TryParse ignoreCase 를 처리하도록 합니다(VS2010/.Net 4에 도입됨). - 선택적으로 일반
default 사용(VS2005/.Net 2에 도입됨) -
defaultValue 및 ignoreCase 대해 기본값과 함께 선택적 인수 (VS2010/.Net 4에 도입됨)를 사용합니다.
를 야기하는:
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; } }
기존 답변은 C# <=7.2부터 true입니다. 그러나 다음을 허용하는 C# 언어 기능 요청 ( corefx 기능 요청과 연결됨)이 있습니다.
public class MyGeneric<TEnum> where TEnum : System.Enum { }
글을 쓰는 시점에서 기능은 언어 개발 회의에서 "토론 중"입니다.
편집하다
nawfal 의 정보에 따르면 이것은 C# 7.3 에 도입되었습니다.
편집 2
이것은 이제 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; }
T 유형이 열거형인지 확인하고 그렇지 않은 경우 예외를 throw하는 클래스에 대한 정적 생성자를 정의할 수 있습니다. 이것은 Jeffery Richter가 C#을 통한 CLR 책에서 언급한 방법입니다.
internal sealed class GenericTypeThatRequiresAnEnum<T> { static GenericTypeThatRequiresAnEnum() { if (!typeof(T).IsEnum) { throw new ArgumentException("T must be an enumerated type"); } } }
그런 다음 parse 메서드에서 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으로 변경하는 방법을 모르는 경우 다음 스크린샷을 참조하세요. 
편집 1 - 필수 Visual Studio 버전 및 ReSharper 고려
Visual Studio에서 새 구문을 인식하려면 버전 15.7 이상이 필요합니다. Microsoft의 릴리스 정보에서도 언급된 것을 찾을 수 있습니다. Visual Studio 2017 15.7 릴리스 정보 를 참조하십시오. 이 유효한 질문을 지적해 주신 @MohamedElshawaf에게 감사드립니다.
Pls는 또한 이 EDIT를 작성하는 시점에서 제 경우 ReSharper 2018.1이 C# 7.3을 아직 지원하지 않는다는 점에 주목합니다. ReSharper를 활성화하면 Enum 제약 조건이 'System.Array', 'System.Delegate', 'System.Enum', 'System.ValueType', 'object'를 유형 매개변수 제약 조건으로 사용할 수 없다는 오류로 강조 표시됩니다. ReSharper는 메서드의 매개변수 T 유형에 대한 'Enum' 제약 조건 제거에 대한 빠른 수정을 제안합니다.
그러나 도구 -> 옵션 -> ReSharper Ultimate -> 일반 에서 ReSharper를 일시적으로 끄면 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; } }
흥미롭게도 이것은 분명히 다른 언어 (Managed 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 소스
나는 항상 이것을 좋아했습니다 (당신은 적절하게 수정할 수 있습니다):
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#에서 유사한 기능을 작성했습니다.
Enum은 특수 유형이므로 where T : 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의 솔루션을 재사용할 수 있는 유틸리티 클래스로 캡슐화했습니다. 유형에 대해 "where 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 수준에서 수행할 수 있습니다. @Christopher Currens 답변 은 IL이 이를 어떻게 수행하는지 보여줍니다.
Fody 의 Add-In ExtraConstraints.Fody를 사용하면 빌드 도구로 완성된 매우 간단한 방법이 있어 이를 달성할 수 있습니다. 프로젝트에 nuget 패키지( 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> () {...}
Enums와 관련하여 매우 흥미로운 Enums.NET을 기록해 두는 것이 좋습니다 .
이것은 내 구현입니다. 기본적으로 모든 속성을 설정할 수 있으며 작동합니다.
public static class EnumExtensions { public static string GetDescription(this Enum @enum) { Type type = @enum.GetType(); FieldInfo fi = type.GetField(@enum.ToString()); DescriptionAttribute[] attrs = fi.GetCustomAttributes(typeof(DescriptionAttribute), false) as DescriptionAttribute[]; if (attrs.Length > 0) { return attrs[0].Description; } return null; } }
나중에 직접 캐스팅을 사용해도 괜찮다면 필요할 때마다 메서드에서 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#에서도 동일한 작업을 수행할 수 있다고 확신합니다. 코드의 어느 곳에서나 유형을 지정할 필요가 없습니다. 대신 구문 분석하려는 문자열에서 유형을 지정합니다.
문제는 String이 일치할 수 있는 열거형을 알 수 있는 방법이 없다는 것입니다. 따라서 답은 해당 문제를 해결하는 것입니다.
문자열 값만 수락하는 대신 "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; } }
출처 : http:www.stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum