Support data content type inference

jskeet · jskeet · commit b1f29cf25ba6 · 2022-02-25T07:11:13.000Z
- New methods in CloudEventFormatter to support inference
- JsonEventFormatter infers a content type of application/json for non-binary data
- All transports use the inferred content type when formatting in binary mode
- Documentation for both formatters and bindings has been updated

Signed-off-by: Jon Skeet &lt;jonskeet@google.com&gt;
diff --git a/docs/bindings.md b/docs/bindings.md
@@ -169,8 +169,11 @@ The conversion should follow the following steps of pseudo-code:
 - For binary mode encoding:
   - Call `formatter.EncodeBinaryModeEventData` to encode
     the data within the CloudEvent
+  - Call `formatter.GetOrInferDataContentType` to obtain the
+    appropriate content type, which may be inferred from the
+    data if the CloudEvent itself does not specify the data content type.
   - Populate metadata in the message from the attributes in the
-    CloudEvent.
+    CloudEvent and the content type.
 - For `To...` methods, return the resulting protocol message.
   This must not be null. (`CopyTo...` messages do not return
   anything.)
diff --git a/docs/formatters.md b/docs/formatters.md
@@ -105,3 +105,18 @@ The formatter should *not* perform validation on the `CloudEvent`
 accepted in `DecodeBinaryModeEventData`, beyond asserting that the
 argument is not null. This is typically called by a protocol binding
 which should perform validation itself later.
+
+## Data content type inference
+
+Some event formats (e.g. JSON) infer the data content type from the
+actual data provided. In the C# SDK, this is implemented via the
+`CloudEventFormatter` methods `GetOrInferDataContentType` and
+`InferDataContentType`. The first of these is primarily a
+convenience method to be called by bindings; the second may be
+overridden by any formatter implementation that wishes to infer
+a data content type when one is not specified. Implementations *can*
+override `GetOrInferDataContentType` if they have unusual
+requirements, but the default implementation is usually sufficient.
+
+The base implementation of `InferDataContentType` always returns
+null; this means that no content type is inferred by default.
diff --git a/src/CloudNative.CloudEvents.Amqp/AmqpExtensions.cs b/src/CloudNative.CloudEvents.Amqp/AmqpExtensions.cs
@@ -168,7 +168,7 @@ public static Message ToAmqpMessage(this CloudEvent cloudEvent, ContentMode cont
                     break;
                 case ContentMode.Binary:
                     bodySection = new Data { Binary = BinaryDataUtilities.AsArray(formatter.EncodeBinaryModeEventData(cloudEvent)) };
-                    properties = new Properties { ContentType = cloudEvent.DataContentType };
+                    properties = new Properties { ContentType = formatter.GetOrInferDataContentType(cloudEvent) };
                     break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(contentMode), $"Unsupported content mode: {contentMode}");
diff --git a/src/CloudNative.CloudEvents.AspNetCore/HttpResponseExtensions.cs b/src/CloudNative.CloudEvents.AspNetCore/HttpResponseExtensions.cs
@@ -41,7 +41,7 @@ public static async Task CopyToHttpResponseAsync(this CloudEvent cloudEvent, Htt
                     break;
                 case ContentMode.Binary:
                     content = formatter.EncodeBinaryModeEventData(cloudEvent);
-                    contentType = MimeUtilities.CreateContentTypeOrNull(cloudEvent.DataContentType);
+                    contentType = MimeUtilities.CreateContentTypeOrNull(formatter.GetOrInferDataContentType(cloudEvent));
                     break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(contentMode), $"Unsupported content mode: {contentMode}");
diff --git a/src/CloudNative.CloudEvents.Avro/AvroEventFormatter.cs b/src/CloudNative.CloudEvents.Avro/AvroEventFormatter.cs
@@ -30,6 +30,9 @@ namespace CloudNative.CloudEvents
     /// Avro record, so the value will have the natural Avro deserialization type for that data (which may
     /// not be exactly the same as the type that was serialized).
     /// </para>
