Chuyển đổi một chuỗi thành một enum trong C #

Cách tốt nhất để chuyển đổi một chuỗi thành giá trị liệt kê trong C # là gì?

Tôi có thẻ chọn HTML chứa các giá trị liệt kê. Khi trang được đăng, tôi muốn chọn giá trị (sẽ ở dạng chuỗi) và chuyển đổi nó thành giá trị liệt kê.

Trong một thế giới lý tưởng, tôi có thể làm một cái gì đó như thế này:

StatusEnum MyStatus = StatusEnum.Parse("Active");

nhưng đó không phải là một mã hợp lệ.

Trong .NET Core và .NET> 4 có một phương thức phân tích chung :

Enum.TryParse("Active", out StatusEnum myStatus);

Điều này cũng bao gồm outcác biến nội tuyến mới của C # 7 , do đó, điều này thực hiện phân tích thử, chuyển đổi sang loại enum rõ ràng và khởi tạo + điền vàomyStatus biến.

Nếu bạn có quyền truy cập vào C # 7 và .NET mới nhất thì đây là cách tốt nhất.

Câu trả lời gốc

Trong .NET, nó khá xấu (cho đến 4 hoặc cao hơn):

StatusEnum MyStatus = (StatusEnum) Enum.Parse(typeof(StatusEnum), "Active", true);

Tôi có xu hướng đơn giản hóa điều này với:

public static T ParseEnum<T>(string value)
{
    return (T) Enum.Parse(typeof(T), value, true);
}

Sau đó tôi có thể làm:

StatusEnum MyStatus = EnumUtil.ParseEnum<StatusEnum>("Active");

Một tùy chọn được đề xuất trong các nhận xét là thêm tiện ích mở rộng, đủ đơn giản:

public static T ToEnum<T>(this string value)
{
    return (T) Enum.Parse(typeof(T), value, true);
}

StatusEnum MyStatus = "Active".ToEnum<StatusEnum>();

Cuối cùng, bạn có thể muốn có một enum mặc định để sử dụng nếu chuỗi không thể được phân tích cú pháp:

public static T ToEnum<T>(this string value, T defaultValue) 
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    T result;
    return Enum.TryParse<T>(value, true, out result) ? result : defaultValue;
}

Điều này làm cho cuộc gọi này:

StatusEnum MyStatus = "Active".ToEnum(StatusEnum.None);

Tuy nhiên, tôi sẽ cẩn thận thêm một phương thức mở rộng như thế này vào string(không có kiểm soát không gian tên) nó sẽ xuất hiện trên tất cả các trường hợp stringcho dù chúng có giữ enum hay không (vì vậy 1234.ToString().ToEnum(StatusEnum.None)sẽ hợp lệ nhưng vô nghĩa). Tốt nhất là tránh làm lộn xộn các lớp lõi của Microsoft bằng các phương thức bổ sung chỉ áp dụng trong các ngữ cảnh rất cụ thể trừ khi toàn bộ nhóm phát triển của bạn hiểu rất rõ về những tiện ích mở rộng đó làm gì.

Sử dụng Enum.TryParse<T>(String, T)(≥ .NET 4.0):

StatusEnum myStatus;
Enum.TryParse("Active", out myStatus);

Nó có thể được đơn giản hóa hơn nữa với kiểu tham số của C # 7.0 :

Enum.TryParse("Active", out StatusEnum myStatus);

Lưu ý rằng hiệu suất của Enum.Parse()là khủng khiếp, bởi vì nó được thực hiện thông qua sự phản ánh. (Điều tương tự cũng đúng Enum.ToString, đi theo cách khác.)

Nếu bạn cần chuyển đổi chuỗi thành Enums trong mã nhạy cảm với hiệu suất, cách tốt nhất của bạn là tạo một chuỗi Dictionary<String,YourEnum>khi khởi động và sử dụng chuỗi đó để thực hiện chuyển đổi.

Bạn đang tìm kiếm Enum.Pude .

SomeEnum enum = (SomeEnum)Enum.Parse(typeof(SomeEnum), "EnumValue");

Bạn có thể sử dụng các phương thức mở rộng ngay bây giờ:

public static T ToEnum<T>(this string value, bool ignoreCase = true)
{
    return (T) Enum.Parse(typeof (T), value, ignoreCase);
}

Và bạn có thể gọi chúng theo mã dưới đây (ở đây, FilterTypelà một loại enum):

FilterType filterType = type.ToEnum<FilterType>();

