Support EnumMember for schema enum serialization

Schema.NET.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.0.31423.177
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31515.178
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Source", "Source", "{719809C2-A551-4C4A-9EFD-B10FB5E35BC0}"
 	ProjectSection(SolutionItems) = preProject
@@ -106,6 +106,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Common", "Common", "{AF228B
 		Source\Common\JsonLdObject.cs = Source\Common\JsonLdObject.cs
 		Source\Common\OneOrMany{T}.cs = Source\Common\OneOrMany{T}.cs
 		Source\Common\PropertyValueSpecification.Partial.cs = Source\Common\PropertyValueSpecification.Partial.cs
+		Source\Common\SchemaEnumJsonConverter{T}.cs = Source\Common\SchemaEnumJsonConverter{T}.cs
 		Source\Common\SchemaSerializer.cs = Source\Common\SchemaSerializer.cs
 		Source\Common\Thing.Partial.cs = Source\Common\Thing.Partial.cs
 		Source\Common\TimeSpanToISO8601DurationValuesJsonConverter.cs = Source\Common\TimeSpanToISO8601DurationValuesJsonConverter.cs

Source/Common/EnumHelper.cs

@@ -1,13 +1,19 @@
 namespace Schema.NET
 {
     using System;
+    using System.Diagnostics;
     using System.Diagnostics.CodeAnalysis;
 
     /// <summary>
     /// Helper for parsing strings into Enum values.
     /// </summary>
     internal static class EnumHelper
     {
+        private const string HttpSchemaOrgUrl = "http://schema.org/";
+        private const int HttpSchemaOrgLength = 18; // equivalent to "http://schema.org/".Length
+        private const string HttpsSchemaOrgUrl = "https://schema.org/";
+        private const int HttpsSchemaOrgLength = 19; // equivalent to "https://schema.org/".Length
+
         /// <summary>
         /// Converts the string representation of the name or numeric value of one or more
         /// enumerated constants to an equivalent enumerated object.
@@ -43,5 +49,49 @@ public static bool TryParse(
 #pragma warning restore IDE0022 // Use expression body for methods
 #endif
         }
+
+        /// <summary>
+        /// Converts the Schema URI representation of the enum type to an equivalent enumerated object.
+        /// </summary>
+        /// <param name="enumType">The enum type to use for parsing.</param>
+        /// <param name="value">The string representation of the name or numeric value of one or more enumerated constants.</param>
+        /// <param name="result">When this method returns true, an object containing an enumeration constant representing the parsed value.</param>
+        /// <returns><see langword="true"/> if the conversion succeeded; <see langword="false"/> otherwise.</returns>
+        public static bool TryParseEnumFromSchemaUri(
+            Type enumType,
+#if NETCOREAPP3_1_OR_GREATER
+            [NotNullWhen(true)]
+#endif
+            string? value,
+            out object? result)
+        {
+            string? enumString;
+            if (value is not null && value.StartsWith(HttpSchemaOrgUrl, StringComparison.OrdinalIgnoreCase))
+            {
+#pragma warning disable IDE0057 // Use range operator. Need to multi-target.
+                enumString = value.Substring(HttpSchemaOrgLength);
+#pragma warning restore IDE0057 // Use range operator. Need to multi-target.
+            }
+            else if (value is not null && value.StartsWith(HttpsSchemaOrgUrl, StringComparison.OrdinalIgnoreCase))
+            {
+#pragma warning disable IDE0057 // Use range operator. Need to multi-target.
+                enumString = value.Substring(HttpsSchemaOrgLength);
+#pragma warning restore IDE0057 // Use range operator. Need to multi-target.
+            }
+            else
+            {
+                enumString = value;
+            }
+
+            if (TryParse(enumType, enumString, out result))
+            {
+                return true;
+            }
+            else
+            {
+                Debug.WriteLine($"Unable to parse enumeration of type {enumType.FullName} with value {enumString}.");
+                return false;
+            }
+        }
     }
 }

Source/Common/SchemaEnumJsonConverter{T}.cs

@@ -0,0 +1,61 @@
+namespace Schema.NET
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using System.Runtime.Serialization;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+
+    /// <summary>
+    /// Converts a Schema enumeration to and from JSON.
+    /// </summary>
+    /// <typeparam name="T">The enum type to convert</typeparam>
+    public class SchemaEnumJsonConverter<T> : JsonConverter<T>
+        where T : struct, Enum
+    {
+        private readonly Dictionary<T, string> valueNameMap = new();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SchemaEnumJsonConverter{T}"/> class.
+        /// </summary>
+        public SchemaEnumJsonConverter()
+        {
+            var enumType = typeof(T);
+            var values = Enum.GetValues(enumType);
+
+            foreach (var value in values)
+            {
+                var enumMember = enumType.GetMember(value!.ToString()!)[0];
+                var enumMemberAttribute = enumMember.GetCustomAttribute<EnumMemberAttribute>(false);
+                this.valueNameMap[(T)value] = enumMemberAttribute!.Value!;
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the enumeration.
+        /// </summary>
+        /// <param name="reader">The <see cref="Utf8JsonReader"/> to read from.</param>
+        /// <param name="typeToConvert">Type of the enumeration.</param>
+        /// <param name="options">The serializer options.</param>
+        /// <returns>The enumeration value.</returns>
+        public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            var valueString = reader.GetString();
+            if (EnumHelper.TryParseEnumFromSchemaUri(typeToConvert, valueString, out var result))
+            {
+                return (T)(result!);
+            }
+
+            return default;
+        }
+
+        /// <summary>
+        /// Writes the specified enumeration using the JSON writer.
+        /// </summary>
+        /// <param name="writer">The JSON writer.</param>
+        /// <param name="value">The enumeration value.</param>
+        /// <param name="options">The JSON serializer options.</param>
+        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) => writer.WriteStringValue(this.valueNameMap[value]);
+    }
+}

