在 C# 中将字符串转换为枚举值的最佳方法是什么？
我有一个包含枚举值的 HTML 选择标记。当页面发布时，我想将值（将以字符串的形式）取出并将其转换为相应的枚举值。
在理想的世界中，我可以这样做：
StatusEnum MyStatus = StatusEnum.Parse("Active");
但这不是有效的代码。
Ben Mills
问问题
946850 次
28 回答
1833
在 .NET Core 和 .NET Framework ≥4.0中有一个通用的解析方法：
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);
但是，我会小心地将这样的扩展方法添加到stringas（没有命名空间控制），它将出现在string它们是否持有枚举的所有实例上（因此1234.ToString().ToEnum(StatusEnum.None)有效但无意义）。通常最好避免使用仅适用于非常特定上下文的额外方法使 Microsoft 的核心类混乱，除非您的整个开发团队非常了解这些扩展的作用。
于 2008-08-19T12:54:28.533 回答
372
使用Enum.TryParse<T>(String, T)（≥ .NET 4.0）：
StatusEnum myStatus;
Enum.TryParse("Active", out myStatus);
使用 C# 7.0 的参数类型内联可以进一步简化它：
Enum.TryParse("Active", out StatusEnum myStatus);
于 2013-12-05T08:22:38.090 回答
225
请注意， 的性能Enum.Parse()很糟糕，因为它是通过反射实现的。（同样如此Enum.ToString，反之亦然。）
如果您需要在性能敏感的代码中将字符串转换为枚举，最好的办法是Dictionary<String,YourEnum>在启动时创建一个并使用它来进行转换。
于 2008-09-02T02:27:07.447 回答
113
您正在寻找Enum.Parse。
SomeEnum enum = (SomeEnum)Enum.Parse(typeof(SomeEnum), "EnumValue");
于 2008-08-19T12:53:52.747 回答
35
您现在可以使用扩展方法：
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>();
于 2014-02-10T10:12:09.947 回答
28
谨防：
enum Example
{
One = 1,
Two = 2,
Three = 3
}
Enum.(Try)Parse() 接受多个逗号分隔的参数，并将它们与二进制 'or' 组合|。你不能禁用它，在我看来你几乎从不想要它。
var x = Enum.Parse("One,Two"); // x is now Three
即使Three没有定义，x仍然会得到 int value 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);
}
于 2015-12-14T12:31:47.580 回答
22
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());于 2008-08-19T12:58:57.730 回答
16
Enum.Parse是你的朋友：
StatusEnum MyStatus = (StatusEnum)Enum.Parse(typeof(StatusEnum), "Active");
于 2008-08-19T12:55:31.743 回答
13
您可以使用默认值扩展接受的答案以避免异常：
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 将失败并抛出被捕获的异常。
经过多年在我们的代码中在许多地方使用此功能之后，添加此操作会降低性能的信息可能会很好！
于 2014-12-09T11:43:43.907 回答
11
我们无法假设完全有效的输入，并采用了@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;
}
于 2012-08-30T15:07:10.443 回答
7
// str.ToEnum<EnumType>()
T static ToEnum<T>(this string str)
{
return (T) Enum.Parse(typeof(T), str);
}
于 2008-08-19T13:13:38.277 回答
7
不确定这是什么时候添加的，但是在 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;
}
于 2019-11-27T18:34:51.117 回答
7
在某个时候，添加了 Parse 的通用版本。对我来说，这更可取，因为我不需要“尝试”解析，而且我还希望结果内联而不生成输出变量。
ColorEnum color = Enum.Parse<ColorEnum>("blue");
于 2021-10-19T20:07:42.340 回答
6
将字符串解析为 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;
}
于 2013-10-17T16:04:17.680 回答
4
我喜欢扩展方法解决方案..
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
}
于 2015-10-01T21:57:29.500 回答
4
使用 TryParse 的超级简单代码：
var value = "Active";
StatusEnum status;
if (!Enum.TryParse<StatusEnum>(value, out status))
status = StatusEnum.Unknown;
于 2016-11-25T02:30:35.440 回答
3
对于性能，这可能会有所帮助：
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];
}
于 2016-06-22T14:10:58.113 回答
3
如果属性名称与您要调用的名称不同（即语言差异），您可以这样做：
我的类型.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
}
}
于 2020-01-24T13:28:38.260 回答
2
我使用了类（具有解析和性能改进的 Enum 的强类型版本）。我在 GitHub 上找到了它，它也应该适用于 .NET 3.5。它有一些内存开销，因为它缓冲字典。
StatusEnum MyStatus = Enum<StatusEnum>.Parse("Active");
这篇博文是Enums – NET 3.5 中更好的语法、改进的性能和 TryParse。
和代码： https ://github.com/damieng/DamienGKit/blob/master/CSharp/DamienG.Library/System/EnumT.cs
于 2015-07-01T09:39:48.757 回答
2
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.
于 2015-08-18T05:28:07.893 回答
2
我发现这里没有考虑枚举值具有 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
}
于 2016-10-04T16:40:31.027 回答
2
您必须使用 Enum.Parse 从 Enum 获取对象值，之后您必须将对象值更改为特定的枚举值。可以使用 Convert.ChangeType 转换为枚举值。请查看以下代码片段
public T ConvertStringValueToEnum<T>(string valueToParse){
return Convert.ChangeType(Enum.Parse(typeof(T), valueToParse, true), typeof(T));
}
于 2017-02-08T11:33:42.457 回答
2
试试这个示例：
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类型返回。
于 2018-10-01T09:37:17.607 回答
2
public TEnum ToEnum<TEnum>(this string value, TEnum defaultValue){
if (string.IsNullOrEmpty(value))
return defaultValue;
return Enum.Parse(typeof(TEnum), value, true);}
于 2019-05-22T07:19:51.063 回答
1
<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
于 2019-05-22T07:15:54.777 回答
1
如果您想在 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;
}
于 2020-06-12T13:51:27.053 回答
0
这里的大多数答案都要求您每次调用扩展方法时始终传入枚举的默认值。如果你不想采用这种方法，你可以像下面这样实现它：
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;
}
于 2022-02-24T08:31:16.407 回答
-1
首先，你需要装饰你的枚举，像这样：
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
于 2021-04-06T23:33:25.047 回答