Span, Memory, and Buffer Pooling

A span does not own storage. It can view an array, stack allocation, string characters, or unmanaged memory, and slicing creates another view. Because a span may point at stack memory, the compiler prevents it from escaping to the heap or crossing an await boundary.

Advanced C# work improves when you separate language syntax, runtime behavior, and application policy. Write down which layer owns the guarantee in this lesson. Then identify the observable evidence—a compiler rejection, test result, generated query, trace, or measurement—that would prove the model correct.

Memory<T> can be stored and passed through asynchronous APIs, while Span<T> is obtained briefly for synchronous processing. APIs should return how much of a buffer contains valid data; capacity is not content length. ReadOnlySpan<T> communicates non-mutating intent.

The starter isolates one part of the mental model so it can run in the browser. The exercise moves the same rule into a current local .NET project where packages, framework hosting, diagnostics, and multi-file tests are available.

using System;

class Program
{
  static int SumRange(int[] values, int start, int count)
  {
      int total = 0;
      for (int i = start; i < start + count; i++) total += values[i];
      return total;
  }

  static void Main()
  {
      int[] values = { 4, 8, 15, 16, 23, 42 };
      Console.WriteLine(SumRange(values, 1, 3));
  }
}

39

A rented ArrayPool buffer may be larger than requested and can contain previous data. Process only the valid range, clear sensitive elements when returning, and return exactly once in a finally block. Pooling tiny or infrequent buffers often adds complexity without benefit.

Classify each failure as a contract violation, transient operational failure, permanent dependency response, concurrency conflict, or programmer defect. That classification determines whether to reject, retry, compensate, cancel, or fail fast. A generic catch-and-continue policy destroys the information needed to make that decision.

Benchmark the original allocating version against the span-based version with realistic payload sizes. Document ownership at every boundary: who supplied storage, which slice is valid, and whether the callee may retain it.

Finish by making the result operable. Add structured diagnostics at the boundary, propagate cancellation, avoid sensitive data, and record SDK and dependency versions. Test the public behavior instead of private implementation details. If a framework or provider performs translation, serialization, concurrency, or I/O, include at least one test against the real production technology.

A senior-level review should be able to answer four questions: what contract is promised, who owns lifetime and cleanup, how failures become visible, and what evidence supports the design. If any answer depends on “the framework probably handles it,” inspect the documentation or runtime behavior and turn the assumption into a checked decision.