在C＃中将子数组作为引用

Question

I have a large number of functions accepting input of sub-arrays (let's say, string) in a read-only way.

I used Array.Copy (C++ memmove equivalent from MSDN) as a temporary workaround, but it comes to a serious bottleneck on running speed. Is there any function I can get a sub-array, let's say [4~94] inside [0~99], such that it can be passed to a function x(array[]) as a reference where inside x the array is defined by [0~90]?

Answer 1

Unfortunately, arrays don't play nicely with partitioning. The only way to get a sub-array is by creating a copy of the original array, which is where the bottleneck probably is.

If you can modify your functions to take IEnumerable parameters instead of arrays, you can do this easily with LINQ:

string[] values = { "foo", "bar", "baz", "zap" };
IEnumerable<string> subset = values.Skip(1).Take(2);

You could also look into ArraySegment , but this would (again) require changes to your functions' parameter types.

string[] values = { "foo", "bar", "baz", "zap" };
ArraySegment<string> segment = new ArraySegment<string>(values, 1, 2);

Answer 2

There is no built-in support for this in C#. You can pass by reference an individual element in an array, but not an address of an array segment that could then be interpreted as a 0-based array in managed code.

The obvious solution is to pass an offset and length along with the array. You can make this a bit less painful by wrapping the array in an IReadOnlyList<T> implementation that encapsulates that for you. For example:

class SubsetList<T> : IReadOnlyList<T>
{
    private readonly IReadOnlyList<T> _list;
    private readonly int _offset = offset;
    private readonly int _length = length;

    public SubsetList(IReadOnlyList<T> list, int offset, int length)
    {
         _list = list;
         _offset = offset;
         _length = length;
    }

    public int Count { get { return _length; } }

    public T this[int index]
    {
        get { return _list[offset + index]; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        for (int i = _offset; i < _offset + _length; i++)
        {
            yield return _list[i];
        }
    }

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

Note that the above is not really needed, as it turns out .NET has (and has had since .NET 2.0) the ArraySegment<T> struct, which does the above and more. But prior to .NET 4.0, it seems it didn't implement the features that would make it transparent to use (such as interface implementations and indexers).

So I offer the above as an alternative for those so-constrained. Note that IReadOnlyList<T> is itself new to .NET 4.5, so to use the above with prior versions of .NET, change that to IList<T> , and then implement all of the other members of the interface with a simple throw new NotSupportedException() (except possibly the setter for the indexer).