C # 'deki dizi dilimleri

Bunu nasıl yapıyorsun? Bir bayt dizisi verildiğinde:

byte[] foo = new byte[4096];

Dizinin ilk x baytını ayrı bir dizi olarak nasıl alabilirim? (Özellikle, bir olarak ihtiyacım var IEnumerable<byte>)

Bu Sockets ile çalışmak içindir . Ben en kolay yolu Perls sözdizimine benzer, dizi dilimleme olacağını anlıyorum:

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

Bu, ilk 41 öğeyi @bardiziye döndürür . C # 'da sadece eksik olduğum bir şey var mı, yoksa yapmam gereken başka bir şey var mı?

LINQ benim için bir seçenektir (.NET 3.5), eğer yardımcı olursa.

Diziler numaralandırılabilir, bu yüzden foozaten bir kendiniz IEnumerable<byte>. Take()İstediğinizi almak için LINQ sekans yöntemlerini kullanmanız yeterlidir ( Linqad alanını dahil etmeyi unutmayın using System.Linq;):

byte[] foo = new byte[4096];

var bar = foo.Take(41);

Gerçekten herhangi bir IEnumerable<byte>değerden bir dizi gerekiyorsa , bunun için ToArray()yöntemi kullanabilirsiniz . Burada böyle görünmüyor.

Kullanabilirsin ArraySegment<T>. Diziyi kopyalamadığı için çok hafif:

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

Diziler CopyTo()yöntemini kullanabilirsiniz .

Veya LINQ ile kullanabilirsiniz Skip()ve 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);

C # 8.0 / .Net Core 3.0'dan itibaren

Dizi dilimleme, yeni türler Indexve Rangeeklenerek desteklenecektir.

Menzil Yapı belgeleri
Dizin Yapı belgeleri

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 }

Yukarıdaki kod örneği C # 8.0 blogundan alınmıştır .

^ön ekin dizinin sonundan saymayı gösterdiğini unutmayın . Dokümanlar örneğinde gösterildiği gibi

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

Rangeve Indexayrıca dilimleme dizilerinin dışında, örneğin döngülerle çalışabilir

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

1'den 4'e kadar olan girişler arasında geçiş yapacak

_{Bu cevabı yazarken, C # 8.0'ın henüz resmi olarak piyasaya sürülmediğini unutmayın.
C # 8.x ve .Net Core 3.x artık Visual Studio 2019 ve sonrasında mevcuttur.}

In C # 7.2 , kullanabilirsiniz Span<T>. Yeni System.Memorysistemin yararı, verilerin etrafında kopyalamaya ihtiyaç duymamasıdır.

İhtiyacınız olan yöntem Slice:

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

Artık birçok yöntem destekliyor Spanve IReadOnlySpanbu nedenle bu yeni türü kullanmak çok kolay olacak.

Yazarken, Span<T>türün henüz .NET'in en son sürümünde (4.7.1) tanımlanmadığını unutmayın, bu nedenle kullanmak için NuGet'ten System.Memory paketini yüklemeniz gerekir .

Burada bahsetmediğim başka bir olasılık: Buffer.BlockCopy (), Array.Copy () 'den biraz daha hızlıdır ve bir dizi ilkelden (örneğin, kısa []), Yuva üzerinden iletmeniz gereken sayısal dizilere sahip olduğunuzda kullanışlı olabilecek bir bayt dizisine.

Eğer istersen IEnumerable<byte>, o zaman

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

Bir dilimi yeni bir dizi olarak döndüren basit bir uzantı yöntemi:

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

Sonra şu şekilde kullanabilirsiniz:

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

LINQ veya diğer uzantıları eklemek istemiyorsanız şunları yapın :

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

Bu (denenmemiş) kod parçasında olduğu gibi, orijinal dizi (IList olan) etrafında bir sarıcı kullanabilirsiniz.

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

Bayt dizileri için System.Buffer.BlockCopy size en iyi performansı verecektir.

Uzantıyı al yöntemini kullanabilirsiniz

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

Bu bir çözüm olabilir:

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

Sonra sonuç bir olan IEnumerable <IEnumerable <bayt >> birinci ile IEnumerable <byte> ilk 40 bayt içeren foo ve ikinci bir IEnumerable <bayt> kalanını tutar.

Bir sarıcı sınıf yazdım, tüm yineleme tembel, umarım yardımcı olabilir:

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

C # Range semantiği destekler sanmıyorum. Bununla birlikte, bir uzantı yöntemi yazabilirsiniz:

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

Ancak diğerlerinin söylediği gibi, bir başlangıç ​​dizini ayarlamanız gerekmiyorsa, ihtiyacınız olan Taketek şey budur.

Genel kullanılan ve PHP işlevi array_slice gibi davranan bir uzantı işlevi . Negatif ofset ve uzunluğa izin verilir.

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