[Fork] [Fork] https://stackoverflow.com/questions/72886747/deserialize-enums-using-the-enummember-value-in-aspnet-fromquery-model-binding | C# Online Compiler

[Fork] [Fork] https://stackoverflow.com/questions/72886747/deserialize-enums-using-the-enummember-value-in-aspnet-fromquery-model-binding by dbc_MinLength

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Reflection;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Diagnostics;
using System.Runtime.Serialization;

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.Text.Json;

//https://stackoverflow.com/questions/72886747/deserialize-enums-using-the-enummember-value-in-aspnet-fromquery-model-binding

#nullable enable

	// Begin code for enum model binding

	public class EnumMemberModelBinderProvider : RenamableEnumModelBinderProvider
	{
		public EnumMemberModelBinderProvider(MvcOptions options) : base(options) { }

		public EnumMemberModelBinderProvider(MvcOptions options, JsonNamingPolicy? namingPolicy, bool allowIntegerValues) : base(options, namingPolicy, allowIntegerValues) { }

		protected override bool TryOverrideName(Type enumType, string name, out ReadOnlyMemory<char> overrideName)
		{
			// You could substitute JsonPropertyNameAttribute or any other attribute with some override name here, if you prefer.
			if (EnumExtensions.TryGetEnumAttribute<System.Runtime.Serialization.EnumMemberAttribute>(enumType, name, out var attr) && attr.Value != null)
			{
				overrideName = attr.Value.AsMemory();
				return true;
			}
			return base.TryOverrideName(enumType, name, out overrideName);
		}
	}

	public class RenamableEnumModelBinderProvider : IModelBinderProvider
	{
		readonly JsonNamingPolicy? namingPolicy;
		readonly bool allowIntegerValues;

		public RenamableEnumModelBinderProvider(MvcOptions options) : this(options, null, true) { }

		public RenamableEnumModelBinderProvider(MvcOptions options, JsonNamingPolicy? namingPolicy, bool allowIntegerValues) => 
			(this.namingPolicy, this.allowIntegerValues) = (namingPolicy, allowIntegerValues);

		/// <inheritdoc />
		public IModelBinder? GetBinder(ModelBinderProviderContext context)
		{
			if (context == null)
			{
				throw new ArgumentNullException(nameof(context));
			}

			if (context.Metadata.IsEnum)
			{
				var loggerFactory = context.Services.GetRequiredService<ILoggerFactory>();
				var binderType = typeof(RenamableEnumModelBinder<>).MakeGenericType(context.Metadata.UnderlyingOrModelType);
				TryOverrideName tryOverrideName = (Type t, string n, out ReadOnlyMemory<char> o) => TryOverrideName(t, n, out o);
				return (IModelBinder)Activator.CreateInstance(binderType,
															BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
															binder: null,
															args: new object[] { loggerFactory, namingPolicy!, allowIntegerValues, tryOverrideName },
															culture: null)!;
			}
			return null;
		}
		
		protected virtual bool TryOverrideName(Type enumType, string name, out ReadOnlyMemory<char> overrideName)
		{
			overrideName = default;
			return false;
		}
	}

	public class RenamableEnumModelBinder<TEnum> : SimpleModelBinderBase where TEnum : struct, Enum
	{
		bool AllowNumbers { get; }
		EnumTypeData<TEnum> EnumTypeData { get; }

		public RenamableEnumModelBinder(ILoggerFactory loggerFactory, JsonNamingPolicy? namingPolicy, bool allowNumbers, TryOverrideName? tryOverrideName) : base(loggerFactory)
		{
			this.AllowNumbers = allowNumbers;
			this.EnumTypeData = EnumTypeData<TEnum>.Create(namingPolicy, tryOverrideName);
		}

		protected override object? ConvertModelFromString(ModelBindingContext bindingContext, string? value)
		{
			if (string.IsNullOrWhiteSpace(value))
				return null;
			TEnum result;
			if (EnumTypeData.TryLookup(value.AsMemory(), out result))
				return result;
			if (AllowNumbers && EnumExtensions.TryParseEnumFromNumber<TEnum>(value, out result))
				return result;
			throw new FormatException(string.Format("Unknown value {0} for enum {1}", value, nameof(TEnum)));
		}
	}

	public abstract class SimpleModelBinderBase : IModelBinder
	{
		readonly ILogger _logger;

		public SimpleModelBinderBase(ILoggerFactory loggerFactory) => _logger = (loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory))).CreateLogger<SimpleModelBinderBase>();

		/// <inheritdoc />
		public Task BindModelAsync(ModelBindingContext bindingContext)
		{
			if (bindingContext == null)
			{
				throw new ArgumentNullException(nameof(bindingContext));
			}

			var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
			if (valueProviderResult == ValueProviderResult.None)
			{
				return Task.CompletedTask;
			}

			bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);

			try
			{
				var value = valueProviderResult.FirstValue; // TODO: Check enums with spaces in their overidden names, e.g. [EnumMember("My Name")]
				object? model = ConvertModelFromString(bindingContext, value);
				CheckAndSaveModel(bindingContext, valueProviderResult, model);
				return Task.CompletedTask;
			}
			catch (Exception exception)
			{
				bindingContext.ModelState.TryAddModelError(bindingContext.ModelName, exception, bindingContext.ModelMetadata);
				// Were able to find a converter for the type but conversion failed.
				return Task.CompletedTask;
			}
		}

		protected abstract object? ConvertModelFromString(ModelBindingContext bindingContext, string? value);

		protected virtual void CheckAndSaveModel(ModelBindingContext bindingContext, ValueProviderResult valueProviderResult, object? model)
		{
			if (model == null && !bindingContext.ModelMetadata.IsReferenceOrNullableType)
			{
				bindingContext.ModelState.TryAddModelError(
					bindingContext.ModelName,
					bindingContext.ModelMetadata.ModelBindingMessageProvider.ValueMustNotBeNullAccessor(
						valueProviderResult.ToString()));
			}
			else
			{
				bindingContext.Result = ModelBindingResult.Success(model);
			}
		}
	}

	// End code for enum model binding

	/********************************************************/
	// Begin general enum parsing code

	public static partial class EnumExtensions
	{
        public static bool TryParseEnumFromNumber<TEnum>(string s, out TEnum value) where TEnum : struct, Enum =>
			TryParseEnumFromNumber(s, Type.GetTypeCode(typeof(TEnum)), out value);
		
        internal static bool TryParseEnumFromNumber<TEnum>(string s, TypeCode enumTypeCode, out TEnum value) where TEnum : struct, Enum
        {
			Debug.Assert(enumTypeCode == Type.GetTypeCode(typeof(TEnum)));
            switch (Type.GetTypeCode(typeof(TEnum)))
            {
                case TypeCode.SByte:
                    {
						if (SByte.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<SByte, TEnum>(ref i);
							return true;
						}
                    };
					break;
                case TypeCode.Int16:
                    {
						if (Int16.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<Int16, TEnum>(ref i);
							return true;
						}
                    };
					break;
                case TypeCode.Int32:
                    {
						if (Int32.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<Int32, TEnum>(ref i);
							return true;
						}
                    };
					break;
                case TypeCode.Int64:
                    {
						if (Int64.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<Int64, TEnum>(ref i);
							return true;
						}
                    };
					break;
                case TypeCode.Byte:
                    {
						if (Byte.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<Byte, TEnum>(ref i);
							return true;
						}
                    };
					break;
                case TypeCode.UInt16:
                    {
						if (UInt16.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<UInt16, TEnum>(ref i);
							return true;
						}
                    };
					break;
                case TypeCode.UInt32:
                    {
						if (UInt32.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<UInt32, TEnum>(ref i);
							return true;
						}
                    };
					break;
                case TypeCode.UInt64:
                    {
						if (UInt64.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
						{
                        	value = Unsafe.As<UInt64, TEnum>(ref i);
							return true;
						}
                    };
					break;
                default:
                    throw new JsonException();
            }
			value = default(TEnum);
			return false;
        }
	}

	// Code refactored from this answer https://stackoverflow.com/a/59061296/3744182
	// By https://stackoverflow.com/users/3744182/dbc
	// To https://stackoverflow.com/questions/59059989/system-text-json-how-do-i-specify-a-custom-name-for-an-enum-value/
	// Refactored version here: https://dotnetfiddle.net/0pa6pD

	public delegate bool TryOverrideName(Type enumType, string name, out ReadOnlyMemory<char> overrideName);

	public class EnumTypeData<TEnum> where TEnum : struct, Enum
	{
		readonly record struct EnumData(ReadOnlyMemory<char> name, TEnum value, UInt64 UInt64Value);

		internal static TypeCode EnumTypeCode { get; } = Type.GetTypeCode(typeof(TEnum));	
		static Func<EnumData, UInt64, int> EntryComparer { get; } = (item, key) => item.UInt64Value.CompareTo(key);
		static bool Flagged { get; } = typeof(TEnum).IsDefined(typeof(FlagsAttribute), false);

		private EnumData [] EnumDataArray { get; }
		private ILookup<ReadOnlyMemory<char>, int> NameLookup { get; }
	
		private EnumTypeData(EnumData [] enumDataArray, ILookup<ReadOnlyMemory<char>, int> nameLookup) => 
			(this.EnumDataArray, this.NameLookup) = (enumDataArray ?? throw new ArgumentNullException(nameof(enumDataArray)), nameLookup ?? throw new ArgumentNullException(nameof(nameLookup)));
	
		public static EnumTypeData<TEnum> Create(JsonNamingPolicy? namingPolicy, TryOverrideName? tryOverrideName)
		{
			var enumData = GetEnumData(namingPolicy, tryOverrideName);
			return new EnumTypeData<TEnum>(enumData, GetLookupTable(enumData));
		}
		
		// Return data about the enum sorted by the binary values of the enumeration constants (that is, by their unsigned magnitude)
		static EnumData [] GetEnumData(JsonNamingPolicy? namingPolicy, TryOverrideName? tryOverrideName)
		{
			var names = Enum.GetNames<TEnum>();
			var values = Enum.GetValues<TEnum>();
			return names.Zip(values, (n, v) => 
				{ 
					if (tryOverrideName == null || !tryOverrideName(typeof(TEnum), n, out var jsonName))
						jsonName = (namingPolicy == null ? n.AsMemory() : namingPolicy.ConvertName(n).AsMemory());
					return new EnumData(jsonName, v, v.ToUInt64(EnumTypeCode));
				})
				.ToArray();
		}

		static int FindEnumDataIndex(EnumData [] enumData, TEnum value, out UInt64 UInt64value)
		{
			UInt64value = value.ToUInt64(EnumTypeCode);
			return enumData.BinarySearchFirst(UInt64value, EntryComparer);
		}

		static ILookup<ReadOnlyMemory<char>, int> GetLookupTable(EnumData [] namesAndValues) =>
			Enumerable.Range(0, namesAndValues.Length).ToLookup(i => namesAndValues[i].name, CharMemoryComparer.OrdinalIgnoreCase);
			
		public bool TryFormatAsString(TEnum value, out ReadOnlyMemory<char> name)
		{
			if (!Flagged)
				return TryFormatSimpleAsString(value, out name);
			else
				return TryFormatFlaggedAsString(value, out name);
		}

		bool TryFormatSimpleAsString(TEnum value, out ReadOnlyMemory<char> name)
		{
			var index = FindEnumDataIndex(EnumDataArray, value, out var _);
			if (index >= 0)
			{
				name = EnumDataArray[index].name;
				return true;
			}
			name = default;
			return false;
		}

		bool TryFormatFlaggedAsString(TEnum value, out ReadOnlyMemory<char> name)
		{
			var index = FindEnumDataIndex(EnumDataArray, value, out var UInt64Value);
			if (index >= 0)
			{
				// A single flag
				name = EnumDataArray[index].name;
				return true;
			}
			if (UInt64Value != 0)
			{
				StringBuilder? sb = null;
				for (int i = (~index) - 1; i >= 0; i--)
				{
					if ((UInt64Value & EnumDataArray[i].UInt64Value) ==  EnumDataArray[i].UInt64Value && EnumDataArray[i].UInt64Value != 0)
					{
						if (sb == null)
						{
							sb = new StringBuilder();
							sb.Append(EnumDataArray[i].name.Span);
						}
						else
						{
							sb.Insert(0, EnumExtensions.FlagSeparatorString);
							sb.Insert(0, EnumDataArray[i].name.Span);
						}
						UInt64Value -= EnumDataArray[i].UInt64Value;
					}
				}
				if (UInt64Value == 0 && sb != null)
				{
					name = sb.ToString().AsMemory();
					return true;
				}
			}
			name = default;
			return false;
		}

		public bool TryLookup(ReadOnlyMemory<char> name, out TEnum value)
		{
			if (!Flagged)
				return TryLookupSimple(name, out value);
			else
				return TryLookupFlagged(name, out value);
		}

		bool TryLookupSimple(ReadOnlyMemory<char> name, out TEnum value)
		{
			int i = 0;
			int firstMatch = -1;
			foreach (var index in NameLookup[name])
			{
				if (firstMatch == -1)
					firstMatch = index;
				else 
				{
					if (i == 1 && MemoryExtensions.Equals(EnumDataArray[firstMatch].name.Span, name.Span, StringComparison.Ordinal))
					{
						value = EnumDataArray[firstMatch].value;
						return true;
					}
					if (MemoryExtensions.Equals(EnumDataArray[index].name.Span, name.Span, StringComparison.Ordinal))
					{
						value = EnumDataArray[index].value;
						return true;
					}
				}
				i++;
			}
			value = (firstMatch == -1 ? default : EnumDataArray[firstMatch].value);
			return firstMatch != -1;
		}
		
		bool TryLookupFlagged(ReadOnlyMemory<char> name, out TEnum value)
		{
			UInt64 UInt64Value = 0;
			foreach (var slice in name.Split(EnumExtensions.FlagSeparatorChar, StringSplitOptions.TrimEntries))
			{
				if (TryLookupSimple(slice, out var thisValue))
					UInt64Value |= thisValue.ToUInt64();
				else
				{
					value = default;
					return false;
				}
			}
			value = UInt64Value.ToEnum<TEnum>(EnumTypeCode);
			return true;
		}
	}

	public static partial class EnumExtensions
	{
		public const char FlagSeparatorChar = ',';
		public const string FlagSeparatorString = ", ";
		
		public static bool TryGetEnumAttribute<TAttribute>(Type type, string name, [System.Diagnostics.CodeAnalysis.NotNullWhen(returnValue: true)] out TAttribute? attribute) where TAttribute : System.Attribute
		{
			var member = type.GetMember(name).SingleOrDefault();
			attribute = member?.GetCustomAttribute<TAttribute>(false);
			return attribute != null;
		}
		
		public static UInt64 ToUInt64<TEnum>(this TEnum value) where TEnum : struct, Enum => value.ToUInt64(EnumTypeData<TEnum>.EnumTypeCode);
		
		internal static UInt64 ToUInt64<TEnum>(this TEnum value, TypeCode enumTypeCode) where TEnum : struct, Enum
		{
			Debug.Assert(enumTypeCode == Type.GetTypeCode(typeof(TEnum)));
			return enumTypeCode switch
			{
				TypeCode.SByte => unchecked((ulong)Unsafe.As<TEnum, SByte>(ref value)),
				TypeCode.Int16 => unchecked((ulong)Unsafe.As<TEnum, Int16>(ref value)),
				TypeCode.Int32 => unchecked((ulong)Unsafe.As<TEnum, Int32>(ref value)),
				TypeCode.Int64 => unchecked((ulong)Unsafe.As<TEnum, Int64>(ref value)),
				TypeCode.Byte => Unsafe.As<TEnum, Byte>(ref value),
				TypeCode.UInt16 => Unsafe.As<TEnum, UInt16>(ref value),
				TypeCode.UInt32 => Unsafe.As<TEnum, UInt32>(ref value),
				TypeCode.UInt64 => Unsafe.As<TEnum, UInt64>(ref value),
				_ => throw new ArgumentException(enumTypeCode.ToString()),
			};
		}

		public static TEnum ToEnum<TEnum>(this UInt64 value) where TEnum : struct, Enum => value.ToEnum<TEnum>(EnumTypeData<TEnum>.EnumTypeCode);
		
		internal static TEnum ToEnum<TEnum>(this UInt64 value, TypeCode enumTypeCode) where TEnum : struct, Enum
		{
			Debug.Assert(enumTypeCode == Type.GetTypeCode(typeof(TEnum)));
			switch (enumTypeCode)
			{
				case TypeCode.SByte:
					{
						var i = unchecked((SByte)value);
						return Unsafe.As<SByte, TEnum>(ref i);
					};
				case TypeCode.Int16:
					{
						var i = unchecked((Int16)value);
						return Unsafe.As<Int16, TEnum>(ref i);
					};
				case TypeCode.Int32:
					{
						var i = unchecked((Int32)value);
						return Unsafe.As<Int32, TEnum>(ref i);
					};
				case TypeCode.Int64:
					{
						var i = unchecked((Int64)value);
						return Unsafe.As<Int64, TEnum>(ref i);
					};
				case TypeCode.Byte:
					{
						var i = unchecked((Byte)value);
						return Unsafe.As<Byte, TEnum>(ref i);
					};
				case TypeCode.UInt16:
					{
						var i = unchecked((UInt16)value);
						return Unsafe.As<UInt16, TEnum>(ref i);
					};
				case TypeCode.UInt32:
					{
						var i = unchecked((UInt32)value);
						return Unsafe.As<UInt32, TEnum>(ref i);
					};
				case TypeCode.UInt64:
					{
						var i = unchecked((UInt64)value);
						return Unsafe.As<UInt64, TEnum>(ref i);
					};
				default:
					throw new ArgumentException(enumTypeCode.ToString());
			}
		}
	}

	public static class StringExtensions
	{
		public static IEnumerable<ReadOnlyMemory<char>> Split(this ReadOnlyMemory<char> chars, char separator, StringSplitOptions options = StringSplitOptions.None)
		{
			int index;
			while ((index = chars.Span.IndexOf(separator)) >= 0)
			{
				var slice = chars.Slice(0, index);
				if ((options & StringSplitOptions.TrimEntries) == StringSplitOptions.TrimEntries)
					slice = slice.Trim();
				if ((options & StringSplitOptions.RemoveEmptyEntries) == 0 || slice.Length > 0)
					yield return slice;
				chars = chars.Slice(index + 1);
			}
			if ((options & StringSplitOptions.TrimEntries) == StringSplitOptions.TrimEntries)
				chars = chars.Trim();
			if ((options & StringSplitOptions.RemoveEmptyEntries) == 0 || chars.Length > 0)
				yield return chars;
		}
	}

	public static class ListExtensions
	{
        public static int BinarySearch<TValue, TKey>(this TValue [] list, TKey key, Func<TValue, TKey, int> comparer)
        {
            if (list == null || comparer == null)
                throw new ArgumentNullException();
            int low = 0;
            int high = list.Length - 1;
            while (low <= high)
            {
                var mid = low + ((high - low) >> 1);
                var order = comparer(list[mid], key);
                if (order == 0)
                    return mid;
                else if (order > 0)
                    high = mid - 1;
                else
                    low = mid + 1;
            }
            return ~low;
        }
		
		public static int BinarySearchFirst<TValue, TKey>(this TValue [] list, TKey key, Func<TValue, TKey, int> comparer)
		{
            int index = list.BinarySearch(key, comparer);
            for (; index > 0 && comparer(list[index-1], key) == 0; index--)
                ;
            return index;
		}
	}

	public class CharMemoryComparer : IEqualityComparer<ReadOnlyMemory<char>>
	{
		public static CharMemoryComparer OrdinalIgnoreCase { get; } = new CharMemoryComparer(StringComparison.OrdinalIgnoreCase);
		public static CharMemoryComparer Ordinal { get; }  = new CharMemoryComparer(StringComparison.Ordinal);
	
		readonly StringComparison comparison;
		CharMemoryComparer(StringComparison comparison) => this.comparison = comparison;
        public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y) => MemoryExtensions.Equals(x.Span, y.Span, comparison);
        public int GetHashCode(ReadOnlyMemory<char> obj) => String.GetHashCode(obj.Span, comparison);
	}

	/********************************************************/

	public enum EnumMemberExample {
		Trick, 
		Treat, 
		[EnumMember(Value = "Trick-Or-Treat")] // Error: Attribute 'JsonPropertyName' is not valid on this declaration type. It is only valid on 'property, indexer' declarations.
		TrickOrTreat
	}

	[Flags]
    enum FlagLongEnum : long
    {
        PZero = ((long)1 << 0),
        POne = ((long)1 << 1),
        PTwo = ((long)1 << 2),
        PSeven = ((long)1 << 7),
        PFourteen = ((long)1 << 14),
        PThirtyOne = ((long)1 << 31),
        PThirtyTwo = ((long)1 << 32),
        PSixtyTwo = ((long)1 << 62),
        PSixtyThree = ((long)1 << 63),
    };

	[Flags]
	public enum FlaggedWithCompositeShort : short
	{
		Zero = 0,
		One = (1<<0),
		Two = (1<<1),
		Three = One | Two,
		Four = (1<<2),
		Eight = (1<<3),
		All = One | Two | Four | Eight,
	}

	public class TestClass
	{
		public void ConfigureServices(IServiceCollection services)
		{
			services.AddControllers(options =>
									{
										options.ModelBinderProviders.Insert(0, new EnumMemberModelBinderProvider(options));
									});
		}		
		public static void Test()
		{
			TestEnumTypeConverter();
		}
		
		static void TestEnumTypeConverter()
		{
			TestEnumTypeConverter<FlagLongEnum>("1,4");
			TestEnumTypeConverter<FlaggedWithCompositeShort>("1,31000");
			TestEnumTypeConverter<FlaggedWithCompositeShort>("1,-31000");
			TestEnumTypeConverter<FlaggedWithCompositeShort>("Zero");
			TestEnumTypeConverter<FlaggedWithCompositeShort>("One,Two,Four,8");
		}

		static void TestEnumTypeConverter<TEnum>(string value) where TEnum: struct, Enum
		{
			var typeConverter = TypeDescriptor.GetConverter(typeof(TEnum));
			
			var model = (TEnum)typeConverter.ConvertFrom(value: value,
                    context: null,
                    culture: CultureInfo.InvariantCulture)!;
			
			Console.WriteLine("Input: {0}, Result: {1}, IsDefined: {2}", value, model, IsDefinedInEnum(model, typeof(TEnum)));
		}
		
		private static bool IsDefinedInEnum(object model, Type modelType)
		{
			//https://github.com/dotnet/aspnetcore/blob/c85baf8db0c72ae8e68643029d514b2e737c9fae/src/Mvc/Mvc.Core/src/ModelBinding/Binders/EnumTypeModelBinder.cs#L58
			
			// Check if the converted value is indeed defined on the enum as EnumTypeConverter
			// converts value to the backing type (ex: integer) and does not check if the value is defined on the enum.
			if (Attribute.IsDefined(modelType, typeof(FlagsAttribute)))
			{
				// Enum.IsDefined does not work with combined flag enum values.
				// From EnumDataTypeAttribute.cs in CoreFX.
				// Examples:
				//
				// [Flags]
				// enum FlagsEnum { Value1 = 1, Value2 = 2, Value4 = 4 }
				//
				// Valid Scenarios:
				// 1. valueProviderResult="Value2,Value4", model=Value2 | Value4, underlying=6, converted=Value2, Value4
				// 2. valueProviderResult="2,4", model=Value2 | Value4, underlying=6, converted=Value2, Value4
				//
				// Invalid Scenarios:
				// 1. valueProviderResult="2,10", model=12, underlying=12, converted=12
				//
				var underlying = Convert.ChangeType(
					model,
					Enum.GetUnderlyingType(modelType),
					CultureInfo.InvariantCulture).ToString();
				var converted = model.ToString();
				return !string.Equals(underlying, converted, StringComparison.OrdinalIgnoreCase);
			}
			return Enum.IsDefined(modelType, model);
		}
	}

	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Environment version: {0} ({1}), {2}, 64bit = {3}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion, Environment.Is64BitOperatingSystem);
			Console.WriteLine();

			try
			{
				TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Failed with unhandled exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}

