I have an enum extension that allows for enums to be transformed into their [Description] value, as in:
private enum WithDescription
{
[Description("Nothing")] None = 0,
[Description("Some of it")] Some,
[Description("All of it")] All
}
public static class EnumExtensions
{
public static string GetDescription<T>(this T enumerationValue) where T : struct, Enum
{
var type = enumerationValue.GetType();
if (!type.IsEnum)
{
throw new ArgumentException($"{nameof(T)} must be of type Enum.");
}
var memberInfo = type.GetMember(enumerationValue.ToString());
if (memberInfo.Length > 0)
{
var attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs.Length > 0)
{
return ((DescriptionAttribute) attrs[0]).Description;
}
}
return enumerationValue.ToString();
}
public static T GetEnumByDescription<T>(this string text) where T : struct, Enum
{
var type = typeof(T);
if (!type.IsEnum)
{
throw new ArgumentException($"{nameof(T)} must be of type Enum.");
}
MemberInfo[] members = type.GetMembers(BindingFlags.Public | BindingFlags.Static);
foreach (MemberInfo member in members)
{
var attrs = member.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs.Length > 0)
{
for (int i = 0; i < attrs.Length; i++)
{
string description = ((DescriptionAttribute) attrs[i]).Description;
if (text.Equals(description, StringComparison.OrdinalIgnoreCase))
{
return (T) Enum.Parse(type, member.Name, true);
}
}
}
if (member.Name.Equals(text, StringComparison.OrdinalIgnoreCase))
{
return (T) Enum.Parse(type, member.Name, true);
}
}
return default;
}
public static IEnumerable<string> GetDescriptions<T>() where T : struct, Enum
{
MemberInfo[] members = typeof(T).GetMembers(BindingFlags.Public | BindingFlags.Static);
foreach (MemberInfo member in members)
{
var attrs = member.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs.Length > 0)
{
for (int i = 0; i < attrs.Length; i++)
{
string description = ((DescriptionAttribute) attrs[i]).Description;
yield return description;
}
}
else
{
yield return member.Name;
}
}
}
}
And, I have a custom System.Text.Json converter:
public class EnumDescriptionConverterFactory : JsonConverterFactory
{
public override bool CanConvert(Type typeToConvert) => typeToConvert.IsEnum;
public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options) =>
(JsonConverter?) Activator.CreateInstance(
typeof(EnumConverterInner<>).MakeGenericType(new Type[] {typeToConvert}),
BindingFlags.Instance | BindingFlags.Public,
binder: null,
args: null,
culture: null);
private class EnumConverterInner<T> : JsonConverter<T> where T : struct, Enum
{
public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
string? propertyName = reader.GetString();
MemberInfo[] members = typeToConvert.GetMembers(BindingFlags.Public | BindingFlags.Static);
foreach (MemberInfo member in members)
{
var attrs = member.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs.Length > 0)
{
foreach (var t in attrs)
{
string description = ((DescriptionAttribute) t).Description;
if (propertyName?.Equals(description, StringComparison.OrdinalIgnoreCase) ?? false)
{
return (T) Enum.Parse(typeToConvert, member.Name, true);
}
}
}
if (member.Name.Equals(propertyName, StringComparison.OrdinalIgnoreCase))
{
return (T) Enum.Parse(typeToConvert, member.Name, true);
}
}
if (!Enum.TryParse(propertyName, false, out T result) &&
!Enum.TryParse(propertyName, true, out result))
{
throw new JsonException(
$"Unable to convert \"{propertyName}\" to Enum \"{typeToConvert}\".");
}
return result;
}
public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
{
Type type = value.GetType();
var memberInfo = type.GetMember(value.ToString());
if (memberInfo.Length > 0)
{
var attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs.Length > 0)
{
var description = ((DescriptionAttribute) attrs[0]).Description;
writer.WriteStringValue(options.PropertyNamingPolicy?.ConvertName(description) ?? description);
}
else
{
writer.WriteStringValue(options.PropertyNamingPolicy?.ConvertName(value.ToString()) ??
value.ToString());
}
}
}
}
This code all works perfectly in every way I could test it, but when I plug it into a netcoreapp3.1 web api application, it converts the description to all lowercase in the output. In my tests, I get "Some of it" and in actual output from an API endpoint, I get "some of it"
In my ConfigureServices I have:
services.AddControllers(options =>
options.Filters.Add(new HttpResponseExceptionFilter())).AddJsonOptions(GetJsonOptions());
and the function being called is:
private static Action<JsonOptions> GetJsonOptions()
{
return options =>
{
options.JsonSerializerOptions.IgnoreNullValues = true;
options.JsonSerializerOptions.MaxDepth = 64;
options.JsonSerializerOptions.Converters.Add(new EnumDescriptionConverterFactory());
};
}
As I wrote, I'm sure it's "working" because the transformation takes place, but the output is always lower case.
Anyone know why this might be happening or what I could do about it?
