Use ReadOnlyMemory<byte> for binary data to eliminate UTF-16 transcoding

samples/EverythingServer/Resources/SimpleResourceType.cs

@@ -1,6 +1,7 @@
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using System.ComponentModel;
+using System.Text;
 
 namespace EverythingServer.Resources;
 
@@ -31,7 +32,7 @@ public static ResourceContents TemplateResource(RequestContext<ReadResourceReque
             } :
             new BlobResourceContents
             {
-                Blob = resource.Description!,
+                Blob = Encoding.UTF8.GetBytes(resource.Description!),
                 MimeType = resource.MimeType,
                 Uri = resource.Uri,
             };

samples/EverythingServer/Tools/AnnotatedMessageTool.cs

@@ -1,6 +1,7 @@
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using System.ComponentModel;
+using System.Text;
 
 namespace EverythingServer.Tools;
 
@@ -41,7 +42,7 @@ public static IEnumerable<ContentBlock> AnnotatedMessage(MessageType messageType
         {
             contents.Add(new ImageContentBlock
             {
-                Data = TinyImageTool.MCP_TINY_IMAGE.Split(",").Last(),
+                Data = Encoding.UTF8.GetBytes(TinyImageTool.MCP_TINY_IMAGE.Split(",").Last()),
                 MimeType = "image/png",
                 Annotations = new() { Audience = [Role.User], Priority = 0.5f }
             });

src/Common/Polyfills/System/Text/EncodingExtensions.cs

@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#if !NET
+
+namespace System.Text;
+
+internal static class EncodingExtensions
+{
+    /// <summary>
+    /// Gets the number of bytes required to encode the specified characters.
+    /// </summary>
+    public static int GetByteCount(this Encoding encoding, ReadOnlySpan<char> chars)
+    {
+        if (chars.IsEmpty)
+        {
+            return 0;
+        }
+
+        unsafe
+        {
+            fixed (char* charsPtr = chars)
+            {
+                return encoding.GetByteCount(charsPtr, chars.Length);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Encodes the specified characters into the specified byte span.
+    /// </summary>
+    public static int GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, Span<byte> bytes)
+    {
+        if (chars.IsEmpty)
+        {
+            return 0;
+        }
+
+        unsafe
+        {
+            fixed (char* charsPtr = chars)
+            fixed (byte* bytesPtr = bytes)
+            {
+                return encoding.GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length);
+            }
+        }
+    }
+}
+
+#endif

src/ModelContextProtocol.Core/AIContentExtensions.cs

@@ -1,9 +1,7 @@
 using Microsoft.Extensions.AI;
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol;
-#if !NET
-using System.Runtime.InteropServices;
-#endif
+using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 
@@ -281,9 +279,9 @@ public static IList<PromptMessage> ToPromptMessages(this ChatMessage chatMessage
         {
             TextContentBlock textContent => new TextContent(textContent.Text),
 
-            ImageContentBlock imageContent => new DataContent(Convert.FromBase64String(imageContent.Data), imageContent.MimeType),
+            ImageContentBlock imageContent => new DataContent(imageContent.DecodedData, imageContent.MimeType),
 
-            AudioContentBlock audioContent => new DataContent(Convert.FromBase64String(audioContent.Data), audioContent.MimeType),
+            AudioContentBlock audioContent => new DataContent(audioContent.DecodedData, audioContent.MimeType),
 
             EmbeddedResourceBlock resourceContent => resourceContent.Resource.ToAIContent(),
 
@@ -324,7 +322,7 @@ public static AIContent ToAIContent(this ResourceContents content)
 
         AIContent ac = content switch
         {
-            BlobResourceContents blobResource => new DataContent(Convert.FromBase64String(blobResource.Blob), blobResource.MimeType ?? "application/octet-stream"),
+            BlobResourceContents blobResource => new DataContent(blobResource.DecodedData, blobResource.MimeType ?? "application/octet-stream"),
             TextResourceContents textResource => new TextContent(textResource.Text),
             _ => throw new NotSupportedException($"Resource type '{content.GetType().Name}' is not supported.")
         };
@@ -401,21 +399,21 @@ public static ContentBlock ToContentBlock(this AIContent content, JsonSerializer
 
             DataContent dataContent when dataContent.HasTopLevelMediaType("image") => new ImageContentBlock
             {
-                Data = dataContent.Base64Data.ToString(),
+                Data = GetUtf8Bytes(dataContent.Base64Data.Span),
                 MimeType = dataContent.MediaType,
             },
 
             DataContent dataContent when dataContent.HasTopLevelMediaType("audio") => new AudioContentBlock
             {
-                Data = dataContent.Base64Data.ToString(),
+                Data = GetUtf8Bytes(dataContent.Base64Data.Span),
                 MimeType = dataContent.MediaType,
             },
 
             DataContent dataContent => new EmbeddedResourceBlock
             {
                 Resource = new BlobResourceContents
                 {
-                    Blob = dataContent.Base64Data.ToString(),
+                    Blob = GetUtf8Bytes(dataContent.Base64Data.Span),
                     MimeType = dataContent.MediaType,
                     Uri = string.Empty,
                 }
@@ -448,6 +446,14 @@ public static ContentBlock ToContentBlock(this AIContent content, JsonSerializer
         contentBlock.Meta = content.AdditionalProperties?.ToJsonObject(options);
 
         return contentBlock;
+
+        static byte[] GetUtf8Bytes(ReadOnlySpan<char> utf16)
+        {
+            // Get UTF-8 bytes from UTF-16 chars without intermediate string allocations
+            byte[] bytes = new byte[Encoding.UTF8.GetByteCount(utf16)];
+            Encoding.UTF8.GetBytes(utf16, bytes);
+            return bytes;
+        }
     }
 
     private sealed class ToolAIFunctionDeclaration(Tool tool) : AIFunctionDeclaration

src/ModelContextProtocol.Core/Protocol/BlobResourceContents.cs

@@ -1,4 +1,7 @@
+using System.Buffers;
+using System.Buffers.Text;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using System.Text.Json.Serialization;
 
 namespace ModelContextProtocol.Protocol;
@@ -9,8 +12,8 @@ namespace ModelContextProtocol.Protocol;
 /// <remarks>
 /// <para>
 /// <see cref="BlobResourceContents"/> is used when binary data needs to be exchanged through
-/// the Model Context Protocol. The binary data is represented as a base64-encoded string
-/// in the <see cref="Blob"/> property.
+/// the Model Context Protocol. The binary data is represented as base64-encoded UTF-8 bytes
+/// in the <see cref="Blob"/> property, providing a zero-copy representation of the wire payload.
 /// </para>
 /// <para>
 /// This class inherits from <see cref="ResourceContents"/>, which also has a sibling implementation
@@ -24,18 +27,102 @@ namespace ModelContextProtocol.Protocol;
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class BlobResourceContents : ResourceContents
 {
+    private ReadOnlyMemory<byte>? _decodedData;
+    private ReadOnlyMemory<byte> _blob;
+
+    /// <summary>
+    /// Creates an <see cref="BlobResourceContents"/> from raw data.
+    /// </summary>
+    /// <param name="data">The raw data.</param>
+    /// <param name="uri">The URI of the data.</param>
+    /// <param name="mimeType">The optional MIME type of the data.</param>
+    /// <returns>A new <see cref="BlobResourceContents"/> instance.</returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    public static BlobResourceContents FromData(ReadOnlyMemory<byte> data, string uri, string? mimeType = null)
+    {
+        ReadOnlyMemory<byte> blob;
+
+        // Encode directly to UTF-8 base64 bytes without string intermediate
+        int maxLength = Base64.GetMaxEncodedToUtf8Length(data.Length);
+        byte[] buffer = new byte[maxLength];
+        if (Base64.EncodeToUtf8(data.Span, buffer, out _, out int bytesWritten) == OperationStatus.Done)
+        {
+            Debug.Assert(bytesWritten == buffer.Length, "Base64 encoding should always produce exact length for non-padded input");
+            blob = buffer.AsMemory(0, bytesWritten);
+        }
+        else
+        {
+            throw new InvalidOperationException("Failed to encode binary data to base64");
+        }
+
+        return new()
+        {
+            _decodedData = data,
+            Blob = blob,
+            MimeType = mimeType,
+            Uri = uri
+        };
+    }
+
     /// <summary>
-    /// Gets or sets the base64-encoded string representing the binary data of the item.
+    /// Gets or sets the base64-encoded UTF-8 bytes representing the binary data of the item.
     /// </summary>
+    /// <remarks>
+    /// This is a zero-copy representation of the wire payload of this item. Setting this value will invalidate any cached value of <see cref="DecodedData"/>.
+    /// </remarks>
     [JsonPropertyName("blob")]
-    public required string Blob { get; set; }
+    public required ReadOnlyMemory<byte> Blob
+    {
+        get => _blob;
+        set
+        {
+            _blob = value;
+            _decodedData = null; // Invalidate cache
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the decoded data represented by <see cref="Blob"/>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// When getting, this member will decode the value in <see cref="Blob"/> and cache the result.
+    /// Subsequent accesses return the cached value unless <see cref="Blob"/> is modified.
+    /// </para>
+    /// <para>
+    /// When setting, the binary data is stored without copying and <see cref="Blob"/> is updated
+    /// with the base64-encoded UTF-8 representation.
+    /// </para>
+    /// </remarks>
+    [JsonIgnore]
+    public ReadOnlyMemory<byte> DecodedData
+    {
+        get
+        {
+            if (_decodedData is null)
+            {
+                // Decode directly from UTF-8 base64 bytes without string intermediate
+                int maxLength = Base64.GetMaxDecodedFromUtf8Length(Blob.Length);
+                byte[] buffer = new byte[maxLength];
+                if (Base64.DecodeFromUtf8(Blob.Span, buffer, out _, out int bytesWritten) == System.Buffers.OperationStatus.Done)
+                {
+                    _decodedData = buffer.AsMemory(0, bytesWritten);
+                }
+                else
+                {
+                    throw new FormatException("Invalid base64 data");
+                }
+            }
+            return _decodedData.Value;
+        }
+    }
 
     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
     private string DebuggerDisplay
     {
         get
         {
-            string lengthDisplay = DebuggerDisplayHelper.GetBase64LengthDisplay(Blob);
+            string lengthDisplay = _decodedData is null ? DebuggerDisplayHelper.GetBase64LengthDisplay(Blob) : $"{DecodedData.Length} bytes";
             string mimeInfo = MimeType is not null ? $", MimeType = {MimeType}" : "";
             return $"Uri = \"{Uri}\"{mimeInfo}, Length = {lengthDisplay}";
         }