题
在 C# 中将字符串转换为枚举值的最佳方法是什么?
我有一个包含枚举值的 HTML 选择标签。当页面发布时,我想获取该值(将以字符串的形式)并将其转换为枚举值。
在理想的世界中,我可以做这样的事情:
StatusEnum MyStatus = StatusEnum.Parse("Active");
但这不是有效的代码。
解决方案
在 .NET Core 和 .NET 中 >4 有一个通用的解析方法:
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
as(没有名称空间控制)它将出现在 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 可以进一步简化 参数类型内联:
Enum.TryParse("Active", out StatusEnum myStatus);
请注意,Enum.Parse() 的性能很糟糕,因为它是通过反射实现的。(Enum.ToString 也是如此,但方向相反。)
如果您需要在性能敏感的代码中将字符串转换为枚举,最好的选择是创建一个 Dictionary<String,YourEnum>
在启动时并使用它来进行转换。
您正在寻找 枚举解析.
SomeEnum enum = (SomeEnum)Enum.Parse(typeof(SomeEnum), "EnumValue");
您可以使用 扩展方法 现在:
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>();
object Enum.Parse(System.Type enumType, string value, bool ignoreCase);
因此,如果您有一个名为心情的枚举,它将如下所示:
enum Mood
{
Angry,
Happy,
Sad
}
// ...
Mood m = (Mood) Enum.Parse(typeof(Mood), "Happy", true);
Console.WriteLine("My mood is: {0}", m.ToString());
谨防:
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);
}
枚举解析 是你的朋友:
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);
我们无法假设完全有效的输入,因此采用了 @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);
}
将字符串解析为 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;
}
使用 TryParse 的超级简单代码:
var value = "Active";
StatusEnum status;
if (!Enum.TryParse<StatusEnum>(value, out status))
status = StatusEnum.Unknown;
我喜欢扩展方法解决方案..
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
}
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 – NET 3.5 中更好的语法、改进的性能和 TryParse.
和代码:https://github.com/damieng/DamienGKit/blob/master/CSharp/DamienG.Library/System/EnumT.cs
对于性能来说,这可能会有所帮助:
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];
}
我发现这里没有考虑具有 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
类型。
<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);}