c# - Das verketten einer C# - Liste von byte[]

20
```
listOfByteArrs.SelectMany(byteArr=>byteArr).ToArray()
```
Der obige code verketten eine Abfolge von Sequenzen von bytes, die in einer Sequenz - und speichern das Ergebnis in einem array.

Obwohl lesbar, dies ist nicht maximal effizient - es ist nicht mit der Tatsache, dass Sie schon wissen die Länge der resultierende byte-array und kann somit vermeiden, die dynamisch erweitert .ToArray() Implementierung, die notwendigerweise mehrere Zuweisungen und array-Kopien. Darüber hinaus SelectMany implementiert ist, in Bezug auf Iteratoren; dies bedeutet, dass viele+viele Schnittstellen-Aufrufe, die ist ziemlich langsam. Jedoch für kleine-ish-Daten-set-Größe dürfte dies egal.

Wenn brauchst du eine schnellere Umsetzung können Sie Folgendes tun:
```
var output = new byte[listOfByteArrs.Sum(arr=>arr.Length)];
int writeIdx=0;
foreach(var byteArr in listOfByteArrs) {
    byteArr.CopyTo(output, writeIdx);
    writeIdx += byteArr.Length;
}
```
oder wie Martinho schon sagt:
```
var output = new byte[listOfByteArrs.Sum(arr => arr.Length)];
using(var stream = new MemoryStream(output))
    foreach (var bytes in listOfByteArrs)
        stream.Write(bytes, 0, bytes.Length);
```
Einige timings:
```
var listOfByteArrs = Enumerable.Range(1,1000)
    .Select(i=>Enumerable.Range(0,i).Select(x=>(byte)x).ToArray()).ToList();
```
Nutzt die kurze Methode zum verketten diese 500500 bytes dauert 15ms, mit der fast-Methode dauert 0,5 ms auf meinem Rechner - YMMV, und beachten Sie, dass für viele Anwendungen sind beide mehr als schnell genug ;-).

Schließlich könnten Sie ersetzen Array.CopyTo mit der static Array.Copy, die low-level - Buffer.BlockCopy oder eine MemoryStream mit einem reserviert-zurück-Puffer - diese führen alle so ziemlich gleich auf meine tests (x64 .NET 4.0).

Obwohl kurze und klare, beachten Sie, dass dieser code ist sehr langsam im Vergleich zu der herkömmlichen Lösung. Wenn es schnell genug ist, ist toll, aber es könnte nicht schnell genug sein.
Was ist die "traditionelle Lösung"?
Die "traditionelle" Lösung wäre wahrscheinlich die manuelle, verschachtelte for-Schleifen. Das ist etwa drei mal langsamer als der block-copy-basierte Lösungen, die aber immer noch 10 mal schneller als SelectMany.

InformationsquelleAutor Eamon Nerbonne

Hier ist eine Lösung basierend auf Andrew Bezzub's und fejesjoco Antworten, pre-allocating alle nötigen Speicher vor. Damit ergibt sich Θ(N) Speicher und Θ(N) Zeit (wobei N die Gesamtzahl von bytes).

byte[] result = new byte[list.Sum(a => a.Length)];
using(var stream = new MemoryStream(result))
{
    foreach (byte[] bytes in list)
    {
        stream.Write(bytes, 0, bytes.Length);
    }
}
return result;

InformationsquelleAutor R. Martinho Fernandes

2

schreiben Sie alles in ein MemoryStream-statt einer Liste. dann rufen Sie MemoryStream.ToArray(). Oder wenn Sie die Liste zunächst eine Zusammenfassung der byte-array-Längen, erstellen Sie ein neues byte-array mit der gesamten Länge, und kopieren Sie jedes array nach der letzten in der großen array.

InformationsquelleAutor fejesjoco
2

Linq:
```
    List<byte[]> list = new List<byte[]>();
    list.Add(new byte[] { 1, 2, 3, 4 });
    list.Add(new byte[] { 1, 2, 3, 4 });
    list.Add(new byte[] { 1, 2, 3, 4 });

    IEnumerable<byte> result = Enumerable.Empty<byte>();

    foreach (byte[] bytes in list)
    {
        result = result.Concat(bytes);
    }

    byte[] newArray = result.ToArray();
```
Vielleicht eine schnellere Lösung wäre (nicht das deklarieren von array im Voraus):
```
IEnumerable<byte> bytesEnumerable = GetBytesFromList(list);

byte[] newArray = bytesEnumerable.ToArray();

private static IEnumerable<T> GetBytesFromList<T>(IEnumerable<IEnumerable<T>> list)
{
    foreach (IEnumerable<T> elements in list)
    {
        foreach (T element in elements)
        {
            yield return element;
        }
    }
}
```
Scheint es, wie oben würden Durchlaufen jedes array nur einmal.

Dieses sieht wie es funktionieren könnte, danke, ich gebe es zu gehen.
Beachten Sie, dass dieser Lösung ist O(n^2) in die Anzahl von byte-arrays. (Sehen Sie, warum? Hinweis: Sequenz-Operatoren sind faul.) Sie können es besser als die. Können Sie eine Lösung finden, die linear in der Anzahl der byte arrays?
danke! Es war nicht offensichtlich für mich, dass die Lösung ist O(n^2). Was ist, wenn ich verwenden Sie separate Methode, um zählbare form von bytes? Ich aktualisierte die Antwort.
Was ist Faulheit hat das damit zu tun? Non-lazy-Implementierung O(N^2) zu. Umgekehrt könnten Sie haben ein faul-Sequenz und O(N) Leistung. Das problem ist die benötigte Schnittstelle Verpackung - Sie müssen sukzessive wrap-Zähler - Sie können nicht erklären, eine Fortsetzung. Es ist nicht ganz fairer Vergleich, aber in, sagen wir, Haskell konzeptionell ähnlichen code würde zum Beispiel so faul, und O(N).
Natürlich könnte man verallgemeinern, dass auch weitere IEnumerable<R> Flatten<T R>(IEnumerable<T> Elemente, Func<T, IEnumerable<R>> selector) { foreach(T item in items) foreach(R Ergebnis im Selektor(Element)) yield return result; } und hey, Sie nur erfunden SelectMany; diese Methode ist bereits in der Sequenz-operator-Bibliothek.

InformationsquelleAutor Andrew Bezzub
0

Statt der Speicherung jedes byte-array in eine List<byte[]>, könnten Sie stattdessen fügen Sie Sie direkt auf eine List<byte> mit der AddRange Methode für jeden.

InformationsquelleAutor Justin
-1

hmm, wie etwa Liste.addrange?

Grund für die -1 ?
Tut AddRange konvertieren einer Liste in ein byte[]? Nein.

InformationsquelleAutor Fredou

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.