Tranches de tableau en C #

Comment faites-vous? Étant donné un tableau d'octets:

byte[] foo = new byte[4096];

Comment puis-je obtenir les premiers x octets du tableau en tant que tableau séparé? (Plus précisément, j'en ai besoin en tant que IEnumerable<byte>)

C'est pour travailler avec l' Socketart. Je pense que le moyen le plus simple serait le découpage de tableaux, similaire à la syntaxe Perls:

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

Ce qui retournerait les 41 premiers éléments dans le @bartableau. Y a-t-il quelque chose en C # qui me manque, ou y a-t-il autre chose que je devrais faire?

LINQ est une option pour moi (.NET 3.5), si cela aide.

Les tableaux sont énumérables, donc votre foodéjà est un IEnumerable<byte>soi. Utilisez simplement les méthodes de séquence LINQ comme Take()pour en obtenir ce que vous voulez (n'oubliez pas d'inclure l' Linqespace de noms avec using System.Linq;):

byte[] foo = new byte[4096];

var bar = foo.Take(41);

Si vous avez vraiment besoin d'un tableau de n'importe quelle IEnumerable<byte>valeur, vous pouvez utiliser la ToArray()méthode pour cela. Cela ne semble pas être le cas ici.

Vous pourriez utiliser ArraySegment<T>. Il est très léger car il ne copie pas le tableau:

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

Vous pouvez utiliser la CopyTo()méthode des tableaux .

Ou avec LINQ, vous pouvez utiliser Skip()et 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);

À partir de C # 8.0 / .Net Core 3.0

Le découpage des tableaux sera pris en charge, ainsi que les nouveaux types Indexet en Rangecours d'ajout.

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

Exemple de code ci-dessus tiré du blog C # 8.0 .

notez que le ^préfixe indique le comptage à partir de la fin du tableau. Comme illustré dans l' exemple de documents

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

Rangeet Indexégalement travailler en dehors des tableaux de découpage, par exemple avec des boucles

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

Parcourra les entrées 1 à 4

_{notez qu'au moment de la rédaction de cette réponse, C # 8.0 n'est pas encore officiellement publié.
C # 8.x et .Net Core 3.x sont désormais disponibles dans Visual Studio 2019 et versions ultérieures}

En C # 7.2 , vous pouvez utiliser Span<T>. L'avantage du nouveau System.Memorysystème est qu'il n'a pas besoin de copier autour des données.

La méthode dont vous avez besoin est la suivante Slice:

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

De nombreuses méthodes prennent désormais en charge Spanet IReadOnlySpan, il sera donc très simple d'utiliser ce nouveau type.

Notez qu'au moment de l'écriture, le Span<T>type n'est pas encore défini dans la version la plus récente de .NET (4.7.1), donc pour l'utiliser, vous devez installer le package System.Memory de NuGet.

Une autre possibilité que je n'ai pas vue mentionnée ici: Buffer.BlockCopy () est légèrement plus rapide que Array.Copy (), et il a l'avantage supplémentaire de pouvoir convertir à la volée à partir d'un tableau de primitives (disons, court []) à un tableau d'octets, ce qui peut être pratique lorsque vous avez des tableaux numériques que vous devez transmettre via Sockets.

Si vous voulez IEnumerable<byte>, alors juste

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

Voici une méthode d'extension simple qui renvoie une tranche en tant que nouveau tableau:

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

Ensuite, vous pouvez l'utiliser comme:

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

Si vous ne voulez pas ajouter LINQ ou d'autres extensions, faites simplement:

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

Vous pouvez utiliser un wrapper autour du tableau d'origine (qui est IList), comme dans ce morceau de code (non testé).

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

Pour les tableaux d'octets, System.Buffer.BlockCopy vous donnera les meilleures performances.

Vous pouvez utiliser la méthode d'extension Take

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

Cela peut être une solution qui:

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

Le résultat est alors un IEnumerable <IEnumerable <byte >> avec un premier IEnumerable <byte> contient les 40 premiers octets de foo , et un second IEnumerable <byte> contient le reste.

J'ai écrit une classe wrapper, toute l'itération est paresseuse, j'espère que cela pourrait aider:

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

Je ne pense pas que C # supporte la sémantique Range. Vous pouvez cependant écrire une méthode d'extension, comme:

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

Mais comme d'autres l'ont dit, si vous n'avez pas besoin de définir un index de démarrage, Takec'est tout ce dont vous avez besoin.

Voici une fonction d'extension qui utilise un générique et se comporte comme la fonction PHP array_slice . Un décalage et une longueur négatifs sont autorisés.

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