Các lát mảng trong C #

Bạn làm nó như thế nào? Cho một mảng byte:

byte[] foo = new byte[4096];

Làm thế nào tôi có thể nhận được x byte đầu tiên của mảng dưới dạng một mảng riêng biệt? (Cụ thể, tôi cần nó như một IEnumerable<byte>)

Đây là để làm việc với Sockets. Tôi nghĩ cách dễ nhất sẽ là cắt mảng, tương tự như cú pháp Perls:

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

Mà sẽ trả lại 41 phần tử đầu tiên vào @barmảng. Có điều gì đó trong C # mà tôi chỉ thiếu, hoặc có một số điều khác tôi nên làm không?

LINQ là một tùy chọn cho tôi (.NET 3.5), nếu điều đó có ích.

Mảng là vô số, vì vậy bạn foođã là một IEnumerable<byte>chính nó. Chỉ cần sử dụng các phương thức chuỗi LINQ như Take()để có được những gì bạn muốn từ nó (đừng quên bao gồm Linqkhông gian tên với using System.Linq;):

byte[] foo = new byte[4096];

var bar = foo.Take(41);

Nếu bạn thực sự cần một mảng từ bất kỳ IEnumerable<byte>giá trị nào , bạn có thể sử dụng ToArray()phương thức cho điều đó. Điều đó dường như không phải là trường hợp ở đây.

Bạn có thể sử dụng ArraySegment<T>. Nó rất nhẹ vì nó không sao chép mảng:

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

Bạn có thể sử dụng CopyTo()phương thức mảng .

Hoặc với LINQ bạn có thể sử dụng Skip()và Take()...

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

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);

Bắt đầu từ C # 8.0 / .Net Core 3.0

Cắt lát sẽ được hỗ trợ, cùng với các loại mới Indexvà Rangeđược thêm vào.

Phạm vi cấu trúc tài liệu
Chỉ mục cấu trúc tài liệu

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 }

Mẫu mã trên được lấy từ blog C # 8.0 .

lưu ý rằng ^tiền tố chỉ ra việc đếm từ cuối mảng. Như thể hiện trong ví dụ về tài liệu

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

Rangevà Indexcũng hoạt động bên ngoài các mảng cắt, ví dụ với các vòng lặp

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

Sẽ lặp qua các mục từ 1 đến 4

_{lưu ý rằng tại thời điểm viết câu trả lời này, C # 8.0 vẫn chưa được phát hành chính thức
C # 8.x và .Net Core 3.x hiện có sẵn trong Visual Studio 2019 trở đi}

Trong C # 7.2 , bạn có thể sử dụng Span<T>. Lợi ích của cái mớiSystem.Memory hệ thống là nó không cần sao chép xung quanh dữ liệu.

Phương pháp bạn cần là Slice:

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

Rất nhiều phương pháp hiện nay hỗ trợ Spanvà IReadOnlySpan, vì vậy sẽ rất đơn giản để sử dụng loại mới này.

Lưu ý rằng tại thời điểm viết Span<T>loại chưa được xác định trong phiên bản .NET mới nhất (4.7.1), vì vậy, để sử dụng nó, bạn cần cài đặt gói System.Memory từ NuGet.

Một khả năng khác tôi chưa từng thấy được đề cập ở đây: Buffer.BlockCopy () nhanh hơn một chút so với Array.Copy () và nó có thêm lợi ích là có thể chuyển đổi nhanh chóng từ một loạt các nguyên thủy (giả sử, ngắn []) đến một mảng byte, có thể hữu ích khi bạn có các mảng số mà bạn cần truyền qua Sockets.

Nếu bạn muốn IEnumerable<byte>, sau đó chỉ

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

Đây là một phương thức mở rộng đơn giản trả về một lát như một mảng mới:

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;
}

Sau đó, bạn có thể sử dụng nó như:

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

Nếu bạn không muốn thêm LINQ hoặc các tiện ích mở rộng khác, hãy làm:

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

Bạn có thể sử dụng một trình bao bọc xung quanh mảng ban đầu (là IList), giống như trong đoạn mã (chưa được kiểm tra) này.

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

}

byte[] foo = new byte[4096]; 

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

Đối với mảng byte System.Buffer.BlockCopy sẽ cung cấp cho bạn hiệu suất tốt nhất.

Bạn có thể sử dụng phương thức mở rộng

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

Đây có thể là một giải pháp:

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

Sau đó, kết quả là một IEnumerable <IEnumerable <byte >> với một IEnumerable <byte> đầu tiên chứa 40 byte đầu tiên của foo và một byte thứ hai <byte> giữ phần còn lại.

Tôi đã viết một lớp bao bọc, toàn bộ lặp đi lặp lại là lười biếng, hy vọng nó có thể giúp:

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;
}

Tôi không nghĩ C # hỗ trợ ngữ nghĩa Range. Bạn có thể viết một phương thức mở rộng, như:

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

Nhưng giống như những người khác đã nói nếu bạn không cần thiết lập một chỉ mục bắt đầu thì đó Takelà tất cả những gì bạn cần.

Đây là một hàm mở rộng sử dụng chung và hoạt động giống như hàm PHP Array_slice . Độ lệch âm và chiều dài được phép.

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;
    }
}

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();
        }
    }
}