​x
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Reflection;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Diagnostics;
using System.Runtime.Serialization;
​
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.Text.Json;
​
//https://stackoverflow.com/questions/72886747/deserialize-enums-using-the-enummember-value-in-aspnet-fromquery-model-binding
​
#nullable enable
​
    // Begin code for enum model binding
​
    public class EnumMemberModelBinderProvider : RenamableEnumModelBinderProvider
    {
        public EnumMemberModelBinderProvider(MvcOptions options) : base(options) { }
​
        public EnumMemberModelBinderProvider(MvcOptions options, JsonNamingPolicy? namingPolicy, bool allowIntegerValues) : base(options, namingPolicy, allowIntegerValues) { }
​
        protected override bool TryOverrideName(Type enumType, string name, out ReadOnlyMemory<char> overrideName)
        {
            // You could substitute JsonPropertyNameAttribute or any other attribute with some override name here, if you prefer.
            if (EnumExtensions.TryGetEnumAttribute<System.Runtime.Serialization.EnumMemberAttribute>(enumType, name, out var attr) && attr.Value != null)
            {
                overrideName = attr.Value.AsMemory();
                return true;
            }
            return base.TryOverrideName(enumType, name, out overrideName);
        }
    }
​
    public class RenamableEnumModelBinderProvider : IModelBinderProvider
    {
        readonly JsonNamingPolicy? namingPolicy;
        readonly bool allowIntegerValues;
​
        public RenamableEnumModelBinderProvider(MvcOptions options) : this(options, null, true) { }
​
        public RenamableEnumModelBinderProvider(MvcOptions options, JsonNamingPolicy? namingPolicy, bool allowIntegerValues) => 
            (this.namingPolicy, this.allowIntegerValues) = (namingPolicy, allowIntegerValues);
​
        /// <inheritdoc />
        public IModelBinder? GetBinder(ModelBinderProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }
​
            if (context.Metadata.IsEnum)
            {
                var loggerFactory = context.Services.GetRequiredService<ILoggerFactory>();
                var binderType = typeof(RenamableEnumModelBinder<>).MakeGenericType(context.Metadata.UnderlyingOrModelType);
                TryOverrideName tryOverrideName = (Type t, string n, out ReadOnlyMemory<char> o) => TryOverrideName(t, n, out o);
                return (IModelBinder)Activator.CreateInstance(binderType,
                                                            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                                                            binder: null,
                                                            args: new object[] { loggerFactory, namingPolicy!, allowIntegerValues, tryOverrideName },
                                                            culture: null)!;
            }
            return null;
        }
        
        protected virtual bool TryOverrideName(Type enumType, string name, out ReadOnlyMemory<char> overrideName)
        {
            overrideName = default;
            return false;
        }
    }
