Làm thế nào để TryParse cho giá trị Enum?

Tôi muốn viết một hàm có thể xác thực một giá trị nhất định (được truyền dưới dạng chuỗi) so với các giá trị có thể có của một enum. Trong trường hợp khớp, nó sẽ trả về thể hiện enum; nếu không, nó sẽ trả về một giá trị mặc định.

Hàm không được sử dụng nội bộ try/ catch, loại trừ việc sử dụng Enum.Parse, sẽ ném ra một ngoại lệ khi đưa ra một đối số không hợp lệ.

Tôi muốn sử dụng một cái gì đó dọc theo dòng của một TryParsehàm để triển khai điều này:

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
{
   object enumValue;
   if (!TryParse (typeof (TEnum), strEnumValue, out enumValue))
   {
       return defaultValue;
   }
   return (TEnum) enumValue;
}

Như những người khác đã nói, bạn phải thực hiện của riêng bạn TryParse. Simon Mourier đang cung cấp một bản triển khai đầy đủ để đảm bảo mọi thứ.

Nếu bạn đang sử dụng enum bitfield (tức là cờ), bạn cũng phải xử lý một chuỗi giống như một chuỗi "MyEnum.Val1|MyEnum.Val2"kết hợp của hai giá trị enum. Nếu bạn chỉ gọi Enum.IsDefinedbằng chuỗi này, nó sẽ trả về false, mặc dù Enum.Parsexử lý nó một cách chính xác.

Cập nhật

Như đã được đề cập bởi Lisa và Christian trong các nhận xét, Enum.TryParsehiện đã có sẵn cho C # trong .NET4 trở lên.

Tài liệu MSDN

Enum.IsDefined sẽ hoàn thành công việc. Nó có thể không hiệu quả như TryParse, nhưng nó sẽ hoạt động mà không cần xử lý ngoại lệ.

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
{
    if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
        return defaultValue;

    return (TEnum)Enum.Parse(typeof(TEnum), strEnumValue);
}

Đáng chú ý: một TryParsephương pháp đã được thêm vào .NET 4.0.

Đây là một triển khai tùy chỉnh của EnumTryParse. Không giống như các triển khai thông thường khác, nó cũng hỗ trợ enum được đánh dấu bằng Flagsthuộc tính.

    /// <summary>
    /// Converts the string representation of an enum to its Enum equivalent value. A return value indicates whether the operation succeeded.
    /// This method does not rely on Enum.Parse and therefore will never raise any first or second chance exception.
    /// </summary>
    /// <param name="type">The enum target type. May not be null.</param>
    /// <param name="input">The input text. May be null.</param>
    /// <param name="value">When this method returns, contains Enum equivalent value to the enum contained in input, if the conversion succeeded.</param>
    /// <returns>
    /// true if s was converted successfully; otherwise, false.
    /// </returns>
    public static bool EnumTryParse(Type type, string input, out object value)
    {
        if (type == null)
            throw new ArgumentNullException("type");

        if (!type.IsEnum)
            throw new ArgumentException(null, "type");

        if (input == null)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        input = input.Trim();
        if (input.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        string[] names = Enum.GetNames(type);
        if (names.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        Type underlyingType = Enum.GetUnderlyingType(type);
        Array values = Enum.GetValues(type);
        // some enums like System.CodeDom.MemberAttributes *are* flags but are not declared with Flags...
        if ((!type.IsDefined(typeof(FlagsAttribute), true)) && (input.IndexOfAny(_enumSeperators) < 0))
            return EnumToObject(type, underlyingType, names, values, input, out value);

        // multi value enum
        string[] tokens = input.Split(_enumSeperators, StringSplitOptions.RemoveEmptyEntries);
        if (tokens.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        ulong ul = 0;
        foreach (string tok in tokens)
        {
            string token = tok.Trim(); // NOTE: we don't consider empty tokens as errors
            if (token.Length == 0)
                continue;

            object tokenValue;
            if (!EnumToObject(type, underlyingType, names, values, token, out tokenValue))
            {
                value = Activator.CreateInstance(type);
                return false;
            }

            ulong tokenUl;
            switch (Convert.GetTypeCode(tokenValue))
            {
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.SByte:
                    tokenUl = (ulong)Convert.ToInt64(tokenValue, CultureInfo.InvariantCulture);
                    break;

                //case TypeCode.Byte:
                //case TypeCode.UInt16:
                //case TypeCode.UInt32:
                //case TypeCode.UInt64:
                default:
                    tokenUl = Convert.ToUInt64(tokenValue, CultureInfo.InvariantCulture);
                    break;
            }

            ul |= tokenUl;
        }
        value = Enum.ToObject(type, ul);
        return true;
    }

    private static char[] _enumSeperators = new char[] { ',', ';', '+', '|', ' ' };

    private static object EnumToObject(Type underlyingType, string input)
    {
        if (underlyingType == typeof(int))
        {
            int s;
            if (int.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(uint))
        {
            uint s;
            if (uint.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(ulong))
        {
            ulong s;
            if (ulong.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(long))
        {
            long s;
            if (long.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(short))
        {
            short s;
            if (short.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(ushort))
        {
            ushort s;
            if (ushort.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(byte))
        {
            byte s;
            if (byte.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(sbyte))
        {
            sbyte s;
            if (sbyte.TryParse(input, out s))
                return s;
        }

        return null;
    }

    private static bool EnumToObject(Type type, Type underlyingType, string[] names, Array values, string input, out object value)
    {
        for (int i = 0; i < names.Length; i++)
        {
            if (string.Compare(names[i], input, StringComparison.OrdinalIgnoreCase) == 0)
            {
                value = values.GetValue(i);
                return true;
            }
        }

        if ((char.IsDigit(input[0]) || (input[0] == '-')) || (input[0] == '+'))
        {
            object obj = EnumToObject(underlyingType, input);
            if (obj == null)
            {
                value = Activator.CreateInstance(type);
                return false;
            }
            value = obj;
            return true;
        }

        value = Activator.CreateInstance(type);
        return false;
    }

Cuối cùng, bạn phải thực hiện điều này xung quanh Enum.GetNames:

public bool TryParseEnum<T>(string str, bool caseSensitive, out T value) where T : struct {
    // Can't make this a type constraint...
    if (!typeof(T).IsEnum) {
        throw new ArgumentException("Type parameter must be an enum");
    }
    var names = Enum.GetNames(typeof(T));
    value = (Enum.GetValues(typeof(T)) as T[])[0];  // For want of a better default
    foreach (var name in names) {
        if (String.Equals(name, str, caseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase)) {
            value = (T)Enum.Parse(typeof(T), name);
            return true;
        }
    }
    return false;
}

Ghi chú bổ sung:

• Enum.TryParseđược bao gồm trong .NET 4. Xem tại đây http://msdn.microsoft.com/library/dd991876(VS.100).aspx
• Một cách tiếp cận khác là bọc trực tiếp Enum.Parsebắt ngoại lệ được ném ra khi nó không thành công. Điều này có thể nhanh hơn khi tìm thấy kết quả phù hợp, nhưng sẽ có thể chậm hơn nếu không. Tùy thuộc vào dữ liệu bạn đang xử lý, điều này có thể là một cải tiến thực tế hoặc không.

CHỈNH SỬA: Vừa thấy một triển khai tốt hơn về điều này, lưu trữ thông tin cần thiết: http://damieng.com/blog/2010/10/17/enums-better-syntax-improved-performance-and-tryparse-in-net- 3-5

Dựa trên .NET 4.5

Mã mẫu bên dưới

using System;

enum Importance
{
    None,
    Low,
    Medium,
    Critical
}

class Program
{
    static void Main()
    {
    // The input value.
    string value = "Medium";

    // An unitialized variable.
    Importance importance;

    // Call Enum.TryParse method.
    if (Enum.TryParse(value, out importance))
    {
        // We now have an enum type.
        Console.WriteLine(importance == Importance.Medium);
    }
    }
}

Tham khảo: http://www.dotnetperls.com/enum-parse

Tôi có một triển khai được tối ưu hóa mà bạn có thể sử dụng trong UnconstrainedMelody . Về mặt hiệu quả, nó chỉ là bộ nhớ đệm danh sách tên, nhưng nó đang làm như vậy theo một cách tốt đẹp, được đánh máy mạnh mẽ, hạn chế chung chung :)

enum EnumStatus
{
    NAO_INFORMADO = 0,
    ENCONTRADO = 1,
    BLOQUEADA_PELO_ENTREGADOR = 2,
    DISPOSITIVO_DESABILITADO = 3,
    ERRO_INTERNO = 4,
    AGARDANDO = 5
}

...

if (Enum.TryParse<EnumStatus>(item.status, out status)) {

}

Hiện tại không có Enum.TryParse. Điều này đã được yêu cầu trên Connect ( Vẫn không có Enum.TryParse ) và nhận được phản hồi cho biết có thể được đưa vào khuôn khổ tiếp theo sau .NET 3.5. Bạn sẽ phải thực hiện các giải pháp thay thế được đề xuất ngay bây giờ.

Cách duy nhất để tránh xử lý ngoại lệ là sử dụng phương thức GetNames () và tất cả chúng ta đều biết rằng không nên lạm dụng ngoại lệ đối với logic ứng dụng thông thường :)

Bộ nhớ đệm là một hàm / từ điển được tạo động có được phép không?

Bởi vì bạn không (dường như) biết trước loại enum, lần thực thi đầu tiên có thể tạo ra thứ gì đó mà các lần thực thi tiếp theo có thể tận dụng.

Bạn thậm chí có thể lưu trữ kết quả của Enum.GetNames ()

Bạn đang cố gắng tối ưu hóa cho CPU hoặc Bộ nhớ? Bạn có thực sự cần?

Như những người khác đã nói, nếu bạn không sử dụng Try & Catch, bạn cần sử dụng IsDefined hoặc GetNames ... Dưới đây là một số mẫu ... về cơ bản chúng đều giống nhau, mẫu đầu tiên xử lý các enums nullable. Tôi thích cái thứ 2 hơn vì nó là một phần mở rộng trên chuỗi, không phải enums ... nhưng bạn có thể kết hợp chúng theo ý muốn!

• www.objectreference.net/post/Enum-TryParse-Extension-Method.aspx
• flatlinerdoa.spaces.live.com/blog/cns!17124D03A9A052B0!605.entry
• mironabramson.com/blog/post/2008/03/Aosystem-version-for-the-missing-method-EnumTryParse.aspx
• lazyloading.blogspot.com/2008/04/enumtryparse-with-net-35-extension.html

Không có TryParse vì loại Enum không được biết cho đến thời gian chạy. Một TryParse tuân theo phương pháp tương tự như phương thức Date.TryParse sẽ tạo ra một lỗi chuyển đổi ngầm định trên tham số ByRef.

Tôi đề nghị làm điều gì đó như thế này:

//1 line call to get value
MyEnums enumValue = (Sections)EnumValue(typeof(Sections), myEnumTextValue, MyEnums.SomeEnumDefault);

//Put this somewhere where you can reuse
public static object EnumValue(System.Type enumType, string value, object NotDefinedReplacement)
{
    if (Enum.IsDefined(enumType, value)) {
        return Enum.Parse(enumType, value);
    } else {
        return Enum.Parse(enumType, NotDefinedReplacement);
    }
}

Hãy xem chính lớp Enum (struct?). Có một phương pháp Phân tích cú pháp nhưng tôi không chắc về phương pháp phân tích cú pháp.

Phương thức này sẽ chuyển đổi một loại enum:

  public static TEnum ToEnum<TEnum>(object EnumValue, TEnum defaultValue)
    {
        if (!Enum.IsDefined(typeof(TEnum), EnumValue))
        {
            Type enumType = Enum.GetUnderlyingType(typeof(TEnum));
            if ( EnumValue.GetType() == enumType )
            {
                string name = Enum.GetName(typeof(HLink.ViewModels.ClaimHeaderViewModel.ClaimStatus), EnumValue);
                if( name != null)
                    return (TEnum)Enum.Parse(typeof(TEnum), name);
                return defaultValue;
            }
        }
        return (TEnum)Enum.Parse(typeof(TEnum), EnumValue.ToString());
    } 

Nó kiểm tra loại cơ bản và lấy tên dựa trên nó để phân tích cú pháp. Nếu mọi thứ không thành công, nó sẽ trả về giá trị mặc định.