[英]How to TryParse for Enum value?
我想編寫一個函數,它可以驗證給定值(作為字符串傳遞)與enum
可能值。 在匹配的情況下,它應該返回枚舉實例; 否則,它應該返回一個默認值。
該函數可能不在內部使用try
/ catch
,它排除了使用Enum.Parse
,它在給定無效參數時拋出異常。
我想使用TryParse
函數的一些東西來實現這個:
public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
{
object enumValue;
if (!TryParse (typeof (TEnum), strEnumValue, out enumValue))
{
return defaultValue;
}
return (TEnum) enumValue;
}
Enum.IsDefined將完成任務。 它可能不如TryParse那樣有效,但它可以在沒有異常處理的情況下工作。
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);
}
值得注意的是:.NET 4.0中添加了TryParse
方法。
正如其他人所說,你必須實現自己的TryParse
。 Simon Mourier正在提供一個完整的實現,它可以處理所有事情。
如果您正在使用位域枚舉(即標志),您還必須處理像"MyEnum.Val1|MyEnum.Val2"
這樣的字符串,它是兩個枚舉值的組合。 如果你只是用這個字符串調用Enum.IsDefined
,它將返回false,即使Enum.Parse
正確處理它。
更新
正如Lisa和Christian在評論中所提到的, Enum.TryParse
現在可用於.NET4及更高版本的C#。
MSDN文檔
這是EnumTryParse
的自定義實現。 與其他常見實現不同,它還支持使用Flags
屬性標記的枚舉。
/// <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;
}
最后,你必須圍繞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;
}
補充說明:
Enum.TryParse
包含在.NET 4中。請參見http://msdn.microsoft.com/library/dd991876(VS.100).aspx Enum.Parse
捕獲失敗時拋出的異常。 找到匹配項時可能會更快,但如果沒有,則可能會更慢。 根據您正在處理的數據,這可能是也可能不是凈改進。 編輯:剛剛看到一個更好的實現,它緩存了必要的信息: http : //damieng.com/blog/2010/10/17/enums-better-syntax-improved-performance-and-tryparse-in-net- 3-5
基於.NET 4.5
示例代碼如下
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);
}
}
}
我有一個可以在UnconstrainedMelody中使用的優化實現。 實際上,它只是緩存了名稱列表,但它是以一種漂亮的,強類型的,通用約束的方式實現的:)
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)) {
}
目前沒有開箱即用的Enum.TryParse。 這已經在Connect( 仍然沒有Enum.TryParse )上被請求,並得到一個響應,表明可能包含在.NET 3.5之后的下一個框架中。 您現在必須實施建議的解決方法。
避免異常處理的唯一方法是使用GetNames()方法,我們都知道異常不應該被濫用於常見的應用程序邏輯:)
緩存動態生成的函數/字典是否允許?
因為您沒有(似乎)提前知道枚舉的類型,所以第一次執行可以生成后續執行可以利用的內容。
你甚至可以緩存Enum.GetNames()的結果
您是否嘗試優化CPU或內存? 你真的需要嗎?
正如其他人已經說過的,如果你不使用Try&Catch,你需要使用IsDefined或GetNames ...這里有一些樣本......它們基本上都是一樣的,第一個處理可以為空的枚舉。 我更喜歡第二個,因為它是字符串的擴展,而不是枚舉...但你可以根據需要混合它們!
沒有TryParse,因為Enum的類型直到運行時才知道。 TryParse遵循與Date.TryParse方法相同的方法,會在ByRef參數上引發隱式轉換錯誤。
我建議做這樣的事情:
//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);
}
}
看看Enum類(struct?)本身。 有一個Parse方法,但我不確定tryparse。
此方法將轉換一種枚舉:
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());
}
它檢查基礎類型並獲取其名稱以進行解析。 如果一切都失敗了,它將返回默認值。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.