Создать общий метод, ограничивающий перечисление Enum
Я строю функцию для расширения 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,
Справедливо, но есть ли обходной путь, чтобы разрешить общий 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#, которое стоит посмотреть, и приветствие. Я удалю эту правку, если раствор будет пузыриться дальше на странице.
22 ответа
Поскольку 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!
Следующий фрагмент (из примеров 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);
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 и любым типом интерфейса.
Существующие ответы верны на C# <=7.2. Однако существует запрос функции языка C# (связанный с запросом функции corefx), чтобы разрешить следующее;
public class MyGeneric<TEnum> where TEnum : 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 является перечислением, и выдаст исключение, если это не так. Этот метод упоминается Джеффри Рихтером в его книге 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) для преобразования строки в перечисление. Последний истинный параметр предназначен для игнорирования регистра ввода.
Также следует учитывать, что, поскольку выпуск 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, смотрите следующий снимок экрана: 
РЕДАКТИРОВАТЬ 1 - Требуемая версия Visual Studio и учитывая ReSharper
Чтобы Visual Studio мог распознать новый синтаксис, вам нужна как минимум версия 15.7. Вы также можете найти это в примечаниях к выпуску Microsoft, см. Замечания к выпуску Visual Studio 2017 15.7. Спасибо @MohamedElshawaf за указание на этот действительный вопрос.
Просьба также обратить внимание, что в моем случае 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 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;
}
Я модифицировал образец от dimarzionist. Эта версия будет работать только с 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);
}
}
Обратите внимание, что
System.Enum
Parse() &
TryParse() методы все еще есть
where struct ограничения, а не, так что это не будет компилироваться:
bool IsValid<TE>(string attempted) where TE : Enum
{
return Enum.TryParse(attempted, out TE _);
}
но это будет:
bool Ok<TE>(string attempted) where TE : struct,Enum
{
return Enum.TryParse(attempted, out var _)
}
как результат,
where struct,Enum может быть предпочтительнее просто
where Enum
У меня есть конкретное требование, когда мне нужно использовать 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));
}
}
Я создал метод расширения 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
Мне всегда нравилось это (вы можете изменить соответствующим образом):
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>();
}
Я инкапсулировал решение 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);
}
}
}
Мне понравилось решение Christopher Currens, использующее IL, но для тех, кто не хочет заниматься сложными задачами по включению MSIL в процесс сборки, я написал аналогичную функцию на C#.
Обратите внимание, что вы не можете использовать общие ограничения, такие как where T : Enum потому что 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 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;
}
}
Как указано в других ответах ранее; хотя это не может быть выражено в исходном коде, на самом деле это может быть сделано на уровне IL. Ответ @Christopher Currens показывает, как IL делает с этим.
С помощью Add-In ExtraConstraints.Fody от Fody есть очень простой способ, в комплекте с инструментами для сборки, добиться этого. Просто добавьте свои пакеты nuget (Fody, ExtraConstraints.Fody) к вашему проекту и добавьте ограничения следующим образом (выдержка из Readme of ExtraConstraints):
public void MethodWithEnumConstraint<[EnumConstraint] T>() {...}
public void MethodWithTypeEnumConstraint<[EnumConstraint(typeof(ConsoleColor))] T>() {...}
и Фоди добавит необходимый IL для присутствия ограничения. Также обратите внимание на дополнительную функцию ограничения делегатов:
public void MethodWithDelegateConstraint<[DelegateConstraint] T> ()
{...}
public void MethodWithTypeDelegateConstraint<[DelegateConstraint(typeof(Func<int>))] T> ()
{...}
Что касается Enums, вы также можете обратить внимание на очень интересный 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 вы бы использовали...
SomeClass<T extends enum> {
}
Довольно просто.