创建将T限制为枚举的通用方法

编辑

Julien Lebosquain现在已经很好地回答了这个问题.我也想延长他的答案ignoreCase,defaultValue和可选的参数,同时加入TryParse和ParseOrDefault.

public abstract class ConstrainedEnumParser 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 -constrained type EnumUtils
    public static TEnum Parse(string value, bool ignoreCase = false) where TEnum : struct, TClass
    {
        return (TEnum)Enum.Parse(typeof(TEnum), value, ignoreCase);
    }
    public static bool TryParse(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(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
// reference type constraint to any 
{
    // call to parse will then contain constraint to specific -class
}

用法示例:

WeekDay parsedDayOrArgumentException = EnumUtils.Parse("monday", ignoreCase:true);
WeekDay parsedDayOrDefault;
bool didParse = EnumUtils.TryParse("clubs", out parsedDayOrDefault, ignoreCase:true);
parsedDayOrDefault = EnumUtils.ParseOrDefault("friday", ignoreCase:true, defaultValue:WeekDay.Sunday);

旧

通过使用评论和"新"发展,我对Vivek答案的旧改进:

使用TEnum的清晰度,为用户

为附加的约束检查添加更多的接口约束

让我们TryParse处理ignoreCase现有参数(在VS2010/.Net 4中引入)

可选使用通用default值(在VS2005/.Net 2中引入)

使用带有默认值的可选参数(在VS2010/.Net 4中引入)for defaultValue和ignoreCase

导致:

public static class EnumUtils
{
    public static TEnum ParseEnum(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中通过C#提到的方法.

internal sealed class GenericTypeThatRequiresAnEnum {
    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(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建议快速修复删除方法类型参数T的'Enum'约束

但是,如果您在工具 - >选项 - > ReSharper Ultimate - >常规下暂时关闭ReSharper,您将看到语法完全正常,因为您使用VS 15.7或更高版本以及C#7.3或更高版本.

我通过dimarzionist修改了样本.此版本仅适用于Enums,不允许结构通过.

public static T ParseEnum(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(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(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();
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
    // Parsing without XmlEnum
    str = "Three";
    me = str.ParseXmlEnumAttribute();
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
    me = MyEnum.One;
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
}