public static dynamic Parse(Type enumType, dynamic value) { if (!EnumHelper.IsEnum(enumType)) { throw new ArgumentException(EnumHelper.InvalidEnumTypeMessage); } if (string.IsNullOrWhiteSpace(value)) { throw new ArgumentNullException(EnumHelper.InvalidValueMessage); } if (Enum.IsDefined(enumType, value)) { return(value); } Type underlyingEnumType = Enum.GetUnderlyingType(enumType); Type valueType = value.GetType(); object eValue = Convert.ChangeType(value, underlyingEnumType); if (Enum.IsDefined(enumType, eValue)) { return(eValue); } throw new OverflowException(EnumHelper.ValueNotValidMessage); }
public static TEnum Parse <TEnum>(string value, StringComparison comparisonType, TEnum defaultValue) where TEnum : struct { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } if (string.IsNullOrWhiteSpace(value)) { return(defaultValue); } Type enumType = typeof(TEnum); foreach (var enumName in Enum.GetNames(enumType)) { if (enumName.Equals(value, comparisonType)) { return(EnumHelper.Parse <TEnum>(value)); } } return(defaultValue); }
public static TOut GetAttribute <TEnum, TOut>(Predicate <TOut> predicate, out TEnum value) where TEnum : struct where TOut : Attribute { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } var enumType = typeof(TEnum); foreach (var enumName in Enum.GetNames(enumType)) { var memInfo = enumType.GetMember(enumName).FirstOrDefault(); if (memInfo != null && memInfo.GetAttributes <TOut>(predicate).FirstOrDefault() != null) { value = EnumHelper.Parse <TEnum>(enumName); break; } } value = default(TEnum); return(null); }
public static IEnumerable <TOut> GetAttributes <TEnum, TOut>(Predicate <TOut> predicate) where TEnum : struct where TOut : Attribute { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } return(typeof(TEnum).GetAttributes <TOut>(predicate)); }
public static dynamic Parse(Type enumType, string value) { if (!EnumHelper.IsEnum(enumType)) { throw new ArgumentException(EnumHelper.InvalidEnumTypeMessage); } if (string.IsNullOrWhiteSpace(value)) { throw new ArgumentNullException(EnumHelper.InvalidValueMessage); } return(Enum.Parse(enumType, value)); }
public static TEnum ValueOf <TEnum>(object value) where TEnum : struct { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } if (value.IsNull()) { throw new ArgumentNullException("value"); } TEnum result; Type valueType = value.GetType(); Type enumType = Enum.GetUnderlyingType(typeof(TEnum)); try { if (valueType == typeof(string)) { if (EnumHelper.TryParseAny <TEnum>((string)value, out result)) { return(result); } } else { EnumRange range = EnumHelper.enumRanges[enumType]; if (range.Converter.CanConvertFrom(valueType)) { return((TEnum)range.Converter.ConvertFrom(value)); } } throw new ArgumentException(); } catch (InvalidCastException cex) { throw new ArgumentOutOfRangeException(string.Format("The value '{0}' is not a valid value of '{1}'.", value, typeof(TEnum).FullName), cex); } catch (InvalidOperationException oex) { throw new ArgumentOutOfRangeException(string.Format("The value '{0}' is not a valid value of '{1}'.", value, typeof(TEnum).FullName), oex); } catch (Exception ex) { throw new ArgumentOutOfRangeException(string.Format("The value '{0}' is not a valid value of '{1}'.", value, typeof(TEnum).FullName), ex); } }
public static TEnum Parse <TEnum>(string value) where TEnum : struct { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } if (string.IsNullOrWhiteSpace(value)) { throw new ArgumentNullException(EnumHelper.InvalidValueMessage); } return((TEnum)Enum.Parse(typeof(TEnum), value)); }
public static TEnum Parse <TEnum>(string value, StringComparison comparisonType) where TEnum : struct { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } if (!string.IsNullOrWhiteSpace(value)) { Type enumType = typeof(TEnum); foreach (var enumName in Enum.GetNames(enumType)) { if (enumName.Equals(value, comparisonType)) { return(EnumHelper.Parse <TEnum>(value)); } } } throw new OverflowException("value is outside the range of the underlying type of enumType."); }
public static dynamic Parse(Type enumType, string value, StringComparison comparisonType) { if (!EnumHelper.IsEnum(enumType)) { throw new ArgumentException(EnumHelper.InvalidEnumTypeMessage); } if (string.IsNullOrWhiteSpace(value)) { throw new ArgumentNullException(EnumHelper.InvalidValueMessage); } foreach (var enumName in Enum.GetNames(enumType)) { if (enumName.Equals(value, comparisonType)) { return(EnumHelper.Parse(enumType, value)); } } throw new OverflowException(EnumHelper.ValueNotValidMessage); }
public static TEnum Parse <TEnum>(string value, TEnum defaultValue) where TEnum : struct { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } if (string.IsNullOrWhiteSpace(value)) { return(defaultValue); } TEnum returnValue; if (!Enum.TryParse <TEnum>(value, out returnValue)) { returnValue = defaultValue; } return((TEnum)Enum.Parse(typeof(TEnum), value)); }
public static bool TryValueOf <TEnum>(object value, out TEnum result) where TEnum : struct { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } if (value.IsNull()) { throw new ArgumentNullException("value"); } result = default(TEnum); try { result = EnumHelper.ValueOf <TEnum>(value); return(true); } catch { return(false); } }
public static bool TryParse <TEnum>(string value, StringComparison comparisonType, out TEnum returnValue) where TEnum : struct { if (!EnumHelper.IsEnum <TEnum>()) { throw new ArgumentException(EnumHelper.InvalidTEnumMessage); } if (string.IsNullOrWhiteSpace(value)) { throw new ArgumentNullException("value"); } try { returnValue = EnumHelper.Parse <TEnum>(value, comparisonType); return(true); } catch { returnValue = default(TEnum); return(false); } }
/// <summary> /// Determines if the specified <typeparamref name="TEnum"/> is an Enum /// </summary> /// <typeparam name="TEnum">The <see cref="Type"/> to check.</typeparam> /// <returns><c>True</c> if the <typeparamref name="TEnum"/> is an enum; otherwise <c>False</c>.</returns> private static bool IsEnum <TEnum>() where TEnum : struct { return(EnumHelper.IsEnum(typeof(TEnum))); }