object Enum.Parse(System.Type enumType, string value, bool ignoreCase);

Vì vậy, nếu bạn có một tâm trạng tên enum, nó sẽ trông như thế này:

   enum Mood
   {
      Angry,
      Happy,
      Sad
   } 

   // ...
   Mood m = (Mood) Enum.Parse(typeof(Mood), "Happy", true);
   Console.WriteLine("My mood is: {0}", m.ToString());

THƯỞNG

enum Example
{
    One = 1,
    Two = 2,
    Three = 3
}

Enum.(Try)Parse() chấp nhận nhiều đối số, được phân tách bằng dấu phẩy và kết hợp chúng với nhị phân 'hoặc'| . Bạn không thể vô hiệu hóa điều này và theo tôi bạn gần như không bao giờ muốn nó.

var x = Enum.Parse("One,Two"); // x is now Three

Ngay cả khi Threekhông được xác định, xvẫn sẽ nhận được giá trị int 3. Điều đó thậm chí còn tệ hơn: Enum.Pude () có thể cung cấp cho bạn một giá trị thậm chí không được xác định cho enum!

Tôi sẽ không muốn trải nghiệm hậu quả của người dùng, sẵn sàng hay không sẵn lòng, kích hoạt hành vi này.

Ngoài ra, như được đề cập bởi những người khác, hiệu suất thấp hơn lý tưởng cho các enum lớn, cụ thể là tuyến tính về số lượng giá trị có thể.

Tôi đề nghị như sau:

    public static bool TryParse<T>(string value, out T result)
        where T : struct
    {
        var cacheKey = "Enum_" + typeof(T).FullName;

        // [Use MemoryCache to retrieve or create&store a dictionary for this enum, permanently or temporarily.
        // [Implementation off-topic.]
        var enumDictionary = CacheHelper.GetCacheItem(cacheKey, CreateEnumDictionary<T>, EnumCacheExpiration);

        return enumDictionary.TryGetValue(value.Trim(), out result);
    }

    private static Dictionary<string, T> CreateEnumDictionary<T>()
    {
        return Enum.GetValues(typeof(T))
            .Cast<T>()
            .ToDictionary(value => value.ToString(), value => value, StringComparer.OrdinalIgnoreCase);
    }

Enum.Pude là bạn của bạn:

StatusEnum MyStatus = (StatusEnum)Enum.Parse(typeof(StatusEnum), "Active");

Bạn có thể mở rộng câu trả lời được chấp nhận với giá trị mặc định để tránh trường hợp ngoại lệ:

public static T ParseEnum<T>(string value, T defaultValue) where T : struct
{
    try
    {
        T enumValue;
        if (!Enum.TryParse(value, true, out enumValue))
        {
            return defaultValue;
        }
        return enumValue;
    }
    catch (Exception)
    {
        return defaultValue;
    }
}

Sau đó, bạn gọi nó như:

StatusEnum MyStatus = EnumUtil.ParseEnum("Active", StatusEnum.None);

Nếu giá trị mặc định không phải là enum, Enum.TryPude sẽ thất bại và đưa ra một ngoại lệ được bắt.

Sau nhiều năm sử dụng chức năng này trong mã của chúng tôi ở nhiều nơi, có lẽ thật tốt khi thêm thông tin mà thao tác này có chi phí hiệu suất!

Chúng tôi không thể cho rằng đầu vào hoàn toàn hợp lệ và đi kèm với biến thể câu trả lời của @ Keith:

public static TEnum ParseEnum<TEnum>(string value) where TEnum : struct
{
    TEnum tmp; 
    if (!Enum.TryParse<TEnum>(value, true, out tmp))
    {
        tmp = new TEnum();
    }
    return tmp;
}

// str.ToEnum<EnumType>()
T static ToEnum<T>(this string str) 
{ 
    return (T) Enum.Parse(typeof(T), str);
}

Phân tích chuỗi thành TEnum mà không cần phương thức try / Catch và không có phương thức TryPude () từ .NET 4.5

/// <summary>
/// Parses string to TEnum without try/catch and .NET 4.5 TryParse()
/// </summary>
public static bool TryParseToEnum<TEnum>(string probablyEnumAsString_, out TEnum enumValue_) where TEnum : struct
{
    enumValue_ = (TEnum)Enum.GetValues(typeof(TEnum)).GetValue(0);
    if(!Enum.IsDefined(typeof(TEnum), probablyEnumAsString_))
        return false;

    enumValue_ = (TEnum) Enum.Parse(typeof(TEnum), probablyEnumAsString_);
    return true;
}

