What are `Memory<T>` and `ReadOnlyMemory<T>`, and how do they differ from spans? Explain why they can live on the heap and cross await, how .Span works, slicing, getting at the underlying array with MemoryMarshal.TryGetArray, ownership and lifetime rules, and how they appear in Stream, PipeReader and System.Text.Json APIs.

How I would answer this in an interview

Memory<T> and ReadOnlyMemory<T> represent the same kind of contiguous region as spans, but they're ordinary structs, not ref structs — so they can be stored on the heap, kept in fields, captured by lambdas and passed across await. When you need to work with the data, you get a span via .Span. I'd explain why they exist, .Span, slicing, MemoryMarshal.TryGetArray, ownership and lifetime rules, and where they appear in Stream, PipeReader and System.Text.Json.

1. Why they can live on the heap and cross await

Span<T> holds a managed pointer that may point to the stack, so it must stay on the stack. Memory<T> instead holds an object reference (an array, a string, or a MemoryManager<T>) plus an index and length — nothing that can dangle into a stack frame. So it can be:

public sealed class Message(ReadOnlyMemory<byte> body) { public ReadOnlyMemory<byte> Body { get; } = body; }  // field: OK

public async Task<int> ReadIntoAsync(Stream stream, Memory<byte> buffer, CancellationToken ct)
{
    int read = await stream.ReadAsync(buffer, ct);   // Memory<T> crosses await
    Process(buffer.Span[..read]);                    // span used synchronously
    return read;
}

2. How .Span works

memory.Span inspects the underlying object:

• T[] → span over the array segment,
• string (for ReadOnlyMemory<char>) → span over the string's chars,
• MemoryManager<T> → calls its GetSpan() (native memory, pinned buffers, custom pools).

This involves a type check and a few instructions — cheap, but not free: in loops, get the span once (var span = memory.Span;) and index the span.

3. Slicing

ReadOnlyMemory<byte> packet = buffer.AsMemory(0, length);
ReadOnlyMemory<byte> header = packet[..8];
ReadOnlyMemory<byte> payload = packet.Slice(8);

Slicing is O(1) and allocation-free (adjusts index/length), like spans.

4. Getting at the underlying array: MemoryMarshal.TryGetArray

Some older APIs need an ArraySegment<T>/array:

if (MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> segment))
    legacySocket.Send(segment.Array!, segment.Offset, segment.Count);
else
    legacySocket.Send(memory.ToArray());   // fallback copy (e.g. native memory)

TryGetArray succeeds only for array-backed memory. MemoryMarshal.TryGetString does the same for string-backed ReadOnlyMemory<char>. Never assume the backing store is an array.

5. Ownership and lifetime rules

Memory<T> doesn't own the memory — it's a view. The important questions are who owns the buffer and how long the view is valid:

• Owner (IMemoryOwner<T> from MemoryPool<T>, an ArrayPool rental, a PipeReader buffer) controls lifetime; when it's disposed/returned, every Memory<T>/Span<T> over it becomes invalid (but still "works" — reading reused or freed memory: silent corruption).
• Rules (from .NET's memory guidelines):
  • A method receiving Memory<T> borrows it for the duration of the call; it mustn't store it beyond that unless the API documents ownership transfer.
  • If you store a Memory<T>, the caller must guarantee the buffer outlives your use (or transfer ownership via IMemoryOwner<T>).
  • Whoever owns an IMemoryOwner<T> must dispose it exactly once, after all consumers are done.
• With PipeReader, the ReadOnlySequence<byte> from ReadAsync is valid only until AdvanceTo is called.

6. Where they appear in the BCL

• Stream: ReadAsync(Memory<byte>, CancellationToken) and WriteAsync(ReadOnlyMemory<byte>, CancellationToken) (returning ValueTask), the efficient async overloads.
• Sockets: Socket.ReceiveAsync(Memory<byte>, ...).
• System.IO.Pipelines: PipeWriter.GetMemory(sizeHint) returns Memory<byte> to write into, then Advance(n) and FlushAsync; PipeReader yields ReadOnlySequence<byte> (a chain of ReadOnlyMemory<byte> segments).
• System.Text.Json: JsonSerializer.Deserialize<T>(ReadOnlySpan<byte>), Utf8JsonReader over ReadOnlySequence<byte>, JsonDocument.Parse(ReadOnlyMemory<byte>) (keeps a reference to the memory, so the buffer must stay valid while the document is used).
• StringBuilder.GetChunks() yields ReadOnlyMemory<char> chunks.
• Channel<ReadOnlyMemory<byte>> for passing buffers between producers and consumers (with care for ownership).

7. A production example

A TCP gateway read frames into ArrayPool buffers and passed ReadOnlyMemory<byte> slices to a channel for async processing — but returned the buffer to the pool immediately after enqueuing. Consumers occasionally processed data from other frames (the buffer had been reused), producing corrupted messages. We changed the contract to pass IMemoryOwner<byte> (ownership transfer) through the channel; the consumer disposed it after processing. Corruption disappeared, and the ownership rule was documented on the channel's message type.