Comment diviser un tableau d'octets

J'ai un tableau d'octets en mémoire, lu à partir d'un fichier. Je voudrais diviser le tableau d'octets à un certain point (index) sans avoir à simplement créer un nouveau tableau d'octets et de copie de chaque octet à la fois, l'augmentation de la mémoire pied d'impression de l'opération. Ce que je voudrais, c'est quelque chose comme ceci:

byte[] largeBytes = [1,2,3,4,5,6,7,8,9];  
byte[] smallPortion;  
smallPortion = split(largeBytes, 3);

smallPortion serait égal à 1,2,3,4

largeBytes serait égal à 5,6,7,8,9

InformationsquelleAutor Keith Sirmons | 2008-08-21

arrays c#split

C'est de cette façon que je le ferais:

using System;
using System.Collections;
using System.Collections.Generic;
class ArrayView<T> : IEnumerable<T>
{
private readonly T[] array;
private readonly int offset, count;
public ArrayView(T[] array, int offset, int count)
{
this.array = array;
this.offset = offset;
this.count = count;
}
public int Length
{
get { return count; }
}
public T this[int index]
{
get
{
if (index < 0 || index >= this.count)
throw new IndexOutOfRangeException();
else
return this.array[offset + index];
}
set
{
if (index < 0 || index >= this.count)
throw new IndexOutOfRangeException();
else
this.array[offset + index] = value;
}
}
public IEnumerator<T> GetEnumerator()
{
for (int i = offset; i < offset + count; i++)
yield return array[i];
}
IEnumerator IEnumerable.GetEnumerator()
{
IEnumerator<T> enumerator = this.GetEnumerator();
while (enumerator.MoveNext())
{
yield return enumerator.Current;
}
}
}
class Program
{
static void Main(string[] args)
{
byte[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
ArrayView<byte> p1 = new ArrayView<byte>(arr, 0, 5);
ArrayView<byte> p2 = new ArrayView<byte>(arr, 5, 5);
Console.WriteLine("First array:");
foreach (byte b in p1)
{
Console.Write(b);
}
Console.Write("\n");
Console.WriteLine("Second array:");
foreach (byte b in p2)
{
Console.Write(b);
}
Console.ReadKey();
}
}

InformationsquelleAutor Michał Piaskowski

20

FYI. System.ArraySegment<T> structure est essentiellement la même chose que ArrayView<T> dans le code ci-dessus. Vous pouvez utiliser cette out-of-the-box structure de la même façon, si vous le souhaitez.
- Intéressant. Dommage que je n'ai pas vu cela lorsque je travaillais sur ce projet. Merci pour l'info de toute façon.
InformationsquelleAutor Eren Ersönmez
19

En C#, Linq, vous pouvez le faire:
```
smallPortion = largeBytes.Take(4).ToArray();
largeBytes = largeBytes.Skip(4).Take(5).ToArray();
```
😉
- L'OP est de se demander comment faire ce sans avoir à [...] de créer un nouveau tableau d'octets et de copie de chaque octet à la fois Mais c'est exactement ce que votre code LINQ n'. À deux reprises.
- ..ce qui m'a aidé à résoudre un problème que j'ai eu qui n'ont pas été résolus par ArraySegment<T>..
- pour éviter d'utiliser le palais a connu plusieurs de mémoire seulement de supprimer les deux ".ToArray()" les appels. Qui sera de retour deux IEnumerables avec beaucoup moins de lignes de code.
- vrai, mais ça vous donne une IEnumerable<byte>. Il est tout à fait sûr (et rapide) pour itérer sur que énumérable plusieurs fois il y a deux inconvénients: a) vous ne pouvez toujours pas d'indice dans cette section du tableau directement. Bien sûr, le LINQ implémentations de Passer/prendre Prendre avantage de la structure du tableau, mais ils le font en essayant de jeter le IEnumerable de Collection ou un Tableau. b) une Fois que vous retournez un IEnumerable de votre API, les clients ne sont plus garantie (par le système de type) que l'énumérable est sûr et efficace pour itérer plusieurs fois.
InformationsquelleAutor Alireza Naghizadeh

Essayez celui-ci:

private IEnumerable<byte[]> ArraySplit(byte[] bArray, int intBufforLengt)
{
int bArrayLenght = bArray.Length;
byte[] bReturn = null;
int i = 0;
for (; bArrayLenght > (i + 1) * intBufforLengt; i++)
{
bReturn = new byte[intBufforLengt];
Array.Copy(bArray, i * intBufforLengt, bReturn, 0, intBufforLengt);
yield return bReturn;
}
int intBufforLeft = bArrayLenght - i * intBufforLengt;
if (intBufforLeft > 0)
{
bReturn = new byte[intBufforLeft];
Array.Copy(bArray, i * intBufforLengt, bReturn, 0, intBufforLeft);
yield return bReturn;
}
}

Je pense qu'il doit être statique

InformationsquelleAutor Robert Wisniewski

1

Je ne suis pas sûr de ce que tu veux dire par:

Je voudrais diviser le tableau d'octets à un certain point(index) sans avoir à simplement créer un nouveau tableau d'octets et de copie de chaque octet à la fois, l'augmentation de la mémoire pied d'impression de l'opération.

Dans la plupart des langues, certes C#, une fois que le tableau a été alloué, il n'y a aucun moyen de changer la taille de celui-ci. Il semble que vous êtes à la recherche d'un moyen pour modifier la longueur d'un tableau, qui vous ne pouvez pas. Vous aussi, vous souhaitez recycler en quelque sorte la mémoire de la deuxième partie du tableau, afin de créer un deuxième tableau, vous aussi ne peut pas le faire.

En résumé: il suffit de créer un nouveau tableau.

InformationsquelleAutor Outlaw Programmer

Comme Eren a dit, vous pouvez utiliser ArraySegment<T>. Voici une méthode d'extension et exemple d'utilisation:

public static class ArrayExtensionMethods
{
public static ArraySegment<T> GetSegment<T>(this T[] arr, int offset, int? count = null)
{
if (count == null) { count = arr.Length - offset; }
return new ArraySegment<T>(arr, offset, count.Value);
}
}
void Main()
{
byte[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
var p1 = arr.GetSegment(0, 5);
var p2 = arr.GetSegment(5);
Console.WriteLine("First array:");
foreach (byte b in p1)
{
Console.Write(b);
}
Console.Write("\n");
Console.WriteLine("Second array:");
foreach (byte b in p2)
{
Console.Write(b);
}
}

InformationsquelleAutor orad

0

Vous ne pouvez pas. Ce que vous voulez est de garder un point de départ et le nombre d'éléments; en substance, construire des itérateurs. Si c'est le C++, vous pouvez simplement utiliser std::vector<int> et servez-vous-en.

En C#, j'aimerais construire une petite itérateur classe qui contient les index de début, le comte et la met en œuvre IEnumerable<>.

InformationsquelleAutor Stu

Vous devez vous connecter pour publier un commentaire.