Mã siêu đơn giản sử dụng TryPude:

var value = "Active";

StatusEnum status;
if (!Enum.TryParse<StatusEnum>(value, out status))
    status = StatusEnum.Unknown;

Tôi thích giải pháp phương pháp mở rộng ..

namespace System
{
    public static class StringExtensions
    {

        public static bool TryParseAsEnum<T>(this string value, out T output) where T : struct
        {
            T result;

            var isEnum = Enum.TryParse(value, out result);

            output = isEnum ? result : default(T);

            return isEnum;
        }
    }
}

Dưới đây thực hiện của tôi với các bài kiểm tra.

using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
using static System.Console;

private enum Countries
    {
        NorthAmerica,
        Europe,
        Rusia,
        Brasil,
        China,
        Asia,
        Australia
    }

   [TestMethod]
        public void StringExtensions_On_TryParseAsEnum()
        {
            var countryName = "Rusia";

            Countries country;
            var isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsTrue(isCountry);
            AreEqual(Countries.Rusia, country);

            countryName = "Don't exist";

            isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsFalse(isCountry);
            AreEqual(Countries.NorthAmerica, country); // the 1rst one in the enumeration
        }

public static T ParseEnum<T>(string value)            //function declaration  
{
    return (T) Enum.Parse(typeof(T), value);
}

Importance imp = EnumUtil.ParseEnum<Importance>("Active");   //function call

==================== Một chương trình hoàn chỉnh ====================

using System;

class Program
{
    enum PetType
    {
    None,
    Cat = 1,
    Dog = 2
    }

    static void Main()
    {

    // Possible user input:
    string value = "Dog";

    // Try to convert the string to an enum:
    PetType pet = (PetType)Enum.Parse(typeof(PetType), value);

    // See if the conversion succeeded:
    if (pet == PetType.Dog)
    {
        Console.WriteLine("Equals dog.");
    }
    }
}
-------------
Output

Equals dog.

Tôi đã sử dụng lớp (phiên bản gõ mạnh của Enum với phân tích cú pháp và cải tiến hiệu suất). Tôi đã tìm thấy nó trên GitHub và nó cũng hoạt động với .NET 3.5. Nó có một số bộ nhớ trên vì nó đệm một từ điển.

StatusEnum MyStatus = Enum<StatusEnum>.Parse("Active");

Blogpost là Enums - Cú pháp tốt hơn, hiệu suất được cải thiện và TryPude trong NET 3.5 .

Và mã: https://github.com/damieng/DamienGKit/blob/master/CSharp/DamienG.L Library / System /Eumum.cs

Đối với hiệu suất, điều này có thể giúp:

    private static Dictionary<Type, Dictionary<string, object>> dicEnum = new Dictionary<Type, Dictionary<string, object>>();
    public static T ToEnum<T>(this string value, T defaultValue)
    {
        var t = typeof(T);
        Dictionary<string, object> dic;
        if (!dicEnum.ContainsKey(t))
        {
            dic = new Dictionary<string, object>();
            dicEnum.Add(t, dic);
            foreach (var en in Enum.GetValues(t))
                dic.Add(en.ToString(), en);
        }
        else
            dic = dicEnum[t];
        if (!dic.ContainsKey(value))
            return defaultValue;
        else
            return (T)dic[value];
    }

Tôi thấy rằng ở đây trường hợp với các giá trị enum có giá trị EnumMember không được xem xét. Vì vậy, ở đây chúng tôi đi:

using System.Runtime.Serialization;

public static TEnum ToEnum<TEnum>(this string value, TEnum defaultValue) where TEnum : struct
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    TEnum result;
    var enumType = typeof(TEnum);
    foreach (var enumName in Enum.GetNames(enumType))
    {
        var fieldInfo = enumType.GetField(enumName);
        var enumMemberAttribute = ((EnumMemberAttribute[]) fieldInfo.GetCustomAttributes(typeof(EnumMemberAttribute), true)).FirstOrDefault();
        if (enumMemberAttribute?.Value == value)
        {
            return Enum.TryParse(enumName, true, out result) ? result : defaultValue;
        }
    }

    return Enum.TryParse(value, true, out result) ? result : defaultValue;
}

Và ví dụ về enum đó:

