在 C# 中将字符串转换为枚举

在 .NET Core 和 .NET Framework ≥4.0 there is a generic parse method 中：

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

这还包括 C#7 的新内联 out 变量，因此它执行尝试解析、转换为显式枚举类型并初始化+填充 myStatus 变量。

如果您可以访问 C#7 和最新的 .NET，这是最好的方法。

原始答案

在 .NET 中它相当丑陋（直到 4 或更高版本）：

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

我倾向于通过以下方式简化这一点：

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

然后我可以这样做：

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

评论中建议的一个选项是添加一个扩展，这很简单：

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

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

最后，如果无法解析字符串，您可能希望使用默认枚举：

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;
}

这使得这个电话：

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

但是，我会小心地将这样的扩展方法添加到 string，因为（没有命名空间控制）它会出现在 string 的所有实例上，无论它们是否持有枚举（所以 1234.ToString().ToEnum(StatusEnum.None) 将是有效但无意义的） .通常最好避免使用仅适用于非常特定上下文的额外方法使 Microsoft 的核心类混乱，除非您的整个开发团队非常了解这些扩展的作用。

---

使用 Enum.TryParse<T>(String, T) (≥ .NET 4.0)：

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

使用 C# 7.0 的 parameter type inlining 可以进一步简化它：

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

---

请注意，Enum.Parse() 的性能很糟糕，因为它是通过反射实现的。 （Enum.ToString 也是如此，反之亦然。）

如果您需要在对性能敏感的代码中将字符串转换为枚举，最好的办法是在启动时创建一个 Dictionary<String,YourEnum> 并使用它来进行转换。

---

您正在寻找 Enum.Parse。

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

---

您现在可以使用 extension methods：

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

您可以通过以下代码调用它们（这里，FilterType 是枚举类型）：

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

---

谨防：

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

Enum.(Try)Parse() 接受多个以逗号分隔的参数，并将它们与二进制“或”组合在一起|。你不能禁用它，在我看来你几乎从不想要它。

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

即使未定义 Three，x 仍将获得 int 值 3。更糟糕的是：Enum.Parse() 可以给你一个甚至没有为枚举定义的值！

我不想体验用户自愿或非自愿触发这种行为的后果。

此外，正如其他人所提到的，对于大型枚举，性能并不理想，即可能值的数量是线性的。

我建议如下：

    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);
    }

---

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

因此，如果您有一个名为 mood 的枚举，它将如下所示：

   enum Mood
   {
      Angry,
      Happy,
      Sad
   } 

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

---

Enum.Parse 是您的朋友：

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

---

您可以使用默认值扩展接受的答案以避免异常：

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;
    }
}

然后你这样称呼它：

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

如果默认值不是枚举，则 Enum.TryParse 将失败并抛出被捕获的异常。

经过多年在我们的代码中在许多地方使用此功能之后，添加此操作会降低性能的信息可能会很好！

---

在某个时候，添加了 Parse 的通用版本。对我来说，这更可取，因为我不需要“尝试”解析，而且我还希望结果内联而不生成输出变量。

ColorEnum color = Enum.Parse<ColorEnum>("blue");

MS Documentation: Parse

---

我们无法假设完全有效的输入，并采用了@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);
}

---

不确定这是什么时候添加的，但是在 Enum 类上现在有一个

Parse<TEnum>(stringValue)

像这样使用有问题的例子：

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

或通过以下方式忽略大小写：

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

这是它使用的反编译方法：

    [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;
    }

---

将字符串解析为 TEnum，无需 try/catch 且无需来自 .NET 4.5 的 TryParse() 方法

/// <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;
}

---

这里的大多数答案都要求您每次调用扩展方法时始终传入枚举的默认值。如果你不想采用这种方法，你可以像下面这样实现它：

 public static TEnum ToEnum<TEnum>(this string value) where TEnum : struct
 {
     if (string.IsNullOrWhiteSpace(value))
          return default(TEnum);

     return Enum.TryParse(value, true, out TEnum result) ? result : default(TEnum);

 }

