C# Array slice without copy

Question

I'd like to pass a sub-set of a C# array to into a method. I don't care if the method overwrites the data so would like to avoid creating a copy.

Is there a way to do this?

Thanks.

Vi

You might be interested in ArraySlice<T>: github.com/henon/SliceAndDice – Sylvanus

Answer 1

Change the method to take an IEnumerable<T> or ArraySegment<T>.

You can then pass new ArraySegment<T>(array, 5, 2)

Millimicron

You may add an example of IEnumerable<T> with Skip / Take. – Heptode

@StefanSteinegger: ArraySegment<T> implements IEnumerable<T> – Millimicron

You do lose fast element access though when using ArraySegment, which implements IEnumerable, IList, both of which dont guarantee O(1) for accessing a random element, right? – Tessatessellate

@t: ArraySegment<T> is O(1). referencesource.microsoft.com/#mscorlib/system/… – Millimicron

Answer 2

With C# 7.2 we have Span<T> . You can use the extension method AsSpan<T> for your array and pass it to the method without copying the sliced part. eg:

Method( array.AsSpan().Slice(1,3) )

Precautionary

Answer 3

You can use the following class. Note you may need to modify it depending on whether you want endIndex to be inclusive or exclusive. You could also modify it to take a start and a count, rather than a start and an end index.

I intentionally didn't add mutable methods. If you specifically want them, that's easy enough to add. You may also want to implement IList if you add the mutable methods.

public class Subset<T> : IReadOnlyList<T>
{
    private IList<T> source;
    private int startIndex;
    private int endIndex;
    public Subset(IList<T> source, int startIndex, int endIndex)
    {
        this.source = source;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    public T this[int i]
    {
        get
        {
            if (startIndex + i >= endIndex)
                throw new IndexOutOfRangeException();
            return source[startIndex + i];
        }
    }

    public int Count
    {
        get { return endIndex - startIndex; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return source.Skip(startIndex)
            .Take(endIndex - startIndex)
            .GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Pleasant

Answer 4

Arrays are immutable by size (i.e. you can't change size of a array), so you can only pass a subtracted copy of the original array. As option you can pass two indexes aside original array into method and operate on the basis of additional two indexes..

Multiplication

Answer 5

you can use Linq take funktion and take as many elements from array as you want

var yournewarray = youroldarray.Take(4).ToArray();

Iy

If you add ToArray to the end then you're performing a copy. You'd also need to use both Skip and Take to get an arbitrary subset. Finally, if he wants quick indexed access within the subset he wouldn't get it from an IEnumerable. – Pleasant

-1: OP specifically posted he does not want a copy. – Tessatessellate