Array-Slices in C #

Wie machst du das? Gegeben ein Byte-Array:

byte[] foo = new byte[4096];

Wie würde ich die ersten x Bytes des Arrays als separates Array erhalten? (Speziell brauche ich es als IEnumerable<byte>)

Dies ist für die Arbeit mit Sockets. Ich denke, der einfachste Weg wäre das Schneiden von Arrays, ähnlich der Perls-Syntax:

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

Welches würde die ersten 41 Elemente in das @barArray zurückgeben. Gibt es etwas in C #, das mir gerade fehlt, oder gibt es noch etwas, was ich tun sollte?

LINQ ist eine Option für mich (.NET 3.5), falls dies hilfreich ist.

Arrays sind aufzählbar, so dass Sie foobereits ein Selbst sind IEnumerable<byte>. Verwenden Sie einfach LINQ-Sequenzmethoden Take(), um das zu erreichen, was Sie wollen (vergessen Sie nicht, den LinqNamespace mit einzuschließen using System.Linq;):

byte[] foo = new byte[4096];

var bar = foo.Take(41);

Wenn Sie wirklich ein Array von einem beliebigen IEnumerable<byte>Wert benötigen , können Sie die ToArray()Methode dafür verwenden. Dies scheint hier nicht der Fall zu sein.

Sie könnten verwenden ArraySegment<T>. Es ist sehr leicht, da es das Array nicht kopiert:

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

Sie können die Arrays- CopyTo()Methode verwenden.

Oder mit LINQ können Sie verwenden Skip()und 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);

Ab C # 8.0 / .Net Core 3.0

Array-Slicing wird zusammen mit den neuen Typen unterstützt Indexund Rangehinzugefügt.

Range Struct-Dokumente
Index Struct-Dokumente

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 }

Das obige Codebeispiel stammt aus dem C # 8.0- Blog .

Beachten Sie, dass das ^Präfix das Zählen ab dem Ende des Arrays anzeigt . Wie im Dokumentbeispiel gezeigt

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

Rangeund Indexarbeiten auch außerhalb von Slicing-Arrays, beispielsweise mit Schleifen

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

Durchläuft die Einträge 1 bis 4

_{Beachten Sie, dass C # 8.0 zum Zeitpunkt des Schreibens dieser Antwort noch nicht offiziell freigegeben ist.
C # 8.x und .Net Core 3.x sind jetzt in Visual Studio 2019 und höher verfügbar}

In C # 7.2 können Sie verwenden Span<T>. Der Vorteil des neuen System.MemorySystems besteht darin, dass keine Daten kopiert werden müssen.

Die Methode, die Sie benötigen, ist Slice:

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

Viele Methoden unterstützen jetzt Spanund IReadOnlySpandaher wird es sehr einfach sein, diesen neuen Typ zu verwenden.

Beachten Sie, dass der Span<T>Typ zum Zeitpunkt des Schreibens noch nicht in der neuesten Version von .NET (4.7.1) definiert ist. Um ihn zu verwenden, müssen Sie das System.Memory-Paket von NuGet installieren .

Eine andere Möglichkeit, die ich hier nicht gesehen habe: Buffer.BlockCopy () ist etwas schneller als Array.Copy () und hat den zusätzlichen Vorteil, dass es in der Lage ist, on-the-fly aus einem Array von Grundelementen (z. B. kurz) zu konvertieren []) zu einem Array von Bytes, was nützlich sein kann, wenn Sie numerische Arrays haben, die Sie über Sockets übertragen müssen.

Wenn du willst IEnumerable<byte>, dann einfach

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

Hier ist eine einfache Erweiterungsmethode, die ein Slice als neues Array zurückgibt:

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

Dann können Sie es verwenden als:

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

Wenn Sie LINQ oder andere Erweiterungen nicht hinzufügen möchten, gehen Sie einfach wie folgt vor :

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

Sie können einen Wrapper um das ursprüngliche Array (IList) verwenden, wie in diesem (nicht getesteten) Code.

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

Für Byte-Arrays bietet System.Buffer.BlockCopy die beste Leistung.

Sie können die Take-Erweiterungsmethode verwenden

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

Dies kann eine Lösung sein, die:

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

Das Ergebnis ist dann, dass ein IEnumerable <IEnumerable <Byte >> mit einem ersten IEnumerable <Byte> die ersten 40 Bytes von foo enthält und ein zweites IEnumerable <Byte> den Rest enthält.

Ich habe eine Wrapper-Klasse geschrieben, die ganze Iteration ist faul, hoffe es könnte helfen:

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

Ich glaube nicht, dass C # die Range-Semantik unterstützt. Sie könnten jedoch eine Erweiterungsmethode schreiben, wie:

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

Aber wie andere gesagt haben, wenn Sie keinen Startindex festlegen müssen, Takeist alles, was Sie brauchen.

Hier ist eine Erweiterungsfunktion, die eine generische Funktion verwendet und sich wie die PHP-Funktion array_slice verhält . Negativer Versatz und Länge sind zulässig.

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