Add API support for multiple schema extension definitions

src/NJsonSchema.Tests/Serialization/ExtensionDataTests.cs

@@ -99,6 +99,64 @@ public async Task When_extension_data_attribute_is_used_on_class_then_extension_
             Assert.Equal(123, schema.ExtensionData["MyClass"]);
         }
 
+        [Fact]
+        public async Task When_multi_extension_data_attribute_is_used_on_class_then_extension_data_property_is_set()
+        {
+            //// Arrange
+
+            //// Act
+            var schema = JsonSchema.FromType<MyMultiTest>();
+
+            //// Assert
+            Assert.Equal("myname", schema.ExtensionData["x-name"]);
+            Assert.Equal("red", schema.ExtensionData["x-color"]);
+        }
+
+        /// <summary>
+        /// Adds multiple extension data properties to a class or property.</summary>
+        /// <seealso cref="System.Attribute" />
+        [AttributeUsage(
+            AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue,
+            AllowMultiple = true)]
+        public class MultiJsonSchemaExtensionDataAttribute : Attribute, IMultiJsonSchemaExtensionDataAttribute
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="MultiJsonSchemaExtensionDataAttribute" /> class.</summary>
+            /// <param name="kvps">The key value pairs.</param>
+            public MultiJsonSchemaExtensionDataAttribute(string name, string color)
+            {
+                SchemaExtensionData = new Dictionary<string, object>
+                {
+                  {"x-name", name},
+                  {"x-color", color}
+                };
+            }
+
+            /// <summary>
+            /// Gets the extension data properties dictionary.
+            /// </summary>
+            public IDictionary<string, object> SchemaExtensionData { get; }
+        }
+        [MultiJsonSchemaExtensionData("myname", "red")]
+        public class MyMultiTest
+        {
+          [MultiJsonSchemaExtensionData("prop", "blue")]
+          public string Property { get; set; }
+        }
+
+        [Fact]
+        public async Task When_multi_extension_data_attribute_is_used_on_property_then_extension_data_property_is_set()
+        {
+          //// Arrange
+
+          //// Act
+          var schema = JsonSchema.FromType<MyMultiTest>();
+
+          //// Assert
+          Assert.Equal("prop", schema.Properties["Property"].ExtensionData["x-name"]);
+          Assert.Equal("blue", schema.Properties["Property"].ExtensionData["x-color"]);
+        }
+
         [Fact]
         public async Task When_extension_data_attribute_is_used_on_property_then_extension_data_property_is_set()
         {

src/NJsonSchema/Annotations/IMultiJsonSchemaExtensionDataAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace NJsonSchema.Annotations
+{
+    /// <summary>Interface to add multiple extension data property to a class or property, implementation needs to inherit from System.Attribute.</summary>
+    public interface IMultiJsonSchemaExtensionDataAttribute
+    {
+        /// <summary>Gets the extension data properties dictionary.</summary>
+        IDictionary<string, object> SchemaExtensionData { get; }
+    }
+}

src/NJsonSchema/Generation/JsonSchemaGenerator.cs

@@ -1409,16 +1409,26 @@ private void ApplyRangeAttribute(JsonSchema schema, IEnumerable<Attribute> paren
         private void ApplyTypeExtensionDataAttributes<TSchemaType>(TSchemaType schema, ContextualType contextualType) where TSchemaType : JsonSchema, new()
         {
             var extensionAttributes = contextualType.OriginalType.GetTypeInfo().GetCustomAttributes()
-                .Where(attribute => attribute is IJsonSchemaExtensionDataAttribute).ToArray();
+                .Where(attribute => attribute is IJsonSchemaExtensionDataAttribute 
+                                 || attribute is IMultiJsonSchemaExtensionDataAttribute).ToArray();
 
             if (extensionAttributes.Any())
             {
                 var extensionData = new Dictionary<string, object>();
 
                 foreach (var attribute in extensionAttributes)
                 {
-                    var extensionAttribute = (IJsonSchemaExtensionDataAttribute)attribute;
-                    extensionData.Add(extensionAttribute.Key, extensionAttribute.Value);
+                    if (attribute is IJsonSchemaExtensionDataAttribute singleExt)
+                    {
+                        extensionData.Add(singleExt.Key, singleExt.Value);
+                    }
+                    else if (attribute is IMultiJsonSchemaExtensionDataAttribute multiExt)
+                    {
+                        foreach (var kvp in multiExt.SchemaExtensionData)
+                        {
+                            extensionData.Add(kvp.Key, kvp.Value);
+                        }
+                    }
                 }
 
                 schema.ExtensionData = extensionData;
@@ -1435,6 +1445,25 @@ private void ApplyPropertyExtensionDataAttributes(ContextualAccessorInfo accesso
             {
                 propertySchema.ExtensionData = extensionDataAttributes.ToDictionary(a => a.Key, a => a.Value);
             }
+
+            var multiExtensionDataAttributes = accessorInfo
+                .GetContextAttributes<IMultiJsonSchemaExtensionDataAttribute>()
+                .ToArray();
+
+            if (multiExtensionDataAttributes.Any())
+            {
+                if (propertySchema.ExtensionData == null)
+                {
+                    propertySchema.ExtensionData = new Dictionary<string, object>();
+                }
+                foreach (var multiExt in multiExtensionDataAttributes)
+                {
+                    foreach (var kvp in multiExt.SchemaExtensionData)
+                    {
+                        propertySchema.ExtensionData.Add(kvp.Key, kvp.Value);
+                    }
+                }
+            }
         }
     }
 }