​
    public class RenamableEnumModelBinder<TEnum> : SimpleModelBinderBase where TEnum : struct, Enum
    {
        bool AllowNumbers { get; }
        EnumTypeData<TEnum> EnumTypeData { get; }
​
        public RenamableEnumModelBinder(ILoggerFactory loggerFactory, JsonNamingPolicy? namingPolicy, bool allowNumbers, TryOverrideName? tryOverrideName) : base(loggerFactory)
        {
            this.AllowNumbers = allowNumbers;
            this.EnumTypeData = EnumTypeData<TEnum>.Create(namingPolicy, tryOverrideName);
        }
​
        protected override object? ConvertModelFromString(ModelBindingContext bindingContext, string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return null;
            TEnum result;
            if (EnumTypeData.TryLookup(value.AsMemory(), out result))
                return result;
            if (AllowNumbers && EnumExtensions.TryParseEnumFromNumber<TEnum>(value, out result))
                return result;
            throw new FormatException(string.Format("Unknown value {0} for enum {1}", value, nameof(TEnum)));
        }
    }
​
    public abstract class SimpleModelBinderBase : IModelBinder
    {
        readonly ILogger _logger;
​
        public SimpleModelBinderBase(ILoggerFactory loggerFactory) => _logger = (loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory))).CreateLogger<SimpleModelBinderBase>();
