RentedListCore 0.2.3

RentedListCore

Disposable List structure allocating memory from ArrayPool

Usage

• RentedList<T>: a disposable struct backed by ArrayPool<T>.Shared, with list operations, collection interfaces, and Span, Memory, and Segment views.
• ValueRentedList<T>: a disposable ref struct that starts empty with a scratch Span<T> and switches to the pool when it outgrows it. Supports the same list operations and span views.

using RentedList<int> rented = [1, 2, 3];
rented.Add(4);

using var value = new ValueRentedList<int>(stackalloc int[4]);
value.AddRange(1, 2, 3, 4);
value.Add(5); // Grows into a rented array.

For both types, Clear() and Dispose() release storage and reset count/capacity to zero. Copies share storage; avoid disposing multiple copies or retaining views across growth or disposal.

Rented buffers

RentedBuffer<T> is a disposable struct for a fixed rental from ArrayPool<T>.Shared. The constructor accepts a minimum capacity; Capacity reports the actual rental size. Array, Span, Memory, and Segment expose the entire rental without copying. Implicit conversions are available to T[], Span<T>, ReadOnlySpan<T>, Memory<T>, ReadOnlyMemory<T>, and ArraySegment<T>, along with ref and range indexers.

using var buffer = new RentedBuffer<byte>(1024);
Span<byte> data = buffer;
data.Clear(); // Pooled storage is not guaranteed to be zeroed.
buffer[0] = 42;
Memory<byte> firstKilobyte = buffer.Memory[..1024];

Negative capacities throw; zero capacity and default buffers have empty views. Dispose() returns the rental and resets capacity to zero; repeated disposal of the same instance is harmless. Copies share storage, so dispose only one owner and stop using all borrowed views (including the array) before disposal. Arrays are returned without clearing their contents.

Stack-or-pool buffers

ValueRentedBuffer<T> is a disposable ref struct for a fixed buffer. Its constructor accepts a minimum capacity and an optional scratch Span<T>. It borrows the entire scratch span if large enough; otherwise it rents directly from ArrayPool<T>.Shared, without copying or modifying the scratch storage. There is no growth.

Allocate stack storage conditionally in the caller so larger requests rent without executing a stack allocation:

ArgumentOutOfRangeException.ThrowIfNegative(length);

const int StackLimit = 1024; // Bytes, since T is byte.
using var buffer = new ValueRentedBuffer<byte>(
    length,
    length <= StackLimit ? stackalloc byte[length] : default);

Span<byte> data = buffer.Span[..length];
data.Clear(); // Storage is not guaranteed to be zeroed.

Stack storage must be allocated in the caller's scope; a constructor or factory cannot return a buffer referencing its own stackalloc storage. Choose stack limits in bytes, accounting for the element size. T is unconstrained, but stackalloc requires unmanaged elements; reference types can use array-backed scratch spans or rentals. Omitting the scratch span rents directly for positive capacities.

Capacity and Span expose the entire selected storage, potentially larger than requested. Ref and range indexers and implicit conversions to Span<T> and ReadOnlySpan<T> share that storage. Negative capacities throw; zero capacity, even with scratch storage, and default buffers have empty views.

Dispose() returns only owned rentals, without clearing their contents, and resets the buffer to empty. Repeated disposal of the same instance is harmless. Copies share storage: dispose only one owner and stop using borrowed views before disposal. Caller-owned scratch storage remains owned by the caller.

Benchmarks

Adding elements

Code

Results

Enumerating elements

Code

Results

Indexing elements

Code

Results

Creating collection

Code

Results