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