T를 열거 형으로 제한하는 일반 메서드 만들기
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 #에서 컴파일러 적용 형식 안전 제네릭 솔루션을 게시 했습니다 . 솔루션이 페이지 위로 거품을 내면이 편집을 제거합니다.
EnumType은 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 # 솔루션
추가 크레딧 : enumMSIL : F # 외에 적어도 하나의 다른 .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 이하
제약 상속을 남용하여 실제 컴파일러가 enum 제약을 적용 할 수 있습니다. 다음 코드는 a class및 a 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 에 의해 훌륭하게 답변되었습니다 . 나는 또한 자신과 대답 확장하고자 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);
낡은
댓글과 '새로운'개발을 사용하여 Vivek의 답변 에 대한 나의 이전 개선 사항 :
- 사용하는
TEnum사용자에 대한 명확성을 위해 - 추가적인 제약 검사를 위해 더 많은 인터페이스 제약을 추가합니다.
- 기존 매개 변수로
TryParse처리 하자ignoreCase(VS2010 / .Net 4에 도입 됨) - 선택적으로 일반
default값 사용 (VS2005 / .Net 2에 도입 됨) - 사용 선택적 인수 에 대한 기본 값 (VS2010 / 닷넷 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가 열거 형인지 확인하고 그렇지 않은 경우 예외를 throw하는 클래스에 대한 정적 생성자를 정의 할 수 있습니다. 이것은 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");
}
}
}
그런 다음 parse 메서드에서 Enum.Parse (typeof (T), input, 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는 또한이 편집을 작성하는 현재 ReSharper 2018.1에서 C # 7.3을 아직 지원하지 않습니다. ReSharper를 활성화하면 'System.Array', 'System.Delegate', 'System.Enum', 'System.ValueType', 'object'를 type parameter constraint로 사용할 수 없다는 오류로 Enum 제약 조건이 강조 표시됩니다 . ReSharper는 메서드의 매개 변수 T 유형의 '열거 형'제약 조건 제거에 대한 빠른 수정을 제안합니다.
그러나 도구-> 옵션-> 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 값과 관련된 텍스트와 함께 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());
}
이것이 도움이되기를 바랍니다.
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));
}
}
기존 답변은 C # <= 7.2 현재 사실입니다. 그러나 다음을 허용 하는 C # 언어 기능 요청 ( corefx 기능 요청에 연결됨 )이 있습니다.
public class MyGeneric<TEnum> where TEnum : System.Enum
{ }
글을 쓰는 시점에서 기능은 언어 개발 회의에서 "토론 중"입니다.
편집하다
당으로 nawfal 의 정보를 원하시면,이는 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 : EnumEnum은 특수 유형이기 때문에 일반적인 제한을 사용할 수 없습니다 . 따라서 주어진 제네릭 유형이 실제로 열거 형인지 확인해야합니다.
내 기능은 다음과 같습니다.
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를 사용하면 빌드 도구를 사용하여이를 달성하는 매우 간단한 방법이 있습니다. 프로젝트에 너겟 패키지 ( Fody, ExtraConstraints.Fody)를 추가하고 다음과 같이 제약 조건을 추가하기 만하면됩니다 (Excerpt of 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 #에서도 똑같이 할 수 있다고 확신합니다. 코드의 어느 곳에서나 유형을 지정할 필요가 없습니다. 대신 구문 분석하려는 문자열에 지정합니다.
문제는 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;
}
}
참고 URL : https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
'development' 카테고리의 다른 글
| Docker 컨테이너 내부에서 머신의 로컬 호스트에 어떻게 연결합니까? (0) | 2020.09.27 |
|---|---|
| 활동이 원래 추가 된 창을 유출했습니다. (0) | 2020.09.27 |
| .gitignore for Visual Studio 프로젝트 및 솔루션 (0) | 2020.09.27 |
| HTML에서 "role"속성의 목적은 무엇입니까? (0) | 2020.09.27 |
| PHP와 열거 (0) | 2020.09.27 |