private static bool IsValidEnumValueInternal(EnumMetadata enumMetaData, object enumValue)
{
var numericEnumValue = ToUInt64(enumValue);
if (enumMetaData.IsFlagsEnum)
{
if (numericEnumValue == 0L)
{
return(enumMetaData.ContainsNumericValue(numericEnumValue));
}
var missingBits = ulong.MaxValue;
foreach (var definedValue in enumMetaData.NumericValues)
{
if ((definedValue & numericEnumValue) == definedValue)
{
missingBits &= ~definedValue;
}
}
return((numericEnumValue & missingBits) == 0);
}
else
{
return(enumMetaData.ContainsNumericValue(numericEnumValue));
}
}
public MainForm()
{
InitializeComponent();
_metadata = new EnumMetadata <AgeDependsAnswer>
{
Answers = new List <AgeDependsAnswer>
{
new AgeDependsAnswer
{
AnswerType = AnswerType.Text,
Description = "Answer 1 description",
DisplayValue = "Answer 1",
MaxAge = 10,
MinAge = 0
},
new AgeDependsAnswer
{
AnswerType = AnswerType.Text,
Description = "Answer 2 description",
DisplayValue = "Answer 2",
MaxAge = 2,
MinAge = 0
}
}
};
}
public static SelectList ToSelectListAsTringFiltered <T>(this EnumMetadata <T> enumMetadata, T[] filterValues, params T[] seletedIndexes)
{
return(enumMetadata.Items.
Where(item => !filterValues.Contains(item.Key)).
ToDictionary(item => item.Key.ToString(), item => item.Value).
ToSelectList(seletedIndexes.Select(item => item.ToString()).ToArray()));
}
/// <summary>
/// Internal metadata read process.
/// </summary>
/// <param name="pToFill"></param>
/// <param name="pElement"></param>
protected override void InternalRead(ref IMetadata pToFill, XElement pElement)
{
string lValue = pElement.Value;
if (string.IsNullOrEmpty(lValue))
{
return;
}
EnumMetadata lToFill = pToFill as EnumMetadata;
int lLastValue = 0;
List <Enum> lEnumList = new List <Enum>();
string[] lValues = lValue.Trim().Split(';');
foreach (string lEnumValue in lValues)
{
Enum lNewEnumValue = new Enum();
lNewEnumValue.Name = lEnumValue.Trim();
if (string.IsNullOrEmpty(lNewEnumValue.Name))
{
continue;
}
lNewEnumValue.Value = lLastValue++;
lEnumList.Add(lNewEnumValue);
}
lToFill.Enumeration = lEnumList;
}
private static EnumMetadata GetEnumMetadata(Type enumType)
{
object value = Enum.GetValues(enumType).GetValue(0);
MethodInfo typeCodeMethod = enumType.GetMethod("GetTypeCode");
var typeCode = (TypeCode)typeCodeMethod.Invoke(value, new object[0]);
var enumMetadata = new EnumMetadata(
enumType.Name,
enumType.Namespace,
GetLongTypeName(enumType),
GetProtectionLevel(enumType),
typeCode
);
s_typeCache[enumType] = enumMetadata;
enumMetadata.DeclaringType = (DefinedTypeMetadata)FromType(enumType.DeclaringType);
enumMetadata.Members = GetEnumMemberMetadata(enumType, enumMetadata);
enumMetadata.Fields = GetFieldMetadata(enumType);
(enumMetadata.Indexers, enumMetadata.Properties) = GetPropertyMetadata(enumType);
enumMetadata.Methods = GetMethodMetadata(enumType);
enumMetadata.CustomAttributes = GetCustomAttributes(enumType.GetCustomAttributesData());
return(enumMetadata);
}
public static Func <string, string?> BuildNameToDescriptionMapper(IStringLocalizer settingEnumStringLocalizer)
{
return(name =>
{
var metadata = EnumMetadata.For <SettingEnum>(name);
return metadata != null?GetDescriptionTranslation(metadata, settingEnumStringLocalizer)?.Value : null;
});
}
public static MvcHtmlString EnumListFor <TModel, TValue>(this HtmlHelper <TModel> htmlHelper,
Expression <Func <TModel, TValue> > expression, object htmlAttributes = null)
{
string inputName = ExpressionHelper.GetExpressionText(expression);
EnumMetadata <TValue> enumMetaData = EnumMetadataFactory.Get <TValue>();
ModelMetadata modelMetadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
PropertyInfo propertyInfo = modelMetadata.ContainerType.GetProperty(modelMetadata.PropertyName);
var enumFilterAttribute =
Attribute.GetCustomAttribute(propertyInfo, typeof(EnumFilterAttribute)) as EnumFilterAttribute;
SelectList selectList = (enumFilterAttribute != null)
? enumMetaData.ToSelectListAsTringFiltered(
enumMetaData.Items.Keys.Where(enumFilterAttribute.IsFiltered).ToArray())
: enumMetaData.ToSelectListAsString();
return(htmlHelper.DropDownListFor(expression, selectList, htmlAttributes));
}
public static bool IsConvertable(object value, Type toType)
{
if (value == null || toType == null)
{
return(true);
}
Type type = value.GetType();
if (toType.IsAssignableFrom(type) || (IsPrimitiveType(type) && IsPrimitiveType(toType)))
{
return(true);
}
if (toType == typeof(string))
{
return(true);
}
if (type == typeof(string) && IsPrimitiveType(toType))
{
return(true);
}
if (type.IsEnum && IsPrimitiveType(toType))
{
return(true);
}
if (toType.IsEnum)
{
EnumMetadata enumMetadata = GetEnumMetadata(toType);
if (IsPrimitiveType(type))
{
int num = CoerceValue <int>(value);
return(num >= 0 && num <= enumMetadata.Members.Length - 1);
}
if (type == typeof(string))
{
EnumMemberMetadata[] members = enumMetadata.Members;
foreach (EnumMemberMetadata enumMemberMetadata in members)
{
if (enumMemberMetadata.MemberName.ToLower().Equals(((string)value).ToLower()))
{
return(true);
}
}
}
}
return(false);
}
private static EnumMetadata GetEnumMetadata(Type enumType)
{
if (!enums.ContainsKey(enumType.FullName))
{
List <EnumMemberMetadata> list = new List <EnumMemberMetadata>();
Array values = Enum.GetValues(enumType);
int num = 0;
string[] names = Enum.GetNames(enumType);
foreach (string text in names)
{
MemberInfo element = enumType.GetMember(text)[0];
list.Add(new EnumMemberMetadata
{
MemberName = text,
Value = values.GetValue(num)
});
foreach (EnumValueAttribute item in from i in element.GetCustomAttributes()
where i is EnumValueAttribute
select i)
{
list.Add(new EnumMemberMetadata
{
LocalizationID = item.LocalizationID,
MemberName = text,
Value = item.Value
});
}
num++;
}
EnumMetadata enumMetadata = new EnumMetadata();
enumMetadata.EnumType = enumType;
enumMetadata.Members = list.ToArray();
EnumMetadata value = enumMetadata;
enums.Add(enumType.FullName, value);
}
return(enums[enumType.FullName]);
}
public static SelectList ToSelectList <T>(this EnumMetadata <T> enumMetadata, params int[] seletedIndexes)
{
return(enumMetadata.Items.
ToDictionary(item => Convert.ToInt32(item.Key), item => item.Value).
ToSelectList(seletedIndexes));
}
private static LocalizedString?GetDescriptionTranslation(EnumMetadata <SettingEnum> metadata, IStringLocalizer settingEnumStringLocalizer)
{
var description = metadata.Attributes.OfType <DescriptionAttribute>().FirstOrDefault()?.Description;
return(description != null ? settingEnumStringLocalizer[description] : null);
}
public EnumMetadataControl(EnumMetadata<Answer> metadata)
: this()
{
_metadata = metadata;
}
public static string GetAsString <T>(this EnumMetadata <T> metaData)
{
return(string.Join(";", metaData.Items.Select((item) => Convert.ToInt32(item.Key) + ":" + item.Value)));
}
public static SelectList ToSelectListAsString <T>(this EnumMetadata <T> enumMetadata, params string[] seletedIndexes)
{
return(enumMetadata.Items.
ToDictionary(item => item.Key.ToString(), item => item.Value).
ToSelectList(seletedIndexes));
}
public static SelectList ToSelectList <T>(this EnumMetadata <T> enumMetadata, params T[] seletedIndexes)
{
return(enumMetadata.ToSelectList(seletedIndexes.Select(s => Convert.ToInt32(s)).ToArray()));
}
public EnumMetadataControl(EnumMetadata <Answer> metadata) : this()
{
_metadata = metadata;
}
private static IImmutableList <EnumMemberMetadata> GetEnumMemberMetadata(Type type, EnumMetadata definingEnum)
{
var members = new List <EnumMemberMetadata>();
foreach (FieldInfo field in type.GetFields())
{
if (field.Name == MetadataAnalyzer.DEFAULT_ENUM_MEMBER_NAME)
{
continue;
}
IImmutableList <CustomAttributeMetadata> customAttributes = GetCustomAttributes(field.CustomAttributes);
var enumMember = new EnumMemberMetadata(field.Name)
{
Type = definingEnum,
CustomAttributes = customAttributes
};
members.Add(enumMember);
}
return(members.ToImmutableArray());
}
public static object ConvertValue(object value, Type toType)
{
object obj = null;
if (value == null)
{
return(null);
}
if (toType == null)
{
return(value);
}
Type type = value.GetType();
if (toType.IsAssignableFrom(type) || (IsPrimitiveType(type) && IsPrimitiveType(toType)))
{
obj = CoerceValue(value, toType);
}
else if (toType == typeof(string))
{
obj = ((type == typeof(char)) ? new string(new char[1]
{
(char)value
}) : value.ToString());
}
else if (type == typeof(string) && IsPrimitiveType(toType))
{
string text = (string)value;
int primitiveTypeIndex = GetPrimitiveTypeIndex(toType);
if (primitiveTypeIndex == 5 && text.Length != 1)
{
throw new Exception($"Cannot convert from {text} to char.");
}
if (primitiveTypeIndex == 7 && text != "true" && text != "false")
{
throw new Exception($"Cannot convert from {text} to boolean.");
}
switch (primitiveTypeIndex)
{
case 0:
obj = double.Parse(text);
break;
case 1:
obj = float.Parse(text);
break;
case 2:
obj = decimal.Parse(text);
break;
case 3:
obj = long.Parse(text);
break;
case 4:
obj = int.Parse(text);
break;
case 5:
obj = short.Parse(text);
break;
case 6:
obj = text[0];
break;
case 7:
obj = byte.Parse(text);
break;
case 8:
obj = (text == "true");
break;
}
}
else if (type.IsEnum && IsPrimitiveType(toType))
{
obj = CoerceValue(GetValue((Enum)value), toType);
}
else if (toType.IsEnum)
{
EnumMetadata enumMetadata = GetEnumMetadata(toType);
if (IsPrimitiveType(type))
{
int primitiveTypeIndex = CoerceValue <int>(value);
if (primitiveTypeIndex >= 0 && primitiveTypeIndex <= enumMetadata.Members.Length - 1)
{
obj = enumMetadata.Members[primitiveTypeIndex].Value;
}
}
else if (type == typeof(string))
{
obj = enumMetadata.Members.FirstOrDefault((EnumMemberMetadata i) => i.MemberName == (string)value).Value;
}
}
else if (typeof(IList).IsAssignableFrom(type) && toType.IsArray)
{
IList list = value as IList;
Array array = Array.CreateInstance(toType.GetElementType(), list.Count);
for (int j = 0; j <= list.Count - 1; j++)
{
array.SetValue(list[j], j);
}
obj = array;
}
else if (type.IsArray && typeof(IList).IsAssignableFrom(toType))
{
IList list = Activator.CreateInstance(toType) as IList;
Array array = value as Array;
for (int j = 0; j <= array.Length - 1; j++)
{
list.Add(array.GetValue(j));
}
obj = list;
}
if (value != null && obj == null)
{
throw new Exception($"Cannot convert from {value} to {toType}.");
}
return(obj);
}