使用默认文字（可从 C# 7.1 获得）

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

       return Enum.TryParse(value, true, out TEnum result) ? result : default;

 }

更好的是：

public static TEnum ToEnum<TEnum>(this string value) where TEnum : struct
{
      if (string.IsNullOrWhiteSpace(value))
           return default;

      return Enum.TryParse(value, true, out TEnum result) ? result : default;

}

---

我喜欢扩展方法解决方案..

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;
        }
    }
}

下面是我的测试实现。

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
        }

---

使用 TryParse 的超级简单代码：

var value = "Active";

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

---

对于性能，这可能会有所帮助：

    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];
    }

---

如果属性名称与您要调用的名称不同（即语言差异），您可以这样做：

我的类型.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,
}

枚举扩展.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);
    }
}

程序.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
    }     
}

---

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

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

====================一个完整的程序====================

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.

---

我使用了类（具有解析和性能改进的 Enum 的强类型版本）。我在 GitHub 上找到了它，它也应该适用于 .NET 3.5。它有一些内存开销，因为它缓冲字典。

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

博文是 Enums – Better syntax, improved performance and TryParse in NET 3.5。

和代码：https://github.com/damieng/DamienGKit/blob/master/CSharp/DamienG.Library/System/EnumT.cs

---

我发现这里没有考虑枚举值具有 EnumMember 值的情况。所以我们开始：

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;
}

该枚举的示例：

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

---

您必须使用 Enum.Parse 从 Enum 获取对象值，之后您必须将对象值更改为特定的枚举值。可以使用 Convert.ChangeType 转换为枚举值。请查看以下代码片段

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

---

试试这个示例：

 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;
        });
    }

在此示例中，您可以发送每个字符串，并设置您的 Enum。如果您的 Enum 有您想要的数据，请将其作为您的 Enum 类型返回。

---

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

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

---

        <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

---

如果您想在 null 或空时使用默认值（例如，当从配置文件中检索并且该值不存在时）并在字符串或数字与任何枚举值不匹配时抛出异常。不过，请注意 Timo 的回答中的警告（https://stackoverflow.com/a/34267134/2454604）。

    public static T ParseEnum<T>(this string s, T defaultValue, bool ignoreCase = false) 
        where T : struct, IComparable, IConvertible, IFormattable//If C# >=7.3: struct, System.Enum 
    {
        if ((s?.Length ?? 0) == 0)
        {
            return defaultValue;
        }

        var valid = Enum.TryParse<T>(s, ignoreCase, out T res);

        if (!valid || !Enum.IsDefined(typeof(T), res))
        {
            throw new InvalidOperationException(
                $"'{s}' is not a valid value of enum '{typeof(T).FullName}'!");
        }
        return res;
    }

---

我开始使用这种方法。性能似乎还可以，但它需要一些样板代码设置。

public enum StatusType {
    Success,
    Pending,
    Rejected
}

static class StatusTypeMethods {

    public static StatusType GetEnum(string type) {
        switch (type) {
            case nameof(StatusType.Success): return StatusType.Success;
            case nameof(StatusType.Pending): return StatusType.Pending;
            case nameof(StatusType.Rejected): return StatusType.Rejected;
            default:
                throw new ArgumentOutOfRangeException(nameof(type), type, null);
        };
    }
}

稍后，您可以像这样使用它：

StatusType = StatusType.GetEnum("Success");

---

首先，你需要装饰你的枚举，像这样：

    public enum Store : short
{
    [Description("Rio Big Store")]
    Rio = 1
}

在 .net 5 中，我创建了这个扩展方法：

//The class also needs to be static, ok?
public static string GetDescription(this System.Enum enumValue)
    {
        FieldInfo fi = enumValue.GetType().GetField(enumValue.ToString());

        DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(
            typeof(DescriptionAttribute), false);

        if (attributes != null && attributes.Length > 0) return attributes[0].Description;
        else return enumValue.ToString();
    }

现在您可以在任何枚举中使用扩展方法

像这样：

var Desc = Store.Rio.GetDescription(); //Store is your Enum

---