logo标签列表

.NET 3.5 中枚举类型的 TryParse 实现

c#.net
7

我该如何在.NET 3.5中实现.NET 4的Enum.TryParse方法？

public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct
4个回答
15

我不喜欢使用 try-catch 来处理应用程序正常流程中的任何转换失败或其他非异常事件，所以我自己为 .NET 3.5 及更早版本编写的 Enum.TryParse 方法利用了 Enum.IsDefined() 方法来确保在调用 Enum.Parse() 时不会抛出异常。你还可以对 value 进行一些空值检查，以防止出现 ArgumentNullException。

public static bool TryParse<TEnum>(string value, out TEnum result)
    where TEnum : struct, IConvertible
{
    var retValue = value == null ? 
                false : 
                Enum.IsDefined(typeof(TEnum), value);
    result = retValue ?
                (TEnum)Enum.Parse(typeof(TEnum), value) :
                default(TEnum);
    return retValue;
}

显然，这种方法不会驻留在Enum类中，因此您需要一个适当的类来包含它。
一个限制是泛型方法没有enum约束，因此您必须考虑如何处理不正确的类型。如果TEnum不是enum，则Enum.IsDefined将抛出ArgumentException，但唯一的其他选项是运行时检查并抛出不同的异常，因此通常我不添加额外的检查，只让这些方法中的类型检查为我处理。我会考虑添加IConvertible作为另一个约束，以帮助进一步约束类型。
我肯定喜欢这个比我的方法（现已删除）更好。 - Anthony Pegram
+1 同意，如果我再花一分钟查看枚举方法并看到 IsDefined 方法，这很可能就会发生。 :) - Peter Karlsson
1
感谢您的回答。虽然这是一个不错的开始，但还有很多其他考虑因素才能与.NET 4的实现相媲美（例如，值作为逗号分隔标志，值作为数字，枚举数值类型）。 - Herman Schoenfeld
似乎无法处理[Flags]枚举组合。 - Zverev Evgeniy
@ZverevEvgeniy，我写这个已经很久了，我不记得是否尝试过使用[Flags]。 - psubsee2003
7

虽然花费的时间比我预期的要长，但是它可以使用并已经过测试。希望这能为某些人省下时间！

    private static readonly char[] FlagDelimiter = new [] { ',' };

    public static bool TryParseEnum<TEnum>(string value, out TEnum result) where TEnum : struct {
        if (string.IsNullOrEmpty(value)) {
            result = default(TEnum);
            return false;
        }

        var enumType = typeof(TEnum);

        if (!enumType.IsEnum)
            throw new ArgumentException(string.Format("Type '{0}' is not an enum", enumType.FullName));


        result = default(TEnum);

        // Try to parse the value directly 
        if (Enum.IsDefined(enumType, value)) {
            result = (TEnum)Enum.Parse(enumType, value);
            return true;
        }

        // Get some info on enum
        var enumValues = Enum.GetValues(enumType);
        if (enumValues.Length == 0)
            return false;  // probably can't happen as you cant define empty enum?
        var enumTypeCode = Type.GetTypeCode(enumValues.GetValue(0).GetType());

        // Try to parse it as a flag 
        if (value.IndexOf(',') != -1) {
            if (!Attribute.IsDefined(enumType, typeof(FlagsAttribute)))
                return false;  // value has flags but enum is not flags

            // todo: cache this for efficiency
            var enumInfo = new Dictionary<string, object>();
            var enumNames = Enum.GetNames(enumType);
            for (var i = 0; i < enumNames.Length; i++)
                enumInfo.Add(enumNames[i], enumValues.GetValue(i));

            ulong retVal = 0;
            foreach(var name in value.Split(FlagDelimiter)) {
                var trimmedName = name.Trim();
                if (!enumInfo.ContainsKey(trimmedName))
                    return false;   // Enum has no such flag

                var enumValueObject = enumInfo[trimmedName];
                ulong enumValueLong;
                switch (enumTypeCode) {
                    case TypeCode.Byte:
                        enumValueLong = (byte)enumValueObject;
                        break;
                    case TypeCode.SByte:
                        enumValueLong = (byte)((sbyte)enumValueObject);
                        break;
                    case TypeCode.Int16:
                        enumValueLong = (ushort)((short)enumValueObject);
                        break;
                    case TypeCode.Int32:
                        enumValueLong = (uint)((int)enumValueObject);
                        break;
                    case TypeCode.Int64:
                        enumValueLong = (ulong)((long)enumValueObject);
                        break;
                    case TypeCode.UInt16:
                        enumValueLong = (ushort)enumValueObject;
                        break;
                    case TypeCode.UInt32:
                        enumValueLong = (uint)enumValueObject;
                        break;
                    case TypeCode.UInt64:
                        enumValueLong = (ulong)enumValueObject;
                        break;
                    default:
                        return false;   // should never happen
                }
                retVal |= enumValueLong;
            }
            result = (TEnum)Enum.ToObject(enumType, retVal);
            return true;
        }

        // the value may be a number, so parse it directly
        switch (enumTypeCode) {
            case TypeCode.SByte:
                sbyte sb;
                if (!SByte.TryParse(value, out sb))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, sb);
                break;
            case TypeCode.Byte:
                byte b;
                if (!Byte.TryParse(value, out b))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, b);
                break;
            case TypeCode.Int16:
                short i16;
                if (!Int16.TryParse(value, out i16))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, i16);
                break;
            case TypeCode.UInt16:
                ushort u16;
                if (!UInt16.TryParse(value, out u16))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, u16);
                break;
            case TypeCode.Int32:
                int i32;
                if (!Int32.TryParse(value, out i32))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, i32);
                break;
            case TypeCode.UInt32:
                uint u32;
                if (!UInt32.TryParse(value, out u32))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, u32);
                break;
            case TypeCode.Int64:
                long i64;
                if (!Int64.TryParse(value, out i64))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, i64);
                break;
            case TypeCode.UInt64:
                ulong u64;
                if (!UInt64.TryParse(value, out u64))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, u64);
                break;
            default:
                return false; // should never happen
        }

        return true;
    }
