diff --git a/docs/fundamentals/code-analysis/quality-rules/ca1844.md b/docs/fundamentals/code-analysis/quality-rules/ca1844.md
index 78d3c92d748ee..18a2db2c18c03 100644
--- a/docs/fundamentals/code-analysis/quality-rules/ca1844.md
+++ b/docs/fundamentals/code-analysis/quality-rules/ca1844.md
@@ -40,6 +40,10 @@ In order to realize these performance benefits, types that derive from <xref:Sys
 
 The easiest way to fix violations is to rewrite your array-based implementation as a memory-based implementation, and then implement the array-based methods in terms of the memory-based methods.
 
+## Example
+
+:::code language="csharp" source="snippets/csharp/all-rules/ca1844.cs" id="snippet1":::
+
 ## When to suppress warnings
 
 It's safe to suppress a warning from this rule if any of the following situations apply:
diff --git a/docs/fundamentals/code-analysis/quality-rules/snippets/csharp/all-rules/ca1844.cs b/docs/fundamentals/code-analysis/quality-rules/snippets/csharp/all-rules/ca1844.cs
new file mode 100644
index 0000000000000..05c319d2ad414
--- /dev/null
+++ b/docs/fundamentals/code-analysis/quality-rules/snippets/csharp/all-rules/ca1844.cs
@@ -0,0 +1,86 @@
+namespace ca1844
+{
+    //<snippet1>
+    // This class violates the rule.
+    public class BadStream : Stream
+    {
+        private readonly Stream _innerStream;
+
+        public BadStream(Stream innerStream)
+        {
+            _innerStream = innerStream;
+        }
+
+        public override bool CanRead => _innerStream.CanRead;
+        public override bool CanSeek => _innerStream.CanSeek;
+        public override bool CanWrite => _innerStream.CanWrite;
+        public override long Length => _innerStream.Length;
+        public override long Position { get => _innerStream.Position; set => _innerStream.Position = value; }
+
+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            // ...
+            return await _innerStream.ReadAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            // ...
+            await _innerStream.WriteAsync(buffer, offset, count, cancellationToken);
+        }
+
+        // Other required overrides
+        public override void Flush() => _innerStream.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => _innerStream.Read(buffer, offset, count);
+        public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
+        public override void SetLength(long value) => _innerStream.SetLength(value);
+        public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
+    }
+
+    // This class satisfies the rule.
+    public class GoodStream : Stream
+    {
+        private readonly Stream _innerStream;
+
+        public GoodStream(Stream innerStream)
+        {
+            _innerStream = innerStream;
+        }
+
+        public override bool CanRead => _innerStream.CanRead;
+        public override bool CanSeek => _innerStream.CanSeek;
+        public override bool CanWrite => _innerStream.CanWrite;
+        public override long Length => _innerStream.Length;
+        public override long Position { get => _innerStream.Position; set => _innerStream.Position = value; }
+
+        public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            // ...
+            return await _innerStream.ReadAsync(buffer, cancellationToken);
+        }
+
+        public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            // ...
+            await _innerStream.WriteAsync(buffer, cancellationToken);
+        }
+
+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return await this.ReadAsync(buffer.AsMemory(offset, count), cancellationToken);
+        }
+
+        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            await this.WriteAsync(buffer.AsMemory(offset, count), cancellationToken);
+        }
+
+        // Other required overrides
+        public override void Flush() => _innerStream.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => _innerStream.Read(buffer, offset, count);
+        public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
+        public override void SetLength(long value) => _innerStream.SetLength(value);
+        public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
+    }
+    //</snippet1>
+}