C#中的数组切片

Question

你是怎么做到的？给定一个字节数组：

byte[] foo = new byte[4096];

如何将数组的前 x 个字节作为单独的数组获取？ （具体来说，我需要它作为IEnumerable<byte>）

这是为了与Sockets 一起工作。我认为最简单的方法是数组切片，类似于 Perls 语法：

@bar = @foo[0..40];

这会将前 41 个元素返回到 @bar 数组中。 C# 中有什么我只是缺少的东西，还是我应该做的其他事情？

LINQ 对我来说是一个选项 (.NET 3.5)，如果有帮助的话。

Answer 1

您可以使用ArraySegment<T>。它非常轻巧，因为它不复制数组：

string[] a = { "one", "two", "three", "four", "five" };
var segment = new ArraySegment<string>( a, 1, 2 );

Answer 2

数组是可枚举的，所以您的foo 本身已经是IEnumerable<byte>。 只需使用Take() 之类的 LINQ 序列方法即可从中获取所需内容（不要忘记将Linq 命名空间与using System.Linq; 一起包含）：

byte[] foo = new byte[4096];

var bar = foo.Take(41);

如果您确实需要来自任何 IEnumerable<byte> 值的数组，则可以使用 ToArray() 方法。这似乎不是这里的情况。

Answer 3

您可以使用数组CopyTo() 方法。

或者使用 LINQ，您可以使用 Skip() 和 Take()...