+    /// <para>
+    /// This event formatter does not infer any data content type.
+    /// </para>
     /// </remarks>
     public class AvroEventFormatter : CloudEventFormatter
     {
diff --git a/src/CloudNative.CloudEvents.Kafka/AssemblyInfo.cs b/src/CloudNative.CloudEvents.Kafka/AssemblyInfo.cs
@@ -0,0 +1,12 @@
+﻿// Copyright 2022 Cloud Native Foundation.
+// Licensed under the Apache 2.0 license.
+// See LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("CloudNative.CloudEvents.UnitTests,PublicKey="
+    + "0024000004800000940000000602000000240000525341310004000001000100e945e99352d0b8"
+    + "90ddb645995bc05ef5a22497d97e78196b9f6148ea33b0c1b219f0c28df523878d1d8c9d042a02"
+    + "f005777461dffe455b348f82b39fcbc64985ef091295c0ad2dcb265c23589e9ce8e48dbe84c8e1"
+    + "7fc37555938b2669aea7575cee288809065aa9dc04dff67ce1dfc5a3167770323c1a2c632f0eb2"
+    + "f8c64acf")]
diff --git a/src/CloudNative.CloudEvents.Kafka/KafkaExtensions.cs b/src/CloudNative.CloudEvents.Kafka/KafkaExtensions.cs
@@ -20,7 +20,8 @@ public static class KafkaExtensions
     {
         private const string KafkaHeaderPrefix = "ce_";
 
-        private const string KafkaContentTypeAttributeName = "content-type";
+        // Visible for testing
+        internal const string KafkaContentTypeAttributeName = "content-type";
         private const string SpecVersionKafkaHeader = KafkaHeaderPrefix + "specversion";
 
         /// <summary>
@@ -155,7 +156,7 @@ private static void InitPartitioningKey(Message<string?, byte[]> message, CloudE
                     break;
                 case ContentMode.Binary:
                     value = BinaryDataUtilities.AsArray(formatter.EncodeBinaryModeEventData(cloudEvent));
-                    contentTypeHeaderValue = cloudEvent.DataContentType;
+                    contentTypeHeaderValue = formatter.GetOrInferDataContentType(cloudEvent);
                     break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(contentMode), $"Unsupported content mode: {contentMode}");
diff --git a/src/CloudNative.CloudEvents.NewtonsoftJson/JsonEventFormatter.cs b/src/CloudNative.CloudEvents.NewtonsoftJson/JsonEventFormatter.cs
@@ -446,23 +446,33 @@ private void WriteCloudEventForBatchOrStructuredMode(JsonWriter writer, CloudEve
 
             if (cloudEvent.Data is object)
             {
-                if (cloudEvent.DataContentType is null)
+                if (cloudEvent.DataContentType is null && GetOrInferDataContentType(cloudEvent) is string inferredDataContentType)
                 {
+                    cloudEvent.SpecVersion.DataContentTypeAttribute.Validate(inferredDataContentType);
                     writer.WritePropertyName(cloudEvent.SpecVersion.DataContentTypeAttribute.Name);
-                    writer.WriteValue(JsonMediaType);
+                    writer.WriteValue(inferredDataContentType);
                 }
                 EncodeStructuredModeData(cloudEvent, writer);
             }
             writer.WriteEndObject();
         }
 
+        /// <summary>
+        /// Infers the data content type of a CloudEvent based on its data. This implementation
+        /// infers a data content type of "application/json" for any non-binary data, and performs
+        /// no inference for binary data.
+        /// </summary>
+        /// <param name="data">The CloudEvent to infer the data content from. Must not be null.</param>
+        /// <returns>The inferred data content type, or null if no inference is performed.</returns>
+        protected override string? InferDataContentType(object data) => data is byte[]? null : JsonMediaType;
+
         /// <summary>
         /// Encodes structured mode data within a CloudEvent, writing it to the specified <see cref="JsonWriter"/>.
         /// </summary>
         /// <remarks>
         /// <para>
         /// This implementation follows the rules listed in the class remarks. Override this method
-        /// to provide more specialized behavior, writing only <see cref="DataPropertyName"/> or
+        /// to provide more specialized behavior, usually writing only <see cref="DataPropertyName"/> or
         /// <see cref="DataBase64PropertyName"/> properties.
         /// </para>
         /// </remarks>
@@ -480,7 +490,7 @@ protected virtual void EncodeStructuredModeData(CloudEvent cloudEvent, JsonWrite
             }
             else
             {
-                ContentType dataContentType = new ContentType(cloudEvent.DataContentType ?? JsonMediaType);
+                ContentType dataContentType = new ContentType(GetOrInferDataContentType(cloudEvent));
                 if (IsJsonMediaType(dataContentType.MediaType))
                 {
                     writer.WritePropertyName(DataPropertyName);
diff --git a/src/CloudNative.CloudEvents.Protobuf/ProtobufEventFormatter.cs b/src/CloudNative.CloudEvents.Protobuf/ProtobufEventFormatter.cs
@@ -59,6 +59,9 @@ namespace CloudNative.CloudEvents.Protobuf
     /// a string, otherwise it is left as a byte array. Derived classes can specialize this behavior by overriding
     /// <see cref="DecodeBinaryModeEventData(ReadOnlyMemory{byte}, CloudEvent)"/>.
     /// </para>
+    /// <para>
+    /// This event formatter does not infer any data content type.
+    /// </para>
     /// </remarks>
     public class ProtobufEventFormatter : CloudEventFormatter
     {
diff --git a/src/CloudNative.CloudEvents.SystemTextJson/JsonEventFormatter.cs b/src/CloudNative.CloudEvents.SystemTextJson/JsonEventFormatter.cs
@@ -457,16 +457,26 @@ private void WriteCloudEventForBatchOrStructuredMode(Utf8JsonWriter writer, Clou
 
             if (cloudEvent.Data is object)
             {
-                if (cloudEvent.DataContentType is null)
+                if (cloudEvent.DataContentType is null && GetOrInferDataContentType(cloudEvent) is string inferredDataContentType)
                 {
+                    cloudEvent.SpecVersion.DataContentTypeAttribute.Validate(inferredDataContentType);
                     writer.WritePropertyName(cloudEvent.SpecVersion.DataContentTypeAttribute.Name);
-                    writer.WriteStringValue(JsonMediaType);
+                    writer.WriteStringValue(inferredDataContentType);
                 }
                 EncodeStructuredModeData(cloudEvent, writer);
             }
             writer.WriteEndObject();
         }
 
+        /// <summary>
+        /// Infers the data content type of a CloudEvent based on its data. This implementation
+        /// infers a data content type of "application/json" for any non-binary data, and performs
+        /// no inference for binary data.
+        /// </summary>
+        /// <param name="data">The CloudEvent to infer the data content from. Must not be null.</param>
+        /// <returns>The inferred data content type, or null if no inference is performed.</returns>
+        protected override string? InferDataContentType(object data) => data is byte[]? null : JsonMediaType;
+
         /// <summary>
         /// Encodes structured mode data within a CloudEvent, writing it to the specified <see cref="Utf8JsonWriter"/>.
         /// </summary>
diff --git a/src/CloudNative.CloudEvents/CloudEventFormatter.cs b/src/CloudNative.CloudEvents/CloudEventFormatter.cs
@@ -164,5 +164,41 @@ public virtual async Task<IReadOnlyList<CloudEvent>> DecodeBatchModeMessageAsync
         /// Must not be null (on return).</param>
         /// <returns>The batch representation of the CloudEvent.</returns>
         public abstract ReadOnlyMemory<byte> EncodeBatchModeMessage(IEnumerable<CloudEvent> cloudEvents, out ContentType contentType);
+
+        /// <summary>
+        /// Determines the effective data content type of the given CloudEvent.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This implementation validates that <paramref name="cloudEvent"/> is not null,
+        /// returns the existing <see cref="CloudEvent.DataContentType"/> if that's not null,
+        /// and otherwise returns null if <see cref="CloudEvent.Data"/> is null or
+        /// delegates to <see cref="InferDataContentType(object)"/> to infer the data content type
+        /// from the actual data.
+        /// </para>
+        /// <para>
+        /// Derived classes may override this if additional information is needed from the CloudEvent
+        /// in order to determine the effective data content type, but most cases can be handled by
+        /// simply overriding <see cref="InferDataContentType(object)"/>.
+        /// </para>
+        /// </remarks>
+        /// <param name="cloudEvent">The CloudEvent to get or infer the data content type from. Must not be null.</param>
+        /// <returns>The data content type of the CloudEvent, or null for no data content type.</returns>
+        public virtual string? GetOrInferDataContentType(CloudEvent cloudEvent)
+        {                     
+            Validation.CheckNotNull(cloudEvent, nameof(cloudEvent));
+            return cloudEvent.DataContentType is string dataContentType ? dataContentType
+                : cloudEvent.Data is not object data ? null
+                : InferDataContentType(data);
+        }
+
+        /// <summary>
+        /// Infers the effective data content type based on the actual data. This base implementation
+        /// always returns null, but derived classes may override this method to effectively provide
+        /// a default data content type based on the in-memory data type.
+        /// </summary>
+        /// <param name="data">The data within a CloudEvent. Should not be null.</param>
+        /// <returns>The inferred content type, or null if no content type is inferred.</returns>
+        protected virtual string? InferDataContentType(object data) => null;
     }
 }
diff --git a/src/CloudNative.CloudEvents/CloudNative.CloudEvents.csproj b/src/CloudNative.CloudEvents/CloudNative.CloudEvents.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <Description>CNCF CloudEvents SDK</Description>
-    <LangVersion>8.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <PackageTags>cloudnative;cloudevents;events</PackageTags>
   </PropertyGroup>
diff --git a/src/CloudNative.CloudEvents/Http/HttpClientExtensions.cs b/src/CloudNative.CloudEvents/Http/HttpClientExtensions.cs
@@ -273,7 +273,7 @@ public static HttpContent ToHttpContent(this CloudEvent cloudEvent, ContentMode
                     break;
                 case ContentMode.Binary:
                     content = formatter.EncodeBinaryModeEventData(cloudEvent);
-                    contentType = MimeUtilities.CreateContentTypeOrNull(cloudEvent.DataContentType);
+                    contentType = MimeUtilities.CreateContentTypeOrNull(formatter.GetOrInferDataContentType(cloudEvent));
                     break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(contentMode), $"Unsupported content mode: {contentMode}");
diff --git a/src/CloudNative.CloudEvents/Http/HttpListenerExtensions.cs b/src/CloudNative.CloudEvents/Http/HttpListenerExtensions.cs
@@ -41,7 +41,7 @@ public static async Task CopyToHttpListenerResponseAsync(this CloudEvent cloudEv
                     break;
                 case ContentMode.Binary:
                     content = formatter.EncodeBinaryModeEventData(cloudEvent);
-                    contentType = MimeUtilities.CreateContentTypeOrNull(cloudEvent.DataContentType);
+                    contentType = MimeUtilities.CreateContentTypeOrNull(formatter.GetOrInferDataContentType(cloudEvent));
                     break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(contentMode), $"Unsupported content mode: {contentMode}");
diff --git a/src/CloudNative.CloudEvents/Http/HttpWebExtensions.cs b/src/CloudNative.CloudEvents/Http/HttpWebExtensions.cs
@@ -43,7 +43,7 @@ public static async Task CopyToHttpWebRequestAsync(this CloudEvent cloudEvent, H
                     break;
                 case ContentMode.Binary:
                     content = formatter.EncodeBinaryModeEventData(cloudEvent);
-                    contentType = MimeUtilities.CreateContentTypeOrNull(cloudEvent.DataContentType);
+                    contentType = MimeUtilities.CreateContentTypeOrNull(formatter.GetOrInferDataContentType(cloudEvent));
                     break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(contentMode), $"Unsupported content mode: {contentMode}");
diff --git a/test/CloudNative.CloudEvents.UnitTests/Amqp/AmqpTest.cs b/test/CloudNative.CloudEvents.UnitTests/Amqp/AmqpTest.cs
@@ -5,6 +5,7 @@
 using Amqp;
 using Amqp.Framing;
 using CloudNative.CloudEvents.NewtonsoftJson;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Net.Mime;
 using System.Text;
@@ -18,8 +19,7 @@ public class AmqpTest
         [Fact]
         public void AmqpStructuredMessageTest()
         {
-            // the AMQPNetLite library is factored such
-            // that we don't need to do a wire test here
+            // The AMQPNetLite library is factored such that we don't need to do a wire test here.
             var cloudEvent = new CloudEvent
             {
                 Type = "com.github.pull.create",
@@ -55,9 +55,7 @@ public void AmqpStructuredMessageTest()
         [Fact]
         public void AmqpBinaryMessageTest()
         {
-            // the AMQPNetLite library is factored such
-            // that we don't need to do a wire test here
-
+            // The AMQPNetLite library is factored such that we don't need to do a wire test here.
             var cloudEvent = new CloudEvent
             {
                 Type = "com.github.pull.create",
@@ -89,6 +87,18 @@ public void AmqpBinaryMessageTest()
             Assert.Equal("value", (string?)receivedCloudEvent["comexampleextension1"]);
         }
 
+        [Fact]
+        public void BinaryMode_ContentTypeCanBeInferredByFormatter()
+        {
+            var cloudEvent = new CloudEvent
+            {
+                Data = "plain text"
+            }.PopulateRequiredAttributes();
+
+            var message = cloudEvent.ToAmqpMessage(ContentMode.Binary, new JsonEventFormatter());
+            Assert.Equal("application/json", message.Properties.ContentType);
+        }
+
         [Fact]
         public void AmqpNormalizesTimestampsToUtc()
         {
diff --git a/test/CloudNative.CloudEvents.UnitTests/AspNetCore/HttpResponseExtensionsTest.cs b/test/CloudNative.CloudEvents.UnitTests/AspNetCore/HttpResponseExtensionsTest.cs
@@ -40,19 +40,36 @@ public async Task CopyToHttpResponseAsync_BinaryMode()
             // There's no data content type header; the content type itself is used for that.
             Assert.False(response.Headers.ContainsKey("ce-datacontenttype"));
         }
-        
+
         [Fact]
-        public async Task CopyToHttpResponseAsync_ContentButNoContentType()
+        public async Task CopyToHttpResponseAsync_BinaryDataButNoDataContentType()
         {
             var cloudEvent = new CloudEvent
             {
-                Data = "plain text",
+                Data = new byte[10],
             }.PopulateRequiredAttributes();
             var formatter = new JsonEventFormatter();
             var response = CreateResponse();
+            // The formatter doesn't infer the data content type for binary data.
             await Assert.ThrowsAsync<ArgumentException>(() => cloudEvent.CopyToHttpResponseAsync(response, ContentMode.Binary, formatter));
         }
 
+        [Fact]
+        public async Task CopyToHttpResponseAsync_NonBinaryDataButNoDataContentType_ContentTypeIsInferred()
+        {
+            var cloudEvent = new CloudEvent
+            {
+                Data = "plain text",
+            }.PopulateRequiredAttributes();
+            var formatter = new JsonEventFormatter();
+            var response = CreateResponse();
+            await cloudEvent.CopyToHttpResponseAsync(response, ContentMode.Binary, formatter);
+            var content = GetContent(response);
+            // The formatter infers that it should encode the string as a JSON value (so it includes the double quotes)
+            Assert.Equal("application/json", response.ContentType);
+            Assert.Equal("\"plain text\"", Encoding.UTF8.GetString(content.Span));
+        }
+
         [Fact]
         public async Task CopyToHttpResponseAsync_BadContentMode()
         {
diff --git a/test/CloudNative.CloudEvents.UnitTests/CloudEventFormatterTest.cs b/test/CloudNative.CloudEvents.UnitTests/CloudEventFormatterTest.cs
diff --git a/test/CloudNative.CloudEvents.UnitTests/Http/HttpClientExtensionsTest.cs b/test/CloudNative.CloudEvents.UnitTests/Http/HttpClientExtensionsTest.cs
diff --git a/test/CloudNative.CloudEvents.UnitTests/Http/HttpListenerExtensionsTest.cs b/test/CloudNative.CloudEvents.UnitTests/Http/HttpListenerExtensionsTest.cs
diff --git a/test/CloudNative.CloudEvents.UnitTests/Http/HttpWebExtensionsTest.cs b/test/CloudNative.CloudEvents.UnitTests/Http/HttpWebExtensionsTest.cs
diff --git a/test/CloudNative.CloudEvents.UnitTests/Kafka/KafkaTest.cs b/test/CloudNative.CloudEvents.UnitTests/Kafka/KafkaTest.cs
diff --git a/test/CloudNative.CloudEvents.UnitTests/NewtonsoftJson/JsonEventFormatterTest.cs b/test/CloudNative.CloudEvents.UnitTests/NewtonsoftJson/JsonEventFormatterTest.cs
diff --git a/test/CloudNative.CloudEvents.UnitTests/SystemTextJson/JsonEventFormatterTest.cs b/test/CloudNative.CloudEvents.UnitTests/SystemTextJson/JsonEventFormatterTest.cs

Original file line number	Diff line number	Diff line change
`@@ -446,23 +446,33 @@ private void WriteCloudEventForBatchOrStructuredMode(JsonWriter writer, CloudEve`
`446`	`446`
`447`	`447`	`if (cloudEvent.Data is object)`
`448`	`448`	`{`
`449`		`- if (cloudEvent.DataContentType is null)`
	`449`	`+ if (cloudEvent.DataContentType is null && GetOrInferDataContentType(cloudEvent) is string inferredDataContentType)`
`450`	`450`	`{`
	`451`	`+ cloudEvent.SpecVersion.DataContentTypeAttribute.Validate(inferredDataContentType);`
`451`	`452`	`writer.WritePropertyName(cloudEvent.SpecVersion.DataContentTypeAttribute.Name);`
`452`		`- writer.WriteValue(JsonMediaType);`
	`453`	`+ writer.WriteValue(inferredDataContentType);`
`453`	`454`	`}`
`454`	`455`	`EncodeStructuredModeData(cloudEvent, writer);`
`455`	`456`	`}`
`456`	`457`	`writer.WriteEndObject();`
`457`	`458`	`}`
`458`	`459`
	`460`	`+ /// <summary>`
	`461`	`+ /// Infers the data content type of a CloudEvent based on its data. This implementation`
	`462`	`+ /// infers a data content type of "application/json" for any non-binary data, and performs`
	`463`	`+ /// no inference for binary data.`
	`464`	`+ /// </summary>`
	`465`	`+ /// <param name="data">The CloudEvent to infer the data content from. Must not be null.</param>`
	`466`	`+ /// <returns>The inferred data content type, or null if no inference is performed.</returns>`
	`467`	`+ protected override string? InferDataContentType(object data) => data is byte[]? null : JsonMediaType;`
	`468`	`+`
`459`	`469`	`/// <summary>`
`460`	`470`	`/// Encodes structured mode data within a CloudEvent, writing it to the specified <see cref="JsonWriter"/>.`
`461`	`471`	`/// </summary>`
`462`	`472`	`/// <remarks>`
`463`	`473`	`/// <para>`
`464`	`474`	`/// This implementation follows the rules listed in the class remarks. Override this method`
`465`		`- /// to provide more specialized behavior, writing only <see cref="DataPropertyName"/> or`
	`475`	`+ /// to provide more specialized behavior, usually writing only <see cref="DataPropertyName"/> or`
`466`	`476`	`/// <see cref="DataBase64PropertyName"/> properties.`
`467`	`477`	`/// </para>`
`468`	`478`	`/// </remarks>`
`@@ -480,7 +490,7 @@ protected virtual void EncodeStructuredModeData(CloudEvent cloudEvent, JsonWrite`
`480`	`490`	`}`
`481`	`491`	`else`
`482`	`492`	`{`
`483`		`- ContentType dataContentType = new ContentType(cloudEvent.DataContentType ?? JsonMediaType);`
	`493`	`+ ContentType dataContentType = new ContentType(GetOrInferDataContentType(cloudEvent));`
`484`	`494`	`if (IsJsonMediaType(dataContentType.MediaType))`
`485`	`495`	`{`
`486`	`496`	`writer.WritePropertyName(DataPropertyName);`
Original file line number	Diff line number	Diff line change
`@@ -457,16 +457,26 @@ private void WriteCloudEventForBatchOrStructuredMode(Utf8JsonWriter writer, Clou`
`457`	`457`
`458`	`458`	`if (cloudEvent.Data is object)`
`459`	`459`	`{`
`460`		`- if (cloudEvent.DataContentType is null)`
	`460`	`+ if (cloudEvent.DataContentType is null && GetOrInferDataContentType(cloudEvent) is string inferredDataContentType)`
`461`	`461`	`{`
	`462`	`+ cloudEvent.SpecVersion.DataContentTypeAttribute.Validate(inferredDataContentType);`
`462`	`463`	`writer.WritePropertyName(cloudEvent.SpecVersion.DataContentTypeAttribute.Name);`
`463`		`- writer.WriteStringValue(JsonMediaType);`
	`464`	`+ writer.WriteStringValue(inferredDataContentType);`
`464`	`465`	`}`
`465`	`466`	`EncodeStructuredModeData(cloudEvent, writer);`
`466`	`467`	`}`
`467`	`468`	`writer.WriteEndObject();`
`468`	`469`	`}`
`469`	`470`
	`471`	`+ /// <summary>`
	`472`	`+ /// Infers the data content type of a CloudEvent based on its data. This implementation`
	`473`	`+ /// infers a data content type of "application/json" for any non-binary data, and performs`
	`474`	`+ /// no inference for binary data.`
	`475`	`+ /// </summary>`
	`476`	`+ /// <param name="data">The CloudEvent to infer the data content from. Must not be null.</param>`
	`477`	`+ /// <returns>The inferred data content type, or null if no inference is performed.</returns>`
	`478`	`+ protected override string? InferDataContentType(object data) => data is byte[]? null : JsonMediaType;`
	`479`	`+`
`470`	`480`	`/// <summary>`
`471`	`481`	`/// Encodes structured mode data within a CloudEvent, writing it to the specified <see cref="Utf8JsonWriter"/>.`
`472`	`482`	`/// </summary>`