Source/Common/SchemaSerializer.cs

@@ -28,22 +28,18 @@ public static class SchemaSerializer
         static SchemaSerializer()
 #pragma warning restore CA1810 // Initialize reference type static fields inline
         {
-            var stringEnumConverter = new JsonStringEnumConverter();
-
             DefaultSerializationSettings = new JsonSerializerOptions
             {
                 AllowTrailingCommas = true,
                 DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault,
                 Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
             };
-            DefaultSerializationSettings.Converters.Add(stringEnumConverter);
 
             HtmlEscapedSerializationSettings = new JsonSerializerOptions
             {
                 AllowTrailingCommas = true,
                 DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault,
             };
-            HtmlEscapedSerializationSettings.Converters.Add(stringEnumConverter);
         }
 
         /// <summary>

Source/Common/ValuesJsonConverter.cs

@@ -16,11 +16,6 @@ namespace Schema.NET
     /// <seealso cref="JsonConverter" />
     public class ValuesJsonConverter : JsonConverter<IValues>
     {
-        private const string HttpSchemaOrgUrl = "http://schema.org/";
-        private const int HttpSchemaOrgLength = 18; // equivalent to "http://schema.org/".Length
-        private const string HttpsSchemaOrgUrl = "https://schema.org/";
-        private const int HttpsSchemaOrgLength = 19; // equivalent to "https://schema.org/".Length
-
         private static readonly Dictionary<string, Type> BuiltInThingTypeLookup = new(StringComparer.Ordinal);
 
         static ValuesJsonConverter()
@@ -299,35 +294,9 @@ private static bool TryProcessTokenAsType(ref Utf8JsonReader reader, Type target
                     success = decimal.TryParse(valueString, NumberStyles.Float, CultureInfo.InvariantCulture, out var localResult);
                     result = localResult;
                 }
-                else if (targetType.GetTypeInfo().IsEnum)
+                else if (targetType.IsEnum)
                 {
-                    string? enumString;
-                    if (valueString is not null && valueString.StartsWith(HttpSchemaOrgUrl, StringComparison.OrdinalIgnoreCase))
-                    {
-#pragma warning disable IDE0057 // Use range operator. Need to multi-target.
-                        enumString = valueString.Substring(HttpSchemaOrgLength);
-#pragma warning restore IDE0057 // Use range operator. Need to multi-target.
-                    }
-                    else if (valueString is not null && valueString.StartsWith(HttpsSchemaOrgUrl, StringComparison.OrdinalIgnoreCase))
-                    {
-#pragma warning disable IDE0057 // Use range operator. Need to multi-target.
-                        enumString = valueString.Substring(HttpsSchemaOrgLength);
-#pragma warning restore IDE0057 // Use range operator. Need to multi-target.
-                    }
-                    else
-                    {
-                        enumString = valueString;
-                    }
-
-                    if (EnumHelper.TryParse(targetType, enumString, out result))
-                    {
-                        success = true;
-                    }
-                    else
-                    {
-                        Debug.WriteLine($"Unable to parse enumeration of type {targetType.FullName} with value {enumString}.");
-                        success = false;
-                    }
+                    success = EnumHelper.TryParseEnumFromSchemaUri(targetType, valueString, out result);
                 }
                 else if (targetType == typeof(DateTime))
                 {

Tools/Schema.NET.Tool/SchemaSourceGenerator.cs

@@ -248,7 +248,7 @@ private static string RenderEnumeration(GeneratorSchemaEnumeration schemaEnumera
     /// <summary>
     /// {SourceUtility.RenderDoc(4, schemaEnumeration.Description)}
     /// </summary>
-    [JsonConverter(typeof(JsonStringEnumConverter))]
+    [JsonConverter(typeof(SchemaEnumJsonConverter<{schemaEnumeration.Name}>))]
     public enum {schemaEnumeration.Name}
     {{{SourceUtility.RenderItems(schemaEnumeration.Values, value => $@"
         /// <summary>