Introduction

ArraySegment<T> is a lightweight view over part of an existing array. Its main value is that it lets you work with a slice of an array without allocating and copying a new array.

What It Actually Stores

An ArraySegment<T> does not own data. It stores three things:

• a reference to the original array
• an offset into that array
• a count

That means creating a segment is cheap:

1int[] values = { 10, 20, 30, 40, 50 };
2var segment = new ArraySegment<int>(values, 1, 3);
3
4Console.WriteLine(segment.Count);
5Console.WriteLine(segment.Array![segment.Offset]);

The segment represents the logical slice [20, 30, 40], but the underlying array is still the original values.

Why That Is Useful

The classic use case is passing a window of data to another API without copying. This matters in:

• network buffers
• parsers
• binary protocols
• large in-memory datasets

Suppose a buffer contains a header followed by a payload. You can represent the payload with a segment instead of allocating a second array:

1byte[] buffer = new byte[1024];
2
3int payloadOffset = 16;
4int payloadLength = 200;
5
6ArraySegment<byte> payload = new ArraySegment<byte>(
7    buffer,
8    payloadOffset,
9    payloadLength
10);

That avoids a Buffer.BlockCopy just to tell another method which region matters.

Shared Backing Array Means Shared Mutation

Because the segment points into the original array, writes affect the same memory:

1int[] data = { 1, 2, 3, 4, 5 };
2var middle = new ArraySegment<int>(data, 1, 3);
3
4middle.Array![middle.Offset + 1] = 99;
5
6Console.WriteLine(string.Join(", ", data));

Output:

1, 2, 99, 4, 5

That is powerful, but it also means ArraySegment<T> is a view, not a defensive copy.

Comparison with Span<T> and Memory<T>

In modern .NET, Span<T> and Memory<T> often provide a nicer slicing story. Still, ArraySegment<T> remains useful because:

• some APIs already accept it
• it can live on the heap and inside objects
• it works well when the source is specifically an array

A common bridge looks like this:

var segment = new ArraySegment<byte>(buffer, 10, 20);
Span<byte> span = segment.AsSpan();

So ArraySegment<T> is not obsolete. It is simply a more specialized array-view type in a world that now also has spans and memories.

When It Is Better Than Copying

It is a good fit when:

• you need performance
• the callee only needs a contiguous subrange
• the original array will remain valid long enough

It is a bad fit when:

• the consumer needs independent ownership
• the backing array may be reused or pooled too early
• exposing shared mutable data would be dangerous

That last point matters in high-performance code with array pools. A segment is only safe while the array itself is safe to keep using.

Common Pitfalls

The biggest mistake is assuming ArraySegment<T> creates a copy. It does not.

Another mistake is indexing from zero mentally. A segment has logical length Count, but the actual data starts at Offset inside the source array.

A third issue is keeping a segment alive after the backing array has been repurposed. If the array comes from a pool or is reused for another operation, the segment can silently point at the wrong data.

Summary

• 'ArraySegment<T> is a cheap view over part of an array.'
• It avoids allocation and copying for contiguous slices.
• It is useful for buffers, parsers, and other performance-sensitive code.
• Mutations affect the original array because the data is shared.
• Prefer it when shared access is intended; prefer copying when independent ownership is required.