byte[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
var subset = arr.Skip(2).Take(2);

Answer 4

从 C# 8.0/.Net Core 3.0 开始

将支持数组切片，并添加新类型 Index 和 Range。

Range Struct docs
Index Struct docs

Index i1 = 3;  // number 3 from beginning
Index i2 = ^4; // number 4 from end
int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Console.WriteLine($"{a[i1]}, {a[i2]}"); // "3, 6"

var slice = a[i1..i2]; // { 3, 4, 5 }

以上代码示例取自 C# 8.0 blog。

注意^ 前缀表示从数组的end 开始计数。如图docs example

var words = new string[]
{
                // index from start    index from end
    "The",      // 0                   ^9
    "quick",    // 1                   ^8
    "brown",    // 2                   ^7
    "fox",      // 3                   ^6
    "jumped",   // 4                   ^5
    "over",     // 5                   ^4
    "the",      // 6                   ^3
    "lazy",     // 7                   ^2
    "dog"       // 8                   ^1
};              // 9 (or words.Length) ^0

Range 和 Index 也可以在切片数组之外工作，例如使用循环

Range range = 1..4; 
foreach (var name in names[range])

将遍历条目 1 到 4

---

_{请注意，在撰写此答案时，C# 8.0 尚未正式发布
C# 8.x 和 .Net Core 3。 x 现在可在 Visual Studio 2019 及更高版本中使用}

Answer 5

static byte[] SliceMe(byte[] source, int length)
{
    byte[] destfoo = new byte[length];
    Array.Copy(source, 0, destfoo, 0, length);
    return destfoo;
}

//

var myslice = SliceMe(sourcearray,41);

Answer 6

在C# 7.2 中，您可以使用Span<T>。新的System.Memory 系统的好处是它不需要复制数据。

你需要的方法是Slice:

Span<byte> slice = foo.Slice(0, 40);

现在很多方法都支持Span和IReadOnlySpan，所以使用这种新类型会非常简单。

请注意，在撰写本文时，最新版本的 .NET (4.7.1) 中尚未定义 Span<T> 类型，因此要使用它，您需要从 NuGet 安装 System.Memory package。

Answer 7

我在这里没有看到的另一种可能性：Buffer.BlockCopy() 比 Array.Copy() 稍快，并且它具有能够从原始数组动态转换的额外好处 (比如，short[]) 到一个字节数组，当你有需要通过 Socket 传输的数字数组时，这会很方便。

Answer 8

如果你想要IEnumerable<byte>，那么就

IEnumerable<byte> data = foo.Take(x);

Answer 9

C# 8 现在（自 2019 年起）支持Ranges，这使您可以更轻松地实现 Slice（类似于 JS 语法）：

var array = new int[] { 1, 2, 3, 4, 5 };
var slice1 = array[2..^3];    // array[new Range(2, new Index(3, fromEnd: true))]
var slice2 = array[..^3];     // array[Range.EndAt(new Index(3, fromEnd: true))]
var slice3 = array[2..];      // array[Range.StartAt(2)]
var slice4 = array[..];       // array[Range.All]

您可以使用范围来代替众所周知的 LINQ 函数：Skip()、Take()、Count()。。 p>

Answer 10

这是一个简单的扩展方法，它返回一个切片作为一个新数组：

public static T[] Slice<T>(this T[] arr, uint indexFrom, uint indexTo) {
    if (indexFrom > indexTo) {
        throw new ArgumentOutOfRangeException("indexFrom is bigger than indexTo!");
    }

    uint length = indexTo - indexFrom;
    T[] result = new T[length];
    Array.Copy(arr, indexFrom, result, 0, length);

    return result;
}

那么你可以把它当作：

byte[] slice = foo.Slice(0, 40);

Answer 11

如果您不想添加 LINQ 或其他扩展名，只需：

float[] subArray = new List<float>(myArray).GetRange(0, 8).ToArray();

Answer 12

byte[] foo = new byte[4096]; 

byte[] bar = foo.Take(40).ToArray();

Answer 13

您可以在原始数组（即 IList）周围使用包装器，就像在这段（未经测试的）代码中一样。

public class SubList<T> : IList<T>
{
    #region Fields

    private readonly int startIndex;
    private readonly int endIndex;
    private readonly int count;
    private readonly IList<T> source;

    #endregion

    public SubList(IList<T> source, int startIndex, int count)
    {
        this.source = source;
        this.startIndex = startIndex;
        this.count = count;
        this.endIndex = this.startIndex + this.count - 1;
    }

    #region IList<T> Members

    public int IndexOf(T item)
    {
        if (item != null)
        {
            for (int i = this.startIndex; i <= this.endIndex; i++)
            {
                if (item.Equals(this.source[i]))
                    return i;
            }
        }
        else
        {
            for (int i = this.startIndex; i <= this.endIndex; i++)
            {
                if (this.source[i] == null)
                    return i;
            }
        }
        return -1;
    }

    public void Insert(int index, T item)
    {
        throw new NotSupportedException();
    }

    public void RemoveAt(int index)
    {
        throw new NotSupportedException();
    }

    public T this[int index]
    {
        get
        {
            if (index >= 0 && index < this.count)
                return this.source[index + this.startIndex];
            else
                throw new IndexOutOfRangeException("index");
        }
        set
        {
            if (index >= 0 && index < this.count)
                this.source[index + this.startIndex] = value;
            else
                throw new IndexOutOfRangeException("index");
        }
    }

    #endregion

    #region ICollection<T> Members

    public void Add(T item)
    {
        throw new NotSupportedException();
    }

    public void Clear()
    {
        throw new NotSupportedException();
    }

    public bool Contains(T item)
    {
        return this.IndexOf(item) >= 0;
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        for (int i=0; i<this.count; i++)
        {
            array[arrayIndex + i] = this.source[i + this.startIndex];
        }
    }

    public int Count
    {
        get { return this.count; }
    }

    public bool IsReadOnly
    {
        get { return true; }
    }

    public bool Remove(T item)
    {
        throw new NotSupportedException();
    }

    #endregion

    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()
    {
        for (int i = this.startIndex; i < this.endIndex; i++)
        {
            yield return this.source[i];
        }
    }

    #endregion

    #region IEnumerable Members

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

    #endregion
}

Answer 14

对于字节数组System.Buffer.BlockCopy 会给你最好的性能。

Answer 15

你可以使用Take扩展方法

var array = new byte[] {1, 2, 3, 4};
var firstTwoItems = array.Take(2);

Answer 16

这可能是一个解决方案：

var result = foo.Slice(40, int.MaxValue);

那么结果是一个IEnumerable>，第一个IEnumerable包含foo，第二个 IEnumerable 保存其余部分。

自己写了一个包装类，整个迭代比较懒，希望能有所帮助：

public static class CollectionSlicer
{
    public static IEnumerable<IEnumerable<T>> Slice<T>(this IEnumerable<T> source, params int[] steps)
    {
        if (!steps.Any(step => step != 0))
        {
            throw new InvalidOperationException("Can't slice a collection with step length 0.");
        }
        return new Slicer<T>(source.GetEnumerator(), steps).Slice();
    }
}

public sealed class Slicer<T>
{
    public Slicer(IEnumerator<T> iterator, int[] steps)
    {
        _iterator = iterator;
        _steps = steps;
        _index = 0;
        _currentStep = 0;
        _isHasNext = true;
    }

    public int Index
    {
        get { return _index; }
    }

    public IEnumerable<IEnumerable<T>> Slice()
    {
        var length = _steps.Length;
        var index = 1;
        var step = 0;

        for (var i = 0; _isHasNext; ++i)
        {
            if (i < length)
            {
                step = _steps[i];
                _currentStep = step - 1;
            }

            while (_index < index && _isHasNext)
            {
                _isHasNext = MoveNext();
            }

            if (_isHasNext)
            {
                yield return SliceInternal();
                index += step;
            }
        }
    }

    private IEnumerable<T> SliceInternal()
    {
        if (_currentStep == -1) yield break;
        yield return _iterator.Current;

        for (var count = 0; count < _currentStep && _isHasNext; ++count)
        {
            _isHasNext = MoveNext();

            if (_isHasNext)
            {
                yield return _iterator.Current;
            }
        }
    }

    private bool MoveNext()
    {
        ++_index;
        return _iterator.MoveNext();
    }

    private readonly IEnumerator<T> _iterator;
    private readonly int[] _steps;
    private volatile bool _isHasNext;
    private volatile int _currentStep;
    private volatile int _index;
}

Answer 17

我认为 C# 不支持 Range 语义。不过，您可以编写一个扩展方法，例如：

public static IEnumerator<Byte> Range(this byte[] array, int start, int end);

但正如其他人所说，如果您不需要设置起始索引，那么您只需要Take。

Answer 18

这是一个使用泛型的扩展函数，其行为类似于 PHP 函数 array_slice。允许负偏移量和长度。

public static class Extensions
{
    public static T[] Slice<T>(this T[] arr, int offset, int length)
    {
        int start, end;

        // Determine start index, handling negative offset.
        if (offset < 0)
            start = arr.Length + offset;
        else
            start = offset;

        // Clamp start index to the bounds of the input array.
        if (start < 0)
            start = 0;
        else if (start > arr.Length)
            start = arr.Length;

        // Determine end index, handling negative length.
        if (length < 0)
            end = arr.Length + length;
        else
            end = start + length;

        // Clamp end index to the bounds of the input array.
        if (end < 0)
            end = 0;
        if (end > arr.Length)
            end = arr.Length;

        // Get the array slice.
        int len = end - start;
        T[] result = new T[len];
        for (int i = 0; i < len; i++)
        {
            result[i] = arr[start + i];
        }
        return result;
    }
}

Answer 19

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace data_seniens
{
    class Program
    {
        static void Main(string[] args)
        {
            //new list
            float [] x=new float[]{11.25f,18.0f,20.0f,10.75f,9.50f, 11.25f, 18.0f, 20.0f, 10.75f, 9.50f };

            //variable
            float eat_sleep_area=x[1]+x[3];
            //print
            foreach (var VARIABLE in x)
            {
                if (VARIABLE < x[7])
                {
                    Console.WriteLine(VARIABLE);
                }
            }



            //keep app run
        Console.ReadLine();
        }
    }
}