internal ConfigurationOptionDescriptor(ConfigurationOptionAttribute configOption,
IEnumerable <CustomMetadataAttribute> customMetadata, string keyName)
{
this.Default = configOption.Default;
this.Type = configOption.Default.GetType();
this.Unset = configOption.Unset;
this.DisplayName = configOption.DisplayName;
this.Description = configOption.Description;
this.PathType = configOption.PathType;
this.Simple = configOption.Simple;
this.Private = configOption.Private;
this.Flag = configOption.Flag;
this.Max = configOption.Max;
this.Min = configOption.Min;
this.CustomMetadata = customMetadata.ToDictionary(m => m.Key, m => m.Value);
this.Increment = configOption.Increment;
this.OptionName = configOption.OptionName;
this.OptionKey = keyName;
this.OptionType = ConfigurationOptionDescriptor.GetOptionType(this.Type, this.IsPath);
this.IsSelection = this.OptionType == ConfigurationOptionType.Selection;
this.SelectionOptions = this.IsSelection
? NonGenericEnums.GetMembers(this.Type)
.Select(m => new SelectionOptionDescriptor(m))
.ToList()
: Enumerable.Empty <ISelectionOptionDescriptor>();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
switch (reader.TokenType)
{
case JsonToken.Null:
if (!TypeData.Get(objectType).IsNullable)
{
throw new JsonSerializationException($"Cannot convert null value to {objectType}.");
}
return(null);
case JsonToken.String:
return(NonGenericEnums.Parse(objectType, (string)reader.Value, EnumFormat));
case JsonToken.Integer:
return(NonGenericEnums.ToObject(objectType, reader.Value));
default:
throw new JsonSerializationException($"Unexpected token {reader.TokenType} when parsing enum.");
}
}
catch (Exception ex)
{
throw new JsonSerializationException($"Error converting value {reader.Value} to type '{objectType}'", ex);
}
}
public static string AsConfigurationStringValue(this object @this)
{
return(@this.GetType().GetTypeInfo().IsEnum
? NonGenericEnums.GetName(@this.GetType(), @this)
: // optimized path for enums
Convert.ToString(@this));
}
public ParseBenchmarks()
{
var enumTypes = typeof(string).GetTypeInfo().Assembly.GetTypes().Where(type => type.GetTypeInfo().IsEnum&& !type.GetTypeInfo().IsGenericType).ToList();
_enumDatas = new EnumData[enumTypes.Count];
for (var i = 0; i < _enumDatas.Length; ++i)
{
var enumType = enumTypes[i];
var names = Enum.GetNames(enumType);
var numericValues = new string[names.Length];
var values = Enum.GetValues(enumType);
for (var j = 0; j < values.Length; ++j)
{
numericValues[j] = Enum.Format(enumType, values.GetValue(j), "D");
}
var parser = (Parser)Activator.CreateInstance(typeof(Parser <>).MakeGenericType(enumType));
_enumDatas[i] = new EnumData {
Type = enumType, Names = names, NumericValues = numericValues, GenericParser = parser
};
if (names.Length > 0)
{
NonGenericEnums.Parse(enumType, names[0]); // Warmup
parser.Parse(names[0]); // Warmup
}
}
}
public bool NonGenericEnums_IsDefined_False()
{
var result = false;
foreach (var value in _undefinedValues)
{
result |= NonGenericEnums.IsDefined(_enumType, value);
}
return(result);
}
/// <summary>
/// 获取枚举的显示名称
/// </summary>
/// <typeparam name="TEnum">枚举</typeparam>
/// <param name="value">枚举值</param>
/// <returns>如果返回-999即失败</returns>
public static int Value <TEnum>(this TEnum value) where TEnum : struct
{
if (!(value is Enum))
{
return(-999);
}
var values = NonGenericEnums.GetMember(value.GetType(), value);
return(values.ToInt32());
}
public string NonGenericEnums_AsString_Decimal()
{
string result = null;
foreach (var value in _values)
{
result = NonGenericEnums.AsString(_enumType, value, EnumFormat.DecimalValue);
}
return(result);
}
public string NonGenericEnums_AsString_Name()
{
string result = null;
foreach (var value in _values)
{
result = NonGenericEnums.AsString(_enumType, value);
}
return(result);
}
/// <summary>
/// 获取枚举的显示名称
/// </summary>
/// <typeparam name="TEnum">枚举</typeparam>
/// <param name="value">枚举值</param>
/// <returns></returns>
public static string DisplayName <TEnum>(this TEnum value) where TEnum : struct
{
if (!(value is Enum))
{
return("");
}
var values = NonGenericEnums.GetMember(value.GetType(), value);
var dis = values.Attributes.Get(typeof(DisplayNameAttribute)) as DisplayNameAttribute;
return(dis == null ? "" : dis.DisplayName);
}
/// <summary>
/// 获取枚举的显示名称
/// </summary>
/// <typeparam name="TEnum">枚举</typeparam>
/// <param name="value">枚举值</param>
/// <returns></returns>
public static OperationType Operation <TEnum>(this TEnum value) where TEnum : struct
{
if (!(value is Enum))
{
return(OperationType.None);
}
var values = NonGenericEnums.GetMember(value.GetType(), value);
var dis = values.Attributes.Get(typeof(OperationAttribute)) as OperationAttribute;
return(dis == null ? OperationType.None : dis.Type);
}
public override Result TryParse(Type type, string s, CultureInfo cultureInfo, Func <Type, string, Result> tryParse)
{
object _result;
if (NonGenericEnums.TryParse(type, s, !_CaseSensitive, out _result))
{
return(Valid(_result));
}
return(InvalidString());
}
private static IEnumerable <JProperty> SerializeEnumValues(Type selectionEnum)
{
return(from enumOption in NonGenericEnums.GetMembers(selectionEnum)
where enumOption.Attributes.Has <SelectionOptionAttribute>()
let attribute = enumOption.Attributes.Get <SelectionOptionAttribute>()
select new JProperty(enumOption.Name, new JObject()
{
{ nameof(attribute.DisplayName), attribute.DisplayName ?? enumOption.Name },
{ nameof(attribute.Private), attribute.Private },
}));
}
/// <summary>
/// 获取枚举的描述
/// </summary>
/// <typeparam name="TEnum">枚举</typeparam>
/// <param name="value">枚举值</param>
/// <returns></returns>
public static string Description <TEnum>(this TEnum value) where TEnum : struct
{
if (!(value is Enum))
{
return("");
}
var values = NonGenericEnums.GetMember(value.GetType(), value);
var des = values.Attributes.Get(typeof(DescriptionAttribute)) as DescriptionAttribute;
return(des == null ? "" : des.Description);
}
public static void IsDefined(DayOfWeek[] dayOfWeekArray)
{
const int iterations = 250000;
var dayOfWeekType = typeof(DayOfWeek);
using (new OperationTimer("Enum.IsDefined Performance"))
{
for (var i = 0; i < iterations; ++i)
{
for (var j = 0; j < dayOfWeekArray.Length; ++j)
{
Enum.IsDefined(dayOfWeekType, dayOfWeekArray[j]);
}
}
}
using (new OperationTimer("NonGenericEnums.IsDefined Performance"))
{
for (var i = 0; i < iterations; ++i)
{
for (var j = 0; j < dayOfWeekArray.Length; ++j)
{
NonGenericEnums.IsDefined(dayOfWeekType, dayOfWeekArray[j]);
}
}
}
using (new OperationTimer("Enums.IsDefined Performance"))
{
for (var i = 0; i < iterations; ++i)
{
for (var j = 0; j < dayOfWeekArray.Length; ++j)
{
dayOfWeekArray[j].IsDefined();
}
}
}
using (new OperationTimer("Enums.IsValid Performance"))
{
for (var i = 0; i < iterations; ++i)
{
for (var j = 0; j < dayOfWeekArray.Length; ++j)
{
dayOfWeekArray[j].IsValid();
}
}
}
}
public object NonGenericEnums_Parse_Decimals()
{
object result = null;
foreach (var enumData in _enumDatas)
{
var enumType = enumData.Type;
foreach (var value in enumData.NumericValues)
{
result = NonGenericEnums.Parse(enumType, value);
}
}
return(result);
}
/// <summary>
/// 字符串转枚举
/// </summary>
/// <typeparam name="TEnum">枚举类型</typeparam>
/// <param name="value">字符串</param>
/// <returns></returns>
public static TEnum StringToEnum <TEnum>(this string value) where TEnum : struct
{
if (value.IsEmpty())
{
return(default(TEnum));
}
var values = NonGenericEnums.GetMember(typeof(TEnum), value.ToCamel());
if (values == null)
{
return(default(TEnum));
}
return((TEnum)values.Value);
}
private static void TestForUndefinedEnumOptions(List <string> path, List <string> fails, Dictionary <Type, HashSet <string> > enumOptionsToIgnore, object itemValue)
{
var typeInfo = itemValue.GetType().GetTypeInfo();
if (typeInfo.IsGenericType && !typeInfo.IsGenericTypeDefinition && typeInfo.GetGenericTypeDefinition() == TypeData.OpenStringEnumValueType)
{
var stringValue = itemValue.ToString();
if (!string.IsNullOrEmpty(stringValue))
{
var enumType = typeInfo.GenericTypeArguments[0];
if (!NonGenericEnums.TryParse(enumType, stringValue, true, out _, EnumFormat.EnumMemberValue, EnumFormat.Name) && (enumOptionsToIgnore == null || !enumOptionsToIgnore.TryGetValue(enumType, out var optionsToIgnore) || !optionsToIgnore.Contains(stringValue)))
{
fails.Add($"{string.Concat(path)} value of '{stringValue}' is not defined in {enumType.Name}");
}
}
}
}
static void Main()
{
var enumTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(assembly => assembly.GetTypes()).Where(type => type.IsEnum && !type.IsGenericType).ToList();
//var methodInfo = typeof(Enums).GetMethod("GetUnderlyingType");
using (new OperationTimer("All Available Enums Caching Performance"))
{
foreach (var enumType in enumTypes)
{
//methodInfo.MakeGenericMethod(enumType).Invoke(null, null);
NonGenericEnums.GetUnderlyingType(enumType);
}
}
Console.WriteLine(enumTypes.Count);
Parse(enumTypes);
var dayOfWeekArray = new DayOfWeek[14];
for (var i = 0; i < dayOfWeekArray.Length; ++i)
{
dayOfWeekArray[i] = (DayOfWeek)i;
}
ToString(dayOfWeekArray);
IsDefined(dayOfWeekArray);
GetHashCode(dayOfWeekArray);
var attributeTargetsArray = new AttributeTargets[15];
attributeTargetsArray[0] = (AttributeTargets)0;
attributeTargetsArray[1] = (AttributeTargets)1;
for (var i = 2; i < attributeTargetsArray.Length; ++i)
{
attributeTargetsArray[i] = (AttributeTargets)(1 << (i - 1)) | (AttributeTargets)(1 << (i - 2));
}
var allAttributeTargets = (AttributeTargets[])Enum.GetValues(typeof(AttributeTargets));
HasFlag(attributeTargetsArray, allAttributeTargets);
Console.ReadLine();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
}
else
{
var enumType = value.GetType();
if (EnumFormat != EnumFormat.DecimalValue)
{
var member = NonGenericEnums.GetMember(enumType, value);
if (member != null)
{
writer.WriteValue(member.AsString(EnumFormat));
return;
}
}
writer.WriteRawValue(NonGenericEnums.AsString(enumType, value, EnumFormat.DecimalValue));
}
}
/// <summary>
/// 获取枚举的显示名称
/// </summary>
/// <typeparam name="TEnum">枚举</typeparam>
/// <param name="type">枚举值</param>
/// <returns></returns>
public static List <EnumKeyValue> GetEnumList <TEnum>(this TEnum type) where TEnum : struct
{
List <EnumKeyValue> list = new List <EnumKeyValue>();
if (!(type is Enum))
{
return(list);
}
var values = NonGenericEnums.GetMembers(type.GetType());
foreach (EnumMember value in values)
{
var dis = value.Attributes.Get(typeof(DisplayNameAttribute)) as DisplayNameAttribute;
var des = value.Attributes.Get(typeof(DescriptionAttribute)) as DescriptionAttribute;
EnumKeyValue keyValue = new EnumKeyValue();
keyValue.Value = value.ToInt32();
keyValue.DisplayName = dis == null ? "" : dis.DisplayName;
keyValue.Description = des == null ? "" : des.Description;
list.Add(keyValue);
}
return(list);
}
static EntityGenerator()
{
var sharedEnumTypes = new[]
{
typeof(YOrN),
typeof(YNOrNA),
typeof(YesOrNo),
typeof(YesNoOrNA),
typeof(TrueOrFalse),
typeof(AcceptOrReject),
typeof(IncreasedOrDecreased),
typeof(UtilitiesDescription),
typeof(TermType),
typeof(SignedByTyp),
typeof(TotalClosingCostRemark),
typeof(PartyType),
typeof(AUS),
typeof(AUSRecommendation),
typeof(BankruptcyForeclosureStatus),
typeof(LicenseAuthType),
typeof(BorContingentLiabilitiesLiabilityDescription),
typeof(BorrowerType),
typeof(ClosingCostFundsType),
typeof(FundsTypeDescription),
typeof(ClosingCostSourceType),
typeof(SourceTypeDescription),
typeof(DocsLoanProgramType),
typeof(ServicingType),
typeof(CorrespondentOptionDesc),
typeof(CreditChargeType),
typeof(DenialReason),
typeof(DisclosureMethod),
typeof(DownPaymentSourceType),
typeof(YNOrOther),
typeof(Hud1EsPayToFeeType),
typeof(RefundableType),
typeof(RecSamePtyTypeDesc),
typeof(FeddieBorrowerAlienStatus),
typeof(FreddieDownPaymentType),
typeof(FullPrepaymentPenaltyOptionType),
typeof(ATRQMStatus),
typeof(ImpoundType),
typeof(ClosingCostImpoundType),
typeof(ImpoundWaived),
typeof(IncludeOriginationPointsCreditType),
typeof(InformationTypesWeCollect),
typeof(ProjectType),
typeof(MonthOrYear),
typeof(CanGoOrGoes),
typeof(OrgTyp),
typeof(IsOrIsNot),
typeof(LimitSharing),
typeof(ScsrsClaus),
typeof(CanIncreaseOrIncreases),
typeof(LoanAmountType),
typeof(LoanDocumentationType),
typeof(LoanPurposeType),
typeof(LoanType),
typeof(RefinancePurpose),
typeof(PropertyType),
typeof(LienType),
typeof(DoesOrDoesNot),
typeof(DoesOrDoesNot2),
typeof(OpenBankruptcy),
typeof(InterestRateImpactedStatus),
typeof(FeePaidBy),
typeof(Owner),
typeof(PaidBy),
typeof(PaidType),
typeof(PenaltyTerm),
typeof(OccupancyIntent),
typeof(PrepaymentPenaltyBasedOn),
typeof(PropertyUsageType),
typeof(PTB),
typeof(DaysInYear),
typeof(TypeOfPurchaser),
typeof(RiskClassification),
typeof(RoundingMethod),
typeof(SignatureType),
typeof(FinalSignatureType),
typeof(SofDBorrowerAddressType),
typeof(TimesToCollect),
typeof(TrstSamePtyTypDesc),
typeof(ProfitManagementItemType),
typeof(UCDPayoffType),
typeof(UlddBorrowerType),
typeof(VestingTrusteeOfType),
typeof(WholePocPaidByType),
typeof(AmortizationType),
typeof(ApplicationTakenMethodType),
typeof(OtherPropertyType),
typeof(RiskAssessmentType),
typeof(ActionTaken),
typeof(IndexMargin),
typeof(PropertyFormType)
};
s_sharedEnums = new Dictionary <string, HashSet <string> >();
foreach (var sharedEnumType in sharedEnumTypes)
{
s_sharedEnums.Add(sharedEnumType.Name, new HashSet <string>(NonGenericEnums.GetMembers(sharedEnumType).Select(m => m.AsString(EnumFormat.EnumMemberValue, EnumFormat.Name))));
}
}
internal EnumConfigurationNode(string key, Enum value, Type enumType) : base(key, value)
{
this.EnumType = enumType;
this.Value = NonGenericEnums.GetMember(enumType, value)
.Attributes.Get <SelectionOptionAttribute>().SerializeAs;
}
public void NonGenericEnumsNullableTest()
{
Assert.AreEqual("Today", NonGenericEnums.GetName(typeof(DateFilterOperator?), (DateFilterOperator?)DateFilterOperator.Today));
Assert.AreEqual("Today", NonGenericEnums.GetName(typeof(DateFilterOperator?), DateFilterOperator.Today));
Assert.AreEqual(null, NonGenericEnums.GetName(typeof(DateFilterOperator?), null));
}
public static void Parse(IEnumerable <Type> enumTypes)
{
var list = new List <EnumInfo>();
foreach (var enumType in enumTypes)
{
var names = Enum.GetNames(enumType).ToList();
var numericValues = new List <string>(names.Count);
foreach (var value in Enum.GetValues(enumType))
{
numericValues.Add(Enum.Format(enumType, value, "D"));
}
var parser = (Parser)Activator.CreateInstance(typeof(Parser <>).MakeGenericType(enumType));
list.Add(new EnumInfo {
Type = enumType, Names = names, NumericValues = numericValues, GenericParser = parser
});
}
const int parseIterations = 375;
using (new OperationTimer("Enum.Parse (Names)"))
{
foreach (var tuple in list)
{
var enumType = tuple.Type;
for (var i = 0; i < parseIterations; ++i)
{
foreach (var name in tuple.Names)
{
Enum.Parse(enumType, name);
}
}
}
}
// Primes the pump
foreach (var tuple in list)
{
if (tuple.Names.Count > 0)
{
NonGenericEnums.Parse(tuple.Type, tuple.Names[0]);
}
}
using (new OperationTimer("NonGenericEnums.Parse (Names)"))
{
foreach (var tuple in list)
{
var enumType = tuple.Type;
for (var i = 0; i < parseIterations; ++i)
{
foreach (var name in tuple.Names)
{
NonGenericEnums.Parse(enumType, name);
}
}
}
}
// Primes the pump
foreach (var tuple in list)
{
if (tuple.Names.Count > 0)
{
tuple.GenericParser.Parse(tuple.Names[0]);
}
}
using (new OperationTimer("UnsafeEnums.Parse (Names)"))
{
foreach (var tuple in list)
{
var parser = tuple.GenericParser;
for (var i = 0; i < parseIterations; ++i)
{
foreach (var name in tuple.Names)
{
parser.Parse(name);
}
}
}
}
using (new OperationTimer("Enum.Parse (Decimal)"))
{
foreach (var tuple in list)
{
var enumType = tuple.Type;
for (var i = 0; i < parseIterations; ++i)
{
foreach (var numericValue in tuple.NumericValues)
{
Enum.Parse(enumType, numericValue);
}
}
}
}
using (new OperationTimer("NonGenericEnums.Parse (Decimal)"))
{
foreach (var tuple in list)
{
var enumType = tuple.Type;
for (var i = 0; i < parseIterations; ++i)
{
foreach (var numericValue in tuple.NumericValues)
{
NonGenericEnums.Parse(enumType, numericValue);
}
}
}
}
using (new OperationTimer("UnsafeEnums.Parse (Decimal)"))
{
foreach (var tuple in list)
{
var parser = tuple.GenericParser;
for (var i = 0; i < parseIterations; ++i)
{
foreach (var numericValue in tuple.NumericValues)
{
parser.Parse(numericValue);
}
}
}
}
}
public void NonGenericEnumsGetUnderlyingType()
{
Assert.AreEqual(typeof(short), NonGenericEnums.GetUnderlyingType(typeof(DateFilterOperator)));
Assert.AreEqual(typeof(ulong), NonGenericEnums.GetUnderlyingType(typeof(ContiguousUInt64Enum)));
Assert.AreEqual(typeof(long), NonGenericEnums.GetUnderlyingType(typeof(NonContiguousEnum)));
}
private string EnumConverter(Enum enumValue)
{
return(NonGenericEnums.GetAttributes(enumValue.GetType(), enumValue)
.Get <SelectionOptionAttribute>().SerializeAs);
}
public static void ToString(DayOfWeek[] dayOfWeekArray)
{
const int iterations = 50000;
using (new OperationTimer("Enum.ToString (Name)"))
{
for (var i = 0; i < (iterations << 1); ++i)
{
for (var j = 0; j < 7; ++j)
{
dayOfWeekArray[j].ToString();
}
}
}
var dayOfWeekType = typeof(DayOfWeek);
using (new OperationTimer("NonGenericEnums.AsString (Name)"))
{
for (var i = 0; i < (iterations << 1); ++i)
{
for (var j = 0; j < 7; ++j)
{
NonGenericEnums.AsString(dayOfWeekType, dayOfWeekArray[j]);
}
}
}
using (new OperationTimer("Enums.AsString (Name)"))
{
for (var i = 0; i < (iterations << 1); ++i)
{
for (var j = 0; j < 7; ++j)
{
dayOfWeekArray[j].AsString();
}
}
}
using (new OperationTimer("Enum.ToString (Decimal)"))
{
for (var i = 0; i < iterations; ++i)
{
for (var j = 0; j < dayOfWeekArray.Length; ++j)
{
dayOfWeekArray[j].ToString("D");
}
}
}
using (new OperationTimer("NonGenericEnums.AsString (Decimal)"))
{
for (var i = 0; i < iterations; ++i)
{
for (var j = 0; j < dayOfWeekArray.Length; ++j)
{
NonGenericEnums.AsString(dayOfWeekType, dayOfWeekArray[j], EnumFormat.DecimalValue);
}
}
}
using (new OperationTimer("Enums.AsString (Decimal)"))
{
for (var i = 0; i < iterations; ++i)
{
for (var j = 0; j < dayOfWeekArray.Length; ++j)
{
dayOfWeekArray[j].AsString(EnumFormat.DecimalValue);
}
}
}
}