你可以将那些开关语句改为反射，而不是列出所有可能的类型并缩短代码。 - Nick Turner
1
@NickTurner：对于这种方法，性能非常重要，反射不利于性能。 - Herman Schoenfeld
1
注意：在 .NET 4+ 中，Enum.Tryparse 不会抛出这些异常。https://msdn.microsoft.com/zh-cn/library/dd991317(v=vs.110).aspx - Julian
@Julian：已删除第一个异常，保留第二个异常，因为文档表明它会被抛出。感谢您的更新。 - Herman Schoenfeld
3

在NLog，我们也需要使用.Net 3.5的Enum.TryParse。受到这篇文章的影响，我们实现了基本功能（只是解析、区分大小写和不区分大小写，没有标志）。

这个基本实现经过了高度的单元测试，因此它具有与Microsoft的.Net 4实现相同的行为。

/// <summary>
/// Enum.TryParse implementation for .net 3.5 
/// 
/// </summary>
/// <returns></returns>
/// <remarks>Don't uses reflection</remarks>
// ReSharper disable once UnusedMember.Local
private static bool TryParseEnum_net3<TEnum>(string value, bool ignoreCase, out TEnum result) where TEnum : struct
{
    var enumType = typeof(TEnum);
    if (!enumType.IsEnum())
        throw new ArgumentException($"Type '{enumType.FullName}' is not an enum");

    if (StringHelpers.IsNullOrWhiteSpace(value))
    {
        result = default(TEnum);
        return false;
    }

    try
    {
        result = (TEnum)Enum.Parse(enumType, value, ignoreCase);
        return true;
    }
    catch (Exception)
    {
        result = default(TEnum);
        return false;
    }
}

并使用：

public static class StringHelpers
{
    /// <summary>
    /// IsNullOrWhiteSpace, including for .NET 3.5
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [ContractAnnotation("value:null => true")]
    internal static bool IsNullOrWhiteSpace(string value)
    {
#if NET3_5

        if (value == null) return true;
        if (value.Length == 0) return true;
        return String.IsNullOrEmpty(value.Trim());
#else
        return string.IsNullOrWhiteSpace(value);
#endif
    }
}

代码可以在NLog GitHub中找到，同时单元测试在GitHub上（xUnit）。
3
它不会成为Enum上的静态方法（静态扩展方法并不太合理），但它应该可以工作。
public static class EnumHelpers
{
    public static bool TryParse<TEnum>(string value, out TEnum result)
        where TEnum : struct
    {
        try
        {
            result = (TEnum)Enum.Parse(typeof(TEnum), value); 
        }
        catch
        {
            result = default;
            return false;
        }

        return true;
    }
}
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接