​
        /// <inheritdoc />
        public Task BindModelAsync(ModelBindingContext bindingContext)
        {
            if (bindingContext == null)
            {
                throw new ArgumentNullException(nameof(bindingContext));
            }
​
            var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            if (valueProviderResult == ValueProviderResult.None)
            {
                return Task.CompletedTask;
            }
​
            bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
​
            try
            {
                var value = valueProviderResult.FirstValue; // TODO: Check enums with spaces in their overidden names, e.g. [EnumMember("My Name")]
                object? model = ConvertModelFromString(bindingContext, value);
                CheckAndSaveModel(bindingContext, valueProviderResult, model);
                return Task.CompletedTask;
            }
            catch (Exception exception)
            {
                bindingContext.ModelState.TryAddModelError(bindingContext.ModelName, exception, bindingContext.ModelMetadata);
                // Were able to find a converter for the type but conversion failed.
                return Task.CompletedTask;
            }
        }
​
        protected abstract object? ConvertModelFromString(ModelBindingContext bindingContext, string? value);
​
        protected virtual void CheckAndSaveModel(ModelBindingContext bindingContext, ValueProviderResult valueProviderResult, object? model)
        {
            if (model == null && !bindingContext.ModelMetadata.IsReferenceOrNullableType)
            {
                bindingContext.ModelState.TryAddModelError(
                    bindingContext.ModelName,
                    bindingContext.ModelMetadata.ModelBindingMessageProvider.ValueMustNotBeNullAccessor(
                        valueProviderResult.ToString()));
            }
            else
            {
                bindingContext.Result = ModelBindingResult.Success(model);
            }
        }
    }
