Liste <byte> und Kopieren von Byte-Arrays?

Question

Also arbeite ich mit einem Dateiformat. Das Dateiformat enthält Teile von Daten ... Also, was ich habe, ist ein Array von Listen für die "Chunks". Diese werden hinzugefügt, wenn ich der Klasse über eine Funktion Daten hinzufüge.

Jetzt, wenn ich die Datei speichern, muss ich einen Chunk am Anfang einfügen. Jetzt weiß ich, dass dies keinen Sinn ergibt, aber ich muss diesen Chunk hinzufügen (der leer ist), BEVOR ich die Datenoffsets für die Datentypen in den Chunks berechne. Wenn nicht, werden die Datenoffsets vermasselt. Nachdem ich diesen leeren Chunk eingefügt habe, erstelle ich dann ein neues byte [] -Array, in das ich die notwendigen Daten hineinkopiere, und überschreibe dann den leeren Chunk, den ich mit dem aktualisierten Byte-Array eingefügt habe.

Der Hauptgrund, warum ich dies tun muss, ist, weil das Datachunk, das ich einfüge, Offsets der anderen Daten enthält, also muss ich die Offsets erstellen, nachdem alles hinzugefügt wurde.

Im Grunde, was ich habe, ist dies (nur vereinfacht):

public struct SizeIndexPair { 
     public int Size; 
     public int Index; 
    }; 

    public class Chunks { 
     private Dictionary<int, SizeIndexPair> reserved; 
     public List<List<byte> > DataChunks; 

     ... 

     public void Reserve(int ID, int size, int index) { 
      SizeIndexPair sip; 
      sip.Size = size; 
      sip.Index = index; 
      reserved.Add(ID, sip); 
      List<byte> placeHolder = new List<byte>(size); 
      DataChunks.Insert(index, placeHolder); 
     } 

     public void Register(int ID, byte[] data) { 
      SizeIndexPair sip = reserved[ID]; 
      if (sip.Size != data.Length) 
       throw new IndexOutOfRangeException(); 
      for (int i = 0; i < data.Length; i++) { 
       DataChunks[sip.Index][i] = data[i]; 
      } 
     } 
    }; 

(Ich verwende List (Byte) hier, weil ich zusätzliche Daten zu einem vorhandenen Brocken könnte hinzufügen müssen)

Ich hoffe, ich mache Sinn.

Das Problem bei diesem Ansatz ist, dass ich das Array "verdopple", was mehr Speicher verbraucht. Außerdem kann der Prozess des Kopierens der Daten meine App ein wenig verlangsamen, besonders da die Datei typischerweise viele Daten enthält.

Gibt es einen besseren Ansatz dafür?

Eine Sache, die dies leicht gelöst hätte, ist das Fixieren der Liste, und anstatt das Array zu reservieren/registrieren, kann ich einfach direkt über einen Zeiger auf das Array zugreifen. Gibt es eine Möglichkeit, dies zu tun?

Danke für Ihre Hilfe.

Answer 1

Wenn das Ziel ist es, eine bestimmte Sammlung von Bytes vor dem Rest der Einträge einfügen in Ihre List<List<byte>> dann können Sie die Überlastung verwenden:

DataChunks.Insert(0, prefix); 

wo 0 den Index des Elements in der Sammlung darstellt, zu Einfügen vor und prefix ist der einzufügende Wert.

dann den resultierenden Byte-Strom zu erhalten:

foreach(byte b in DataChunks.SelectMany(c => c)) 
    Console.WriteLine(b); // replace with the method you use to write the `List of Lists of Bytes 

Answer 2

Sie sollten hier in der Funktion der Byte-Array namens „CopyTo“

Zum Beispiel ist ein alter Code von einem Netzwerk-Paket-Handler, ich schrieb vor einigen Jahren:

Public Sub SendData(ByVal Data() As Byte) 
    Try 
     Dim Length As Integer = Data.Length 
     Dim D() As Byte = BitConverter.GetBytes(Data.Length) 
     ReDim Preserve D(D.Length + Data.Length - 1) 
     Data.CopyTo(D, 4) 
     client.BeginSend(D, 0, D.Length, 0, AddressOf sockSendEnd, client) 
    Catch 
     RaiseEvent onError(Err.Description) 
    End Try 
End Sub