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