​
    // End code for enum model binding
​
    /********************************************************/
    // Begin general enum parsing code
​
    public static partial class EnumExtensions
    {
        public static bool TryParseEnumFromNumber<TEnum>(string s, out TEnum value) where TEnum : struct, Enum =>
            TryParseEnumFromNumber(s, Type.GetTypeCode(typeof(TEnum)), out value);
        
        internal static bool TryParseEnumFromNumber<TEnum>(string s, TypeCode enumTypeCode, out TEnum value) where TEnum : struct, Enum
        {
            Debug.Assert(enumTypeCode == Type.GetTypeCode(typeof(TEnum)));
            switch (Type.GetTypeCode(typeof(TEnum)))
            {
                case TypeCode.SByte:
                    {
                        if (SByte.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<SByte, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                case TypeCode.Int16:
                    {
                        if (Int16.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<Int16, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                case TypeCode.Int32:
                    {
                        if (Int32.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<Int32, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                case TypeCode.Int64:
                    {
                        if (Int64.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<Int64, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                case TypeCode.Byte:
                    {
                        if (Byte.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<Byte, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                case TypeCode.UInt16:
                    {
                        if (UInt16.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<UInt16, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                case TypeCode.UInt32:
                    {
                        if (UInt32.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<UInt32, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                case TypeCode.UInt64:
                    {
                        if (UInt64.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var i))
                        {
                            value = Unsafe.As<UInt64, TEnum>(ref i);
                            return true;
                        }
                    };
                    break;
                default:
                    throw new JsonException();
            }
            value = default(TEnum);
            return false;
        }
    }
​
    // Code refactored from this answer https://stackoverflow.com/a/59061296/3744182
    // By https://stackoverflow.com/users/3744182/dbc
    // To https://stackoverflow.com/questions/59059989/system-text-json-how-do-i-specify-a-custom-name-for-an-enum-value/
    // Refactored version here: https://dotnetfiddle.net/0pa6pD
​
    public delegate bool TryOverrideName(Type enumType, string name, out ReadOnlyMemory<char> overrideName);
​
    public class EnumTypeData<TEnum> where TEnum : struct, Enum
    {
        readonly record struct EnumData(ReadOnlyMemory<char> name, TEnum value, UInt64 UInt64Value);
​
        internal static TypeCode EnumTypeCode { get; } = Type.GetTypeCode(typeof(TEnum));   
        static Func<EnumData, UInt64, int> EntryComparer { get; } = (item, key) => item.UInt64Value.CompareTo(key);
        static bool Flagged { get; } = typeof(TEnum).IsDefined(typeof(FlagsAttribute), false);
​
        private EnumData [] EnumDataArray { get; }
        private ILookup<ReadOnlyMemory<char>, int> NameLookup { get; }
    
        private EnumTypeData(EnumData [] enumDataArray, ILookup<ReadOnlyMemory<char>, int> nameLookup) => 
            (this.EnumDataArray, this.NameLookup) = (enumDataArray ?? throw new ArgumentNullException(nameof(enumDataArray)), nameLookup ?? throw new ArgumentNullException(nameof(nameLookup)));
    
        public static EnumTypeData<TEnum> Create(JsonNamingPolicy? namingPolicy, TryOverrideName? tryOverrideName)
        {
            var enumData = GetEnumData(namingPolicy, tryOverrideName);
            return new EnumTypeData<TEnum>(enumData, GetLookupTable(enumData));
        }
        
        // Return data about the enum sorted by the binary values of the enumeration constants (that is, by their unsigned magnitude)
        static EnumData [] GetEnumData(JsonNamingPolicy? namingPolicy, TryOverrideName? tryOverrideName)
        {
            var names = Enum.GetNames<TEnum>();
            var values = Enum.GetValues<TEnum>();
            return names.Zip(values, (n, v) => 
                { 
                    if (tryOverrideName == null || !tryOverrideName(typeof(TEnum), n, out var jsonName))
                        jsonName = (namingPolicy == null ? n.AsMemory() : namingPolicy.ConvertName(n).AsMemory());
                    return new EnumData(jsonName, v, v.ToUInt64(EnumTypeCode));
                })
                .ToArray();
        }
​
        static int FindEnumDataIndex(EnumData [] enumData, TEnum value, out UInt64 UInt64value)
        {
            UInt64value = value.ToUInt64(EnumTypeCode);
            return enumData.BinarySearchFirst(UInt64value, EntryComparer);
        }
​
        static ILookup<ReadOnlyMemory<char>, int> GetLookupTable(EnumData [] namesAndValues) =>
            Enumerable.Range(0, namesAndValues.Length).ToLookup(i => namesAndValues[i].name, CharMemoryComparer.OrdinalIgnoreCase);
            
        public bool TryFormatAsString(TEnum value, out ReadOnlyMemory<char> name)
        {
            if (!Flagged)
                return TryFormatSimpleAsString(value, out name);
            else
                return TryFormatFlaggedAsString(value, out name);
        }
​
        bool TryFormatSimpleAsString(TEnum value, out ReadOnlyMemory<char> name)
        {
            var index = FindEnumDataIndex(EnumDataArray, value, out var _);
            if (index >= 0)
            {
                name = EnumDataArray[index].name;
                return true;
            }
            name = default;
            return false;
        }
​
        bool TryFormatFlaggedAsString(TEnum value, out ReadOnlyMemory<char> name)
        {
            var index = FindEnumDataIndex(EnumDataArray, value, out var UInt64Value);
            if (index >= 0)
            {
                // A single flag
                name = EnumDataArray[index].name;
                return true;
            }
            if (UInt64Value != 0)
            {
                StringBuilder? sb = null;
                for (int i = (~index) - 1; i >= 0; i--)
                {
                    if ((UInt64Value & EnumDataArray[i].UInt64Value) ==  EnumDataArray[i].UInt64Value && EnumDataArray[i].UInt64Value != 0)
                    {
                        if (sb == null)
                        {
                            sb = new StringBuilder();
                            sb.Append(EnumDataArray[i].name.Span);
                        }
                        else
                        {
                            sb.Insert(0, EnumExtensions.FlagSeparatorString);
                            sb.Insert(0, EnumDataArray[i].name.Span);
                        }
                        UInt64Value -= EnumDataArray[i].UInt64Value;
                    }
                }
                if (UInt64Value == 0 && sb != null)
                {
                    name = sb.ToString().AsMemory();
                    return true;
                }
            }
            name = default;
            return false;
        }
​
        public bool TryLookup(ReadOnlyMemory<char> name, out TEnum value)
        {
            if (!Flagged)
                return TryLookupSimple(name, out value);
            else
                return TryLookupFlagged(name, out value);
        }
​
        bool TryLookupSimple(ReadOnlyMemory<char> name, out TEnum value)
        {
            int i = 0;
            int firstMatch = -1;
            foreach (var index in NameLookup[name])
            {
                if (firstMatch == -1)
                    firstMatch = index;
                else 
                {
                    if (i == 1 && MemoryExtensions.Equals(EnumDataArray[firstMatch].name.Span, name.Span, StringComparison.Ordinal))
                    {
                        value = EnumDataArray[firstMatch].value;
                        return true;
                    }
                    if (MemoryExtensions.Equals(EnumDataArray[index].name.Span, name.Span, StringComparison.Ordinal))
                    {
                        value = EnumDataArray[index].value;
                        return true;
                    }
                }
                i++;
            }
            value = (firstMatch == -1 ? default : EnumDataArray[firstMatch].value);
            return firstMatch != -1;
        }
        
        bool TryLookupFlagged(ReadOnlyMemory<char> name, out TEnum value)
        {
            UInt64 UInt64Value = 0;
            foreach (var slice in name.Split(EnumExtensions.FlagSeparatorChar, StringSplitOptions.TrimEntries))
            {
                if (TryLookupSimple(slice, out var thisValue))
                    UInt64Value |= thisValue.ToUInt64();
                else
                {
                    value = default;
                    return false;
                }
            }
            value = UInt64Value.ToEnum<TEnum>(EnumTypeCode);
            return true;
        }
    }
​
    public static partial class EnumExtensions
    {
        public const char FlagSeparatorChar = ',';
        public const string FlagSeparatorString = ", ";
        
        public static bool TryGetEnumAttribute<TAttribute>(Type type, string name, [System.Diagnostics.CodeAnalysis.NotNullWhen(returnValue: true)] out TAttribute? attribute) where TAttribute : System.Attribute
        {
            var member = type.GetMember(name).SingleOrDefault();
            attribute = member?.GetCustomAttribute<TAttribute>(false);
            return attribute != null;
        }
        
        public static UInt64 ToUInt64<TEnum>(this TEnum value) where TEnum : struct, Enum => value.ToUInt64(EnumTypeData<TEnum>.EnumTypeCode);
        
        internal static UInt64 ToUInt64<TEnum>(this TEnum value, TypeCode enumTypeCode) where TEnum : struct, Enum
        {
            Debug.Assert(enumTypeCode == Type.GetTypeCode(typeof(TEnum)));
            return enumTypeCode switch
            {
                TypeCode.SByte => unchecked((ulong)Unsafe.As<TEnum, SByte>(ref value)),
                TypeCode.Int16 => unchecked((ulong)Unsafe.As<TEnum, Int16>(ref value)),
                TypeCode.Int32 => unchecked((ulong)Unsafe.As<TEnum, Int32>(ref value)),
                TypeCode.Int64 => unchecked((ulong)Unsafe.As<TEnum, Int64>(ref value)),
                TypeCode.Byte => Unsafe.As<TEnum, Byte>(ref value),
                TypeCode.UInt16 => Unsafe.As<TEnum, UInt16>(ref value),
                TypeCode.UInt32 => Unsafe.As<TEnum, UInt32>(ref value),
                TypeCode.UInt64 => Unsafe.As<TEnum, UInt64>(ref value),
                _ => throw new ArgumentException(enumTypeCode.ToString()),
            };
        }
​
        public static TEnum ToEnum<TEnum>(this UInt64 value) where TEnum : struct, Enum => value.ToEnum<TEnum>(EnumTypeData<TEnum>.EnumTypeCode);
        
        internal static TEnum ToEnum<TEnum>(this UInt64 value, TypeCode enumTypeCode) where TEnum : struct, Enum
        {
            Debug.Assert(enumTypeCode == Type.GetTypeCode(typeof(TEnum)));
            switch (enumTypeCode)
            {
                case TypeCode.SByte:
                    {
                        var i = unchecked((SByte)value);
                        return Unsafe.As<SByte, TEnum>(ref i);
                    };
                case TypeCode.Int16:
                    {
                        var i = unchecked((Int16)value);
                        return Unsafe.As<Int16, TEnum>(ref i);
                    };
                case TypeCode.Int32:
                    {
                        var i = unchecked((Int32)value);
                        return Unsafe.As<Int32, TEnum>(ref i);
                    };
                case TypeCode.Int64:
                    {
                        var i = unchecked((Int64)value);
                        return Unsafe.As<Int64, TEnum>(ref i);
                    };
                case TypeCode.Byte:
                    {
                        var i = unchecked((Byte)value);
                        return Unsafe.As<Byte, TEnum>(ref i);
                    };
                case TypeCode.UInt16:
                    {
                        var i = unchecked((UInt16)value);
                        return Unsafe.As<UInt16, TEnum>(ref i);
                    };
                case TypeCode.UInt32:
                    {
                        var i = unchecked((UInt32)value);
                        return Unsafe.As<UInt32, TEnum>(ref i);
                    };
                case TypeCode.UInt64:
                    {
                        var i = unchecked((UInt64)value);
                        return Unsafe.As<UInt64, TEnum>(ref i);
                    };
                default:
                    throw new ArgumentException(enumTypeCode.ToString());
            }
        }
    }
​
    public static class StringExtensions
    {
        public static IEnumerable<ReadOnlyMemory<char>> Split(this ReadOnlyMemory<char> chars, char separator, StringSplitOptions options = StringSplitOptions.None)
        {
            int index;
            while ((index = chars.Span.IndexOf(separator)) >= 0)
            {
                var slice = chars.Slice(0, index);
                if ((options & StringSplitOptions.TrimEntries) == StringSplitOptions.TrimEntries)
                    slice = slice.Trim();
                if ((options & StringSplitOptions.RemoveEmptyEntries) == 0 || slice.Length > 0)
                    yield return slice;
                chars = chars.Slice(index + 1);
            }
            if ((options & StringSplitOptions.TrimEntries) == StringSplitOptions.TrimEntries)
                chars = chars.Trim();
            if ((options & StringSplitOptions.RemoveEmptyEntries) == 0 || chars.Length > 0)
                yield return chars;
        }
    }
​
    public static class ListExtensions
    {
        public static int BinarySearch<TValue, TKey>(this TValue [] list, TKey key, Func<TValue, TKey, int> comparer)
        {
            if (list == null || comparer == null)
                throw new ArgumentNullException();
            int low = 0;
            int high = list.Length - 1;
            while (low <= high)
            {
                var mid = low + ((high - low) >> 1);
                var order = comparer(list[mid], key);
                if (order == 0)
                    return mid;
                else if (order > 0)
                    high = mid - 1;
                else
                    low = mid + 1;
            }
            return ~low;
        }
        
        public static int BinarySearchFirst<TValue, TKey>(this TValue [] list, TKey key, Func<TValue, TKey, int> comparer)
        {
            int index = list.BinarySearch(key, comparer);
            for (; index > 0 && comparer(list[index-1], key) == 0; index--)
                ;
            return index;
        }
    }
​
    public class CharMemoryComparer : IEqualityComparer<ReadOnlyMemory<char>>
    {
        public static CharMemoryComparer OrdinalIgnoreCase { get; } = new CharMemoryComparer(StringComparison.OrdinalIgnoreCase);
        public static CharMemoryComparer Ordinal { get; }  = new CharMemoryComparer(StringComparison.Ordinal);
    
        readonly StringComparison comparison;
        CharMemoryComparer(StringComparison comparison) => this.comparison = comparison;
        public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y) => MemoryExtensions.Equals(x.Span, y.Span, comparison);
        public int GetHashCode(ReadOnlyMemory<char> obj) => String.GetHashCode(obj.Span, comparison);
    }
​
    /********************************************************/
​
    public enum EnumMemberExample {
        Trick, 
        Treat, 
        [EnumMember(Value = "Trick-Or-Treat")] // Error: Attribute 'JsonPropertyName' is not valid on this declaration type. It is only valid on 'property, indexer' declarations.
        TrickOrTreat
    }
​
    [Flags]
    enum FlagLongEnum : long
    {
        PZero = ((long)1 << 0),
        POne = ((long)1 << 1),
        PTwo = ((long)1 << 2),
        PSeven = ((long)1 << 7),
        PFourteen = ((long)1 << 14),
        PThirtyOne = ((long)1 << 31),
        PThirtyTwo = ((long)1 << 32),
        PSixtyTwo = ((long)1 << 62),
        PSixtyThree = ((long)1 << 63),
    };
​
    [Flags]
    public enum FlaggedWithCompositeShort : short
    {
        Zero = 0,
        One = (1<<0),
        Two = (1<<1),
        Three = One | Two,
        Four = (1<<2),
        Eight = (1<<3),
        All = One | Two | Four | Eight,
    }
​
    public class TestClass
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers(options =>
                                    {
                                        options.ModelBinderProviders.Insert(0, new EnumMemberModelBinderProvider(options));
                                    });
        }       
        public static void Test()
        {
            TestEnumTypeConverter();
        }
        
        static void TestEnumTypeConverter()
        {
            TestEnumTypeConverter<FlagLongEnum>("1,4");
            TestEnumTypeConverter<FlaggedWithCompositeShort>("1,31000");
            TestEnumTypeConverter<FlaggedWithCompositeShort>("1,-31000");
            TestEnumTypeConverter<FlaggedWithCompositeShort>("Zero");
            TestEnumTypeConverter<FlaggedWithCompositeShort>("One,Two,Four,8");
        }
​
        static void TestEnumTypeConverter<TEnum>(string value) where TEnum: struct, Enum
        {
            var typeConverter = TypeDescriptor.GetConverter(typeof(TEnum));
            
            var model = (TEnum)typeConverter.ConvertFrom(value: value,
                    context: null,
                    culture: CultureInfo.InvariantCulture)!;
            
            Console.WriteLine("Input: {0}, Result: {1}, IsDefined: {2}", value, model, IsDefinedInEnum(model, typeof(TEnum)));
        }
        
        private static bool IsDefinedInEnum(object model, Type modelType)
        {
            //https://github.com/dotnet/aspnetcore/blob/c85baf8db0c72ae8e68643029d514b2e737c9fae/src/Mvc/Mvc.Core/src/ModelBinding/Binders/EnumTypeModelBinder.cs#L58
            
            // Check if the converted value is indeed defined on the enum as EnumTypeConverter
            // converts value to the backing type (ex: integer) and does not check if the value is defined on the enum.
            if (Attribute.IsDefined(modelType, typeof(FlagsAttribute)))
            {
                // Enum.IsDefined does not work with combined flag enum values.
                // From EnumDataTypeAttribute.cs in CoreFX.
                // Examples:
                //
                // [Flags]
                // enum FlagsEnum { Value1 = 1, Value2 = 2, Value4 = 4 }
                //
                // Valid Scenarios:
                // 1. valueProviderResult="Value2,Value4", model=Value2 | Value4, underlying=6, converted=Value2, Value4
                // 2. valueProviderResult="2,4", model=Value2 | Value4, underlying=6, converted=Value2, Value4
                //
                // Invalid Scenarios:
                // 1. valueProviderResult="2,10", model=12, underlying=12, converted=12
                //
                var underlying = Convert.ChangeType(
                    model,
                    Enum.GetUnderlyingType(modelType),
                    CultureInfo.InvariantCulture).ToString();
                var converted = model.ToString();
                return !string.Equals(underlying, converted, StringComparison.OrdinalIgnoreCase);
            }
            return Enum.IsDefined(modelType, model);
        }
    }
​
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Environment version: {0} ({1}), {2}, 64bit = {3}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion, Environment.Is64BitOperatingSystem);
            Console.WriteLine();
​
            try
            {
                TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with unhandled exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
    }
​

Compilation error (line 17, col 0): 'InputBox' is not declared. It may be inaccessible due to its protection level.
Compilation error (line 21, col 0): 'MsgBox' is not declared. It may be inaccessible due to its protection level.
Compilation error (line 21, col 0): 'vbCrLf' is not declared. It may be inaccessible due to its protection level.

Last Run:	9:19:59 pm
Compile:	0s
Execute:	0.211s
Memory:	0b
CPU:	0s

View IL Code