Port 'WindowsRuntimeBufferExtensions' to 'WinRT.Runtime.dll' (#2298)

* Convert Buffer property to Buffer() method

Change WindowsRuntimePinnedArrayBuffer.Buffer from an internal property getter to a public unsafe Buffer() method (inlined) and update call sites. Also make GetArraySegment public, add an XML <returns> doc and AggressiveInlining, and remove a redundant Debug.Assert for Capacity. Update ABI and WindowsRuntimeBufferMarshal usages to call Buffer(). These changes expose the buffer access method and unify callers to the new signature.

* Add WindowsRuntimeExternalArrayBuffer for external arrays

Introduce WindowsRuntimeExternalArrayBuffer, an internal sealed implementation of IBuffer that wraps an external byte[] with support for offset, length and capacity. Provides Buffer() and GetArraySegment() APIs and a Length setter that enforces capacity (throws E_BOUNDS). Implements a pinning strategy using PinnedGCHandle and caches the pinned data pointer with Interlocked.CompareExchange to be thread-safe, and disposes the pinned handle in a finalizer. Includes debug assertions for constructor parameters and is marked as a managed-only WinRT type.

* Add WindowsRuntimeExternalArrayBuffer marshaller

Introduce ABI support and a custom marshaller for WindowsRuntimeExternalArrayBuffer. Adds TypeMapAssociation, a file-scoped ABI type, and a fixed set of ComInterfaceEntry vtables (IBuffer, IBufferByteAccess, IStringable, IWeakReferenceSource, IMarshal, IAgileObject, IInspectable, IUnknown). Implements a WindowsRuntimeComWrappersMarshallerAttribute that provides vtable computation and GetOrCreateComInterfaceForObject behavior, and a native IBufferByteAccess implementation with an unmanaged Buffer method that returns the underlying byte pointer and converts exceptions to HRESULTs.

* Support WindowsRuntimeExternalArrayBuffer cases

Add handling for the WindowsRuntimeExternalArrayBuffer type in WindowsRuntimeBufferMarshal to extract underlying memory and array segments. Introduces early-return branches that call Buffer()/GetArraySegment() on external array buffers and adds clarifying comments; existing pinned-array handling remains unchanged.

* Flatten Windows.Storage.Streams paths

Remove an extra 'Streams' nesting by relocating several Windows.Storage.Streams files into the Windows.Storage/Streams folder. This cleans up the directory layout to better match namespaces and simplify imports.

Files moved:
- Windows.Storage.Streams/Buffers/WindowsRuntimeBuffer.cs (from ...Streams/Buffers/...)
- Windows.Storage/Streams/IBuffer.cs (from ...Streams/Streams/...)
- Windows.Storage/Streams/IInputStream.cs (from ...Streams/Streams/...)
- Windows.Storage/Streams/IOutputStream.cs (from ...Streams/Streams/...)
- Windows.Storage/Streams/IRandomAccessStream.cs (from ...Streams/Streams/...)
- Windows.Storage/Streams/InputStreamOptions.cs (from ...Streams/Streams/...)

* Use ThrowIfBufferLengthExceedsCapacity helper

Replace the manual bounds check and construction of ArgumentOutOfRangeException in the Length setter with ArgumentOutOfRangeException.ThrowIfBufferLengthExceedsCapacity(value, Capacity). This centralizes validation, simplifies the code, and ensures consistent exception details (including HResult) when the buffer length exceeds capacity.

* Add GetSpan to external and pinned buffers

Introduce ReadOnlySpan<byte> GetSpan() implementations for WindowsRuntimePinnedArrayBuffer and WindowsRuntimeExternalArrayBuffer. Both methods use MemoryMarshal.GetArrayDataReference and Unsafe.Add to create a ReadOnlySpan via MemoryMarshal.CreateReadOnlySpan and are annotated with AggressiveInlining. The pinned variant notes that parameters were validated at construction so offset/capacity checks are skipped; the external variant references the same rationale to avoid extra overhead while providing efficient span access to the buffer data.

* Rename GetSpan to GetSpanForCapacity

Rename WindowsRuntimePinnedArrayBuffer.GetSpan to GetSpanForCapacity to make the semantics explicit: the returned ReadOnlySpan<byte> covers Capacity (not Length). Update WindowsRuntimeExternalArrayBuffer XML doc cref to point to the new member and add a remark documenting the capacity-based length. Method inlining and implementation remain unchanged.

* Add IBuffer AsBuffer extensions for byte[]

Introduce WindowsRuntimeBufferExtensions with three AsBuffer overloads for byte[]: AsBuffer(source), AsBuffer(source, offset, length) and AsBuffer(source, offset, length, capacity). The methods validate arguments and return a WindowsRuntimeExternalArrayBuffer that exposes the byte array as an IBuffer with specified length and capacity. Includes MIT header and preserved commented exception message checks for range/capacity validation.

* Use Span for buffer capacity and add CopyTo

Change ReadOnlySpan<byte> -> Span<byte> for GetSpanForCapacity in WindowsRuntimeExternalArrayBuffer and WindowsRuntimePinnedArrayBuffer to allow mutable access and use MemoryMarshal.CreateSpan. Add a new Argument_InvalidIBufferInstance message. Extend WindowsRuntimeBufferExtensions: adjust AsBuffer overloads to use named args, add CopyTo(ReadOnlySpan<byte>, IBuffer[, uint]) methods to efficiently copy into IBuffer (with GC.KeepAlive and Length update semantics), and add a private GetSpanForCapacity(IBuffer) helper that retrieves a Span<byte> for native, external-array, or pinned-array backed buffers and throws the new argument exception for unsupported IBuffer instances. Also add a few using directives required by the new code.

* Add byte[] CopyTo overloads and improve docs

Refine XML docs for ReadOnlySpan<byte>.CopyTo overloads (singular "value" wording) and add missing <exception> tags documenting ArgumentNullException, ArgumentException and ArgumentOutOfRangeException cases. Introduce two new byte[] CopyTo overloads: CopyTo(byte[] source, IBuffer destination) and CopyTo(byte[] source, int sourceIndex, IBuffer destination, uint destinationIndex, int count). Both delegate to the existing ReadOnlySpan<byte> implementations (using AsSpan) and perform null checks before calling into the span-based logic.

* Add IBuffer-to-Span CopyTo overloads

Add two CopyTo overloads to copy from IBuffer to Span<byte> (full-buffer and ranged variants). Implement argument checks, early-return for zero-length copies, use GetSpanForCapacity(...).Slice for span slicing and call GC.KeepAlive(source) after the copy. Also replace a range-based span slice with explicit Slice, add a pragma to suppress IDE0057, and update XML docs and exception wording to better describe destination capacity requirements.

* Add byte[] overloads for IBuffer.CopyTo

Add two convenience overloads for copying IBuffer contents to byte arrays: CopyTo(this IBuffer, byte[]) and CopyTo(this IBuffer, uint sourceIndex, byte[] destination, int destinationIndex, int count). Both perform null checks and forward to the existing Span-based CopyTo implementation. Also update the XML summary on the Span-based CopyTo to correctly reference Span<T>. These changes make it easier for callers using arrays to copy buffer data without manually creating spans.

* Add IBuffer CopyTo overloads and safety checks

Add two IBuffer.CopyTo overloads to copy entire buffers or a specified range between IBuffer instances, including XML docs. Introduce System.Diagnostics and Debug.Assert checks for int.MaxValue bounds, early-return for zero-length copies, Span-based copy logic, GC.KeepAlive calls, and update destination.Length after copy. Also add Debug.Assert guards in existing copy helpers and argument null checks to improve safety and correctness.

* Add IBuffer.ToArray extension methods

Introduce two ToArray extension overloads for IBuffer: a parameterless variant that copies the entire buffer and an overload that accepts a sourceIndex and count. Both perform null/argument validation, handle a zero-length fast path (returning an empty array), allocate an uninitialized byte[] via GC.AllocateUninitializedArray, and copy data using the buffer's CopyTo method. Some additional range checks (Array.MaxLength and capacity/remaining-space checks) are present but commented out.

* Add IsSameData and TryGetSpan helpers

Introduce IsSameData(IBuffer, IBuffer?) to detect whether two IBuffer instances share the same underlying memory (handles both managed and native-backed buffers). Add TryGetNativeSpanForCapacity and TryGetManagedSpanForCapacity to safely obtain Span<byte> for a buffer's Capacity without throwing/pinning, and refactor GetSpanForCapacity to use these helpers. Document potential exceptions for IBufferByteAccess.Buffer failures on various CopyTo/ToArray APIs and add necessary using/imports and attributes. These changes avoid unnecessary pinning, centralize native/managed span retrieval, and improve diagnostics when interacting with IBuffer internals.

* Add IBuffer.GetByte extension method

Introduce GetByte(this IBuffer, uint) to WindowsRuntimeBufferExtensions with XML docs. The method validates the source is not null, obtains a Span<byte> via GetSpanForCapacity, reads the byte at the specified offset, and calls GC.KeepAlive to ensure the buffer remains alive. Provides a convenient, safe way to read a single byte from an IBuffer instance.

* Add IBuffer-backed MemoryStream wrapper

Introduce WindowsRuntimeBufferMemoryStream, an internal sealed MemoryStream implementation backed by a Windows.Storage.Streams.IBuffer. The stream constructor accepts an IBuffer, a backing byte[] and an offset and initializes the stream length from the buffer. Overrides SetLength, Write (sync and span), WriteAsync (task and ValueTask) and WriteByte to keep the IBuffer.Length in sync with the stream. This supports managed-to-WinRT buffer interop without parameter validation in the constructor.

* Add UnmanagedMemoryStream backed by IBuffer

Introduce WindowsRuntimeBufferUnmanagedMemoryStream: an UnmanagedMemoryStream implementation backed by a native IBuffer. The new class exposes a constructor accepting an IBuffer and native byte* memory, overrides SetLength and various Write APIs (sync/async/Span/byte) to keep the IBuffer.Length in sync, and uses FileAccess.ReadWrite. Also add a private _buffer field (with comment) to WindowsRuntimeBufferMemoryStream.cs. Note: the UnmanagedMemoryStream constructor does not validate parameters and uses unsafe pointer input.

* Add GetArray and IBuffer AsStream helpers

Expose underlying array accessors on WindowsRuntimeExternalArrayBuffer and WindowsRuntimePinnedArrayBuffer (GetArray(out int offset)), and add MemoryStream <-> IBuffer helpers in WindowsRuntimeBufferExtensions: GetWindowsRuntimeBuffer overloads to create IBuffer from MemoryStream, and AsStream to wrap an IBuffer as a Stream (handles array-backed and native buffers). Also add System.IO using and fix inverted logic in GetSpanForCapacity to correctly throw for invalid IBuffer instances. These changes enable sharing memory between MemoryStream and IBuffer and provide a convenient Stream view over IBuffer data.

* Use exception helpers for buffer checks

Add a set of ArgumentException/ArgumentOutOfRange/UnauthorizedAccess helpers to WindowsRuntimeExceptionExtensions and corresponding message constants to WindowsRuntimeExceptionMessages. Replace in-file commented/manual validation checks in WindowsRuntimeBufferExtensions with calls to the new ThrowIf* helpers (e.g. ThrowIfInsufficientArrayElementsAfterOffset, ThrowIfInsufficientBufferCapacity, ThrowIfBufferIndexExceedsCapacity/Length, ThrowIfInsufficientSpaceInSourceBuffer/TargetBuffer, ThrowIfStreamPositionBeyondEndOfStream, ThrowIfBufferLengthExceedsArrayMaxLength, ThrowInvalidIBufferInstance, ThrowInternalBufferAccess). Helpers are annotated for inlining/stack-trace hiding and centralize error text creation for clearer, consistent validation and minor performance improvements.

* Remove WindowsRuntimeBuffer and related files

Delete WinRT buffer implementation and helpers for Windows.Storage.Streams (IBufferByteAccess.cs, IMarshal.cs, IMemoryBufferByteAccess.cs, WindowsRuntimeBuffer.cs, WindowsRuntimeBufferExtensions.cs) and remove their entries from src/cswinrt/cswinrt.vcxproj and cswinrt.vcxproj.filters. Cleans up deprecated/unneeded buffer wrapper code and project file references.

* Fix typo

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Fix typos

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Use BufferOffset exception message and add constant

Replace the incorrect Argument_BufferIndexExceedsLength usage with a new Argument_BufferOffsetExceedsLength in WindowsRuntimeExceptionExtensions to provide a more accurate error for offset checks. Add the corresponding constant message to WindowsRuntimeExceptionMessages.

* Refactor IBuffer unwrap and access helpers

Introduce clearer managed/native unwrapping helpers and simplify buffer logic. Adds TryGetArray and TryGetData to handle managed arrays (array + offset) and native pointers respectively, replaces span-based helpers, and updates equality, span retrieval and stream creation paths to use the new helpers. GetSpanForCapacity now prefers managed arrays, then native data, and throws for unrecognized buffers. Also removes the now-unused ThrowInvalidIBufferInstance helper from WindowsRuntimeExceptionExtensions.cs. These changes reduce low-level unsafe span usage, centralize native access, and make equality/stream logic rely on array/offset or raw pointers.

* Remove unused usings in buffer extensions

Remove unused using directives System.Runtime.CompilerServices and System.Runtime.InteropServices from WindowsRuntimeBufferExtensions.cs to clean up imports. No functional changes; reduces compiler warnings for unused namespaces.

* Add Windows Buffers using; remove attribute

Remove the special-case emission of the TypeMapAssociation assembly attribute from src/cswinrt/main.cpp. Add using Windows.Storage.Buffers and tidy up using directives in StreamOperationsImplementation.cs, WinRtIOHelper.cs and WinRtToNetFxStreamAdapter.cs (also adjust placement of System.Diagnostics.CodeAnalysis). These changes prepare the additions to use Windows.Storage.Buffers types and stop emitting the assembly-level TypeMapAssociation here.

* Remove unused WindowsRuntime usings

Remove the unused System.Runtime.InteropServices.WindowsRuntime using directives from WinRtIOHelper.cs and WinRtToNetFxStreamAdapter.cs. This is a tidy-up to eliminate redundant imports (and related compiler warnings); no functional changes.

* Stub WindowsRuntimeBuffer handling with TODOs

Replace direct WindowsRuntimeBuffer cast and TryGetUnderlyingData usage with null/placeholder assignments and TODO comments in StreamOperationsImplementation.cs. This temporarily disables the optimized managed-array path (the buffer.TryGetUnderlyingData branch) and keeps the generic allocation fallback intact. Restore the original cast and TryGetUnderlyingData calls later to recover the optimized behavior.

* Remove WindowsRuntime using; add Buffers namespace

Remove obsolete System.Runtime.InteropServices.WindowsRuntime using directives from multiple test files and add using Windows.Storage.Buffers where needed. Affected files: FunctionalTests/Async/Program.cs, ObjectLifetimeTests/{App,MainWindow,MyControl,ObjectLifetimePage}.xaml.cs, UnitTest/ApiCompatTests.cs, and UnitTest/TestComponentCSharp_Tests.cs. This updates imports to use Windows.Storage.Buffers for buffer-related types and cleans up unnecessary WindowsRuntime interop using statements.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: Sergio0694

src/Tests/FunctionalTests/Async/Program.cs

@@ -1,11 +1,11 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
-using System.Runtime.InteropServices.WindowsRuntime;
 using System.Threading.Tasks;
 using TestComponentCSharp;
 using Windows.Foundation;
 using Windows.Foundation.Tasks;
+using Windows.Storage.Buffers;
 using Windows.Storage.Streams;
 using Windows.Web.Http;
 using WindowsRuntime.InteropServices;

src/Tests/ObjectLifetimeTests/App.xaml.cs

@@ -10,7 +10,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
 using Windows.ApplicationModel;
 using Windows.ApplicationModel.Activation;
 using Windows.Foundation;

src/Tests/ObjectLifetimeTests/MainWindow.xaml.cs

@@ -9,7 +9,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
 using Windows.Foundation;
 using Windows.Foundation.Collections;
 

src/Tests/ObjectLifetimeTests/MyControl.xaml.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
 using Windows.Foundation;
 using Windows.Foundation.Collections;
 using Microsoft.UI.Xaml;

src/Tests/ObjectLifetimeTests/ObjectLifetimePage.xaml.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
 using Windows.Foundation;
 using Windows.Foundation.Collections;
 using Microsoft.UI.Xaml;

src/Tests/UnitTest/ApiCompatTests.cs

@@ -21,11 +21,11 @@
 using Windows.Data.Json;
 
 using Windows.Storage;
+using Windows.Storage.Buffers;
 using Windows.Storage.Streams;
 using Windows.Storage.FileProperties;
 
 using System.Diagnostics;
-using System.Runtime.InteropServices.WindowsRuntime;
 
 namespace UnitTest
 {

src/Tests/UnitTest/TestComponentCSharp_Tests.cs

@@ -13,7 +13,6 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.Marshalling;
-using System.Runtime.InteropServices.WindowsRuntime;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -36,6 +35,7 @@
 using Windows.Security.Cryptography;
 using Windows.Security.Cryptography.Core;
 using Windows.Storage;
+using Windows.Storage.Buffers;
 using Windows.Storage.Streams;
 using Windows.UI;
 using Windows.UI.Notifications;

src/WinRT.Runtime2/ABI/WindowsRuntime.InteropServices/Buffers/WindowsRuntimeExternalArrayBuffer.cs

@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using WindowsRuntime;
+using WindowsRuntime.InteropServices;
+using WindowsRuntime.InteropServices.Marshalling;
+using static System.Runtime.InteropServices.ComWrappers;
+
+#pragma warning disable CS0723, IDE0008, IDE0046, IDE1006
+
+[assembly: TypeMapAssociation<WindowsRuntimeComWrappersTypeMapGroup>(
+    source: typeof(WindowsRuntimeExternalArrayBuffer),
+    proxy: typeof(ABI.WindowsRuntime.InteropServices.WindowsRuntimeExternalArrayBuffer))]
+
+namespace ABI.WindowsRuntime.InteropServices;
+
+/// <summary>
+/// ABI type for <see cref="WindowsRuntimeExternalArrayBuffer"/>.
+/// </summary>
+[WindowsRuntimeClassName("Windows.Storage.Streams.IBuffer")]
+[WindowsRuntimeExternalArrayBufferComWrappersMarshaller]
+file static class WindowsRuntimeExternalArrayBuffer;
+
+/// <summary>
+/// The set of <see cref="ComInterfaceEntry"/> values for <see cref="WindowsRuntimeExternalArrayBuffer"/>.
+/// </summary>
+file struct WindowsRuntimeExternalArrayBufferInterfaceEntries
+{
+    public ComInterfaceEntry IBuffer;
+    public ComInterfaceEntry IBufferByteAccess;
+    public ComInterfaceEntry IStringable;
+    public ComInterfaceEntry IWeakReferenceSource;
+    public ComInterfaceEntry IMarshal;
+    public ComInterfaceEntry IAgileObject;
+    public ComInterfaceEntry IInspectable;
+    public ComInterfaceEntry IUnknown;
+}
+
+/// <summary>
+/// The implementation of <see cref="WindowsRuntimeExternalArrayBufferInterfaceEntries"/>.
+/// </summary>
+file static class WindowsRuntimeExternalArrayBufferInterfaceEntriesImpl
+{
+    /// <summary>
+    /// The <see cref="WindowsRuntimeExternalArrayBufferInterfaceEntries"/> value for <see cref="WindowsRuntimeExternalArrayBuffer"/>.
+    /// </summary>
+    [FixedAddressValueType]
+    public static readonly WindowsRuntimeExternalArrayBufferInterfaceEntries Entries;
+
+    /// <summary>
+    /// Initializes <see cref="Entries"/>.
+    /// </summary>
+    static WindowsRuntimeExternalArrayBufferInterfaceEntriesImpl()
+    {
+        Entries.IBuffer.IID = WellKnownWindowsInterfaceIIDs.IID_IBuffer;
+        Entries.IBuffer.Vtable = Windows.Storage.Streams.IBufferImpl.Vtable;
+        Entries.IBufferByteAccess.IID = WellKnownWindowsInterfaceIIDs.IID_IBufferByteAccess;
+        Entries.IBufferByteAccess.Vtable = WindowsRuntimeExternalArrayBufferByteAccessImpl.Vtable;
+        Entries.IStringable.IID = WellKnownWindowsInterfaceIIDs.IID_IStringable;
+        Entries.IStringable.Vtable = IStringableImpl.Vtable;
+        Entries.IWeakReferenceSource.IID = WellKnownWindowsInterfaceIIDs.IID_IWeakReferenceSource;
+        Entries.IWeakReferenceSource.Vtable = IWeakReferenceSourceImpl.Vtable;
+        Entries.IMarshal.IID = WellKnownWindowsInterfaceIIDs.IID_IMarshal;
+        Entries.IMarshal.Vtable = IMarshalImpl.RoBufferVtable;
+        Entries.IAgileObject.IID = WellKnownWindowsInterfaceIIDs.IID_IAgileObject;
+        Entries.IAgileObject.Vtable = IAgileObjectImpl.Vtable;
+        Entries.IInspectable.IID = WellKnownWindowsInterfaceIIDs.IID_IInspectable;
+        Entries.IInspectable.Vtable = IInspectableImpl.Vtable;
+        Entries.IUnknown.IID = WellKnownWindowsInterfaceIIDs.IID_IUnknown;
+        Entries.IUnknown.Vtable = IUnknownImpl.Vtable;
+    }
+}
+
+/// <summary>
+/// A custom <see cref="WindowsRuntimeComWrappersMarshallerAttribute"/> implementation for <see cref="WindowsRuntimeExternalArrayBuffer"/>.
+/// </summary>
+[Obsolete(WindowsRuntimeConstants.PrivateImplementationDetailObsoleteMessage,
+    DiagnosticId = WindowsRuntimeConstants.PrivateImplementationDetailObsoleteDiagnosticId,
+    UrlFormat = WindowsRuntimeConstants.CsWinRTDiagnosticsUrlFormat)]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public sealed unsafe class WindowsRuntimeExternalArrayBufferComWrappersMarshallerAttribute : WindowsRuntimeComWrappersMarshallerAttribute
+{
+    /// <inheritdoc/>
+    public override void* GetOrCreateComInterfaceForObject(object value)
+    {
+        // No reference tracking is needed, see notes in the marshaller attribute for 'WindowsRuntimePinnedArrayBuffer'
+        return (void*)WindowsRuntimeComWrappers.Default.GetOrCreateComInterfaceForObject(value, CreateComInterfaceFlags.None);
+    }
+
+    /// <inheritdoc/>
+    public override ComInterfaceEntry* ComputeVtables(out int count)
+    {
+        count = sizeof(WindowsRuntimeExternalArrayBufferInterfaceEntries) / sizeof(ComInterfaceEntry);
+
+        return (ComInterfaceEntry*)Unsafe.AsPointer(in WindowsRuntimeExternalArrayBufferInterfaceEntriesImpl.Entries);
+    }
+}
+
+/// <summary>
+/// The native implementation of <c>IBufferByteAccess</c> for <see cref="WindowsRuntimeExternalArrayBuffer"/>.
+/// </summary>
+file static unsafe class WindowsRuntimeExternalArrayBufferByteAccessImpl
+{
+    /// <summary>
+    /// The <see cref="IBufferByteAccessVftbl"/> value for the <see cref="WindowsRuntimeExternalArrayBuffer"/> implementation.
+    /// </summary>
+    [FixedAddressValueType]
+    private static readonly IBufferByteAccessVftbl Vftbl;
+
+    /// <summary>
+    /// Initializes <see cref="Vftbl"/>.
+    /// </summary>
+    static WindowsRuntimeExternalArrayBufferByteAccessImpl()
+    {
+        *(IInspectableVftbl*)Unsafe.AsPointer(ref Vftbl) = *(IInspectableVftbl*)IInspectableImpl.Vtable;
+
+        Vftbl.Buffer = &Buffer;
+    }
+
+    /// <summary>
+    /// Gets a pointer to the <see cref="WindowsRuntimeExternalArrayBuffer"/> implementation.
+    /// </summary>
+    public static nint Vtable
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => (nint)Unsafe.AsPointer(in Vftbl);
+    }
+
+    /// <see href="https://learn.microsoft.com/windows/win32/api/robuffer/nf-robuffer-ibufferbyteaccess-buffer"/>
+    [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
+    private static HRESULT Buffer(void* thisPtr, byte** value)
+    {
+        if (value is null)
+        {
+            return WellKnownErrorCodes.E_POINTER;
+        }
+
+        try
+        {
+            var thisObject = ComInterfaceDispatch.GetInstance<global::WindowsRuntime.InteropServices.WindowsRuntimeExternalArrayBuffer>((ComInterfaceDispatch*)thisPtr);
+
+            *value = thisObject.Buffer();
+
+            return WellKnownErrorCodes.S_OK;
+        }
+        catch (Exception ex)
+        {
+            return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(ex);
+        }
+    }
+}

src/WinRT.Runtime2/ABI/WindowsRuntime.InteropServices/Buffers/WindowsRuntimePinnedArrayBuffer.cs

@@ -145,7 +145,7 @@ private static HRESULT Buffer(void* thisPtr, byte** value)
         {
             var thisObject = ComInterfaceDispatch.GetInstance<global::WindowsRuntime.InteropServices.WindowsRuntimePinnedArrayBuffer>((ComInterfaceDispatch*)thisPtr);
 
-            *value = thisObject.Buffer;
+            *value = thisObject.Buffer();
 
             return WellKnownErrorCodes.S_OK;
         }

src/WinRT.Runtime2/InteropServices/Buffers/MemoryStreams/WindowsRuntimeBufferMemoryStream.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Windows.Storage.Streams;
+
+namespace WindowsRuntime.InteropServices;
+
+/// <summary>
+/// A <see cref="MemoryStream"/> implementation backed by a managed <see cref="IBuffer"/> instance.
+/// </summary>
+internal sealed class WindowsRuntimeBufferMemoryStream : MemoryStream
+{
+    /// <summary>
+    /// The <see cref="IBuffer"/> instance to back the stream.
+    /// </summary>
+    private readonly IBuffer _buffer;
+
+    /// <summary>
+    /// Creates a new <see cref="WindowsRuntimeBufferMemoryStream"/> instance with the specified parameters.
+    /// </summary>
+    /// <param name="buffer">The <see cref="IBuffer"/> instance to back the stream.</param>
+    /// <param name="array">The byte array to use as the underlying storage.</param>
+    /// <param name="offset">The offset in the byte array where the stream starts.</param>
+    /// <remarks>This constructor doesn't validate any of its parameters.</remarks>
+    public WindowsRuntimeBufferMemoryStream(IBuffer buffer, byte[] array, int offset)
+        : base(array, offset, (int)buffer.Capacity, writable: true)
+    {
+        _buffer = buffer;
+
+        SetLength(buffer.Length);
+    }
+
+    /// <inheritdoc/>
+    public override void SetLength(long value)
+    {
+        base.SetLength(value);
+
+        // The input value is limited by 'Capacity', so this cast is safe
+        _buffer.Length = (uint)Length;
+    }
+
+    /// <inheritdoc/>
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        base.Write(buffer, offset, count);
+
+        _buffer.Length = (uint)Length;
+    }
+
+    /// <inheritdoc/>
+    public override void Write(ReadOnlySpan<byte> buffer)
+    {
+        base.Write(buffer);
+
+        _buffer.Length = (uint)Length;
+    }
+
+    /// <inheritdoc/>
+    public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+    {
+        await base.WriteAsync(buffer, offset, count, cancellationToken);
+
+        _buffer.Length = (uint)Length;
+    }
+
+    /// <inheritdoc/>
+    public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+    {
+        await base.WriteAsync(buffer, cancellationToken);
+
+        _buffer.Length = (uint)Length;
+    }
+
+    /// <inheritdoc/>
+    public override void WriteByte(byte value)
+    {
+        base.WriteByte(value);
+
+        _buffer.Length = (uint)Length;
+    }
+}