When to use ArraySegment over Memory?

Question

I was researching the best way to return 'views' into a very large array and found ArraySegment which perfectly suited my needs. However, I then found Memory<T> which seems to behave the same, with the exception of requiring a span to view the memory.

For the use-case of creating and writing to views into a massive (2GB+) array, does it matter which one is used?

The reasons for the large arrays are they hold bytes of an image.

Are you sure having these arrays fully occupying memory is sensible in the first place? Might a `MemoryMappedFile` be a better starting point? Without knowing your use cases it's going to be difficult for anyone to offer concrete advice. — Damien_The_Unbeliever, Sep 07 '18 at 14:43
ArraySegment is just a convenience tool to avoid having to add the offset of the segment each time you access the element. Under the hood it still does it, which adds some cost to each call. Memory objects are as efficient as C# arrays. — Thinko, Sep 07 '18 at 14:46
The use case is stitching images together. The resulting image needs to be encoded to .png, hence requiring the whole file to be in memory. — Red Riding Hood, Sep 07 '18 at 14:46
Does this answer your question? [How is the new C# Span different from ArraySegment?](https://stackoverflow.com/questions/49020894/how-is-the-new-c-sharp-spant-different-from-arraysegmentt) — CoolBots, Aug 21 '20 at 03:13
`ArraySegment` is older, hence why it exists. I'd use `Memory` (or `Span`, as needed) in all new code. — Etienne de Martel, Nov 18 '20 at 16:02

score 6 · Accepted Answer · answered Jul 08 '22 at 22:10

Resurrecting this in case someone bumps into this question.

When to use ArraySegment over Memory?

Never, unless you need to call something old that expects an ArraySegment<T>, which I doubt will be the case as it was never that popular.

ArraySegment<T> is just an array, an offset, and a length, which are all exposed directly where you can choose to ignore the offset and length and access the entirety of the array if you want to. There’s also no read-only version of ArraySegment<T>.

Span<T> and Memory<T> can be backed by arrays, similar to ArraySegment<T>, but also by strings and unmanaged memory (in the form of a pointer in Span<T>’s case, and by using a custom MemoryManager<T> in Memory<T>’s case). They provide better encapsulation by not exposing their underlying data source and have read-only versions for immutable access.

Back then, we had to pass the array/offset/count trio to a lot of APIs (APIs that needed a direct reference of an array), but now that Span<T> and Memory<T> exist and are widely supported by most, if not all, .NET APIs that need to interact with continuous blocks of memory, you should have no reason to use an ArraySegment<T>.

See also: Memory- and span-related types - MS Docs

MikeJ · Answer 2 · 2020-11-17T22:07:09.780

Memory is sort of a wrapper around Span - one that doesn't have to be on the stack. And as the link provided by CoolBots pointed out it's an addition to arrays and array segments not really a replacement for them.

The main reason you would want to consider using Span/Memory is for performance and flexibility. Span gives you access to the memory directly instead of copying it back and forth to the array, and it allows you to treat the memory in a flexible way. Below I'll go from using the array as bytes to using it as an array of uint.

I'll skip right to Span but you could use AsMemory instead so you could pass that around easier. But it'd still boil down to getting the Span from the Memory.

Here's an example:

        const int dataSize = 512;
        const int segSize = 256;

        byte[] rawdata = new byte[dataSize];

        var segment = new ArraySegment<byte>(rawdata, segSize, segSize);

        var seg1 = segment.AsSpan();

        var seg1Uint = MemoryMarshal.Cast<byte, uint>(seg1);

        for (int i = 0; i < segSize / sizeof(uint); ++i)
        {
            ref var data = ref seg1Uint[i];

            data = 0x000066;
        }

        foreach (var b in rawdata)
            Console.WriteLine(b);

I would add that the standard API seems to be moving toward favoring `Memory` and `Span` over arrays. For example, [`SocketAsyncEventArgs.MemoryBuffer`](https://learn.microsoft.com/en-us/dotnet/api/system.net.sockets.socketasynceventargs.memorybuffer). — StackOverthrow, Nov 18 '20 at 16:05

When to use ArraySegment over Memory?

2 Answers2