public enum OracleInstanceStatus
{
    Unknown = -1,
    Started = 1,
    Mounted = 2,
    Open = 3,
    [EnumMember(Value = "OPEN MIGRATE")]
    OpenMigrate = 4
}

Bạn phải sử dụng Enum.Pude để lấy giá trị đối tượng từ Enum, sau đó bạn phải thay đổi giá trị đối tượng thành giá trị enum cụ thể. Việc truyền tới giá trị enum có thể được thực hiện bằng cách sử dụng Convert.ChangeType. Xin hãy xem đoạn mã sau

public T ConvertStringValueToEnum<T>(string valueToParse){
    return Convert.ChangeType(Enum.Parse(typeof(T), valueToParse, true), typeof(T));
}

Hãy thử mẫu này:

 public static T GetEnum<T>(string model)
    {
        var newModel = GetStringForEnum(model);

        if (!Enum.IsDefined(typeof(T), newModel))
        {
            return (T)Enum.Parse(typeof(T), "None", true);
        }

        return (T)Enum.Parse(typeof(T), newModel.Result, true);
    }

    private static Task<string> GetStringForEnum(string model)
    {
        return Task.Run(() =>
        {
            Regex rgx = new Regex("[^a-zA-Z0-9 -]");
            var nonAlphanumericData = rgx.Matches(model);
            if (nonAlphanumericData.Count < 1)
            {
                return model;
            }
            foreach (var item in nonAlphanumericData)
            {
                model = model.Replace((string)item, "");
            }
            return model;
        });
    }

Trong mẫu này, bạn có thể gửi mọi chuỗi và đặt Enum. Nếu bạn Enumcó dữ liệu mà bạn muốn, hãy trả lại dữ liệu đó theo Enumkiểu của bạn .

Không chắc chắn khi điều này được thêm vào nhưng trên lớp Enum bây giờ có một

Parse<TEnum>(stringValue)

Được sử dụng như vậy với ví dụ trong câu hỏi:

var MyStatus = Enum.Parse<StatusEnum >("Active")

hoặc bỏ qua vỏ bằng cách:

var MyStatus = Enum.Parse<StatusEnum >("active", true)

Đây là phương pháp dịch ngược mà nó sử dụng:

    [NullableContext(0)]
    public static TEnum Parse<TEnum>([Nullable(1)] string value) where TEnum : struct
    {
      return Enum.Parse<TEnum>(value, false);
    }

    [NullableContext(0)]
    public static TEnum Parse<TEnum>([Nullable(1)] string value, bool ignoreCase) where TEnum : struct
    {
      TEnum result;
      Enum.TryParse<TEnum>(value, ignoreCase, true, out result);
      return result;
    }

        <Extension()>
    Public Function ToEnum(Of TEnum)(ByVal value As String, ByVal defaultValue As TEnum) As TEnum
        If String.IsNullOrEmpty(value) Then
            Return defaultValue
        End If

        Return [Enum].Parse(GetType(TEnum), value, True)
    End Function

public TEnum ToEnum<TEnum>(this string value, TEnum defaultValue){
if (string.IsNullOrEmpty(value))
    return defaultValue;

return Enum.Parse(typeof(TEnum), value, true);}

Nếu tên thuộc tính khác với tên bạn muốn gọi (nghĩa là khác biệt ngôn ngữ), bạn có thể làm như thế này:

MyType.cs

using System;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

[JsonConverter(typeof(StringEnumConverter))]
public enum MyType
{
    [EnumMember(Value = "person")]
    Person,
    [EnumMember(Value = "annan_deltagare")]
    OtherPerson,
    [EnumMember(Value = "regel")]
    Rule,
}

EnumExtensions.cs

using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

public static class EnumExtensions
{
    public static TEnum ToEnum<TEnum>(this string value) where TEnum : Enum
    {
        var jsonString = $"'{value.ToLower()}'";
        return JsonConvert.DeserializeObject<TEnum>(jsonString, new StringEnumConverter());
    }

    public static bool EqualsTo<TEnum>(this string strA, TEnum enumB) where TEnum : Enum
    {
        TEnum enumA;
        try
        {
            enumA = strA.ToEnum<TEnum>();
        }
        catch
        {
            return false;
        }
        return enumA.Equals(enumB);
    }
}

Chương trình.cs

public class Program
{
    static public void Main(String[] args) 
    { 
        var myString = "annan_deltagare";
        var myType = myString.ToEnum<MyType>();
        var isEqual = myString.EqualsTo(MyType.OtherPerson);
        //Output: true
    }     
}