Come passare da una matrice all'altra in C # attraverso più chiamate

Question

Abbiamo un'applicazione in cui è necessario serializzare alcuni dati da un flusso a più oggetti.

L'array di dati rappresenta un numero di messaggi di lunghezza variabile raggruppati insieme. Non ci sono codici di delimitazione dei messaggi nello stream.

Vogliamo fare qualcosa del tipo:

void Decode(byte[] Data)  
{  
    Object0.ExtractMessage(Data);
    Object1.ExtractMessage(Data);
    Object2.ExtractMessage(Data);
    ...
}  

dove ogni chiamata ProcessData sa da dove iniziare nell'array. Idealmente lo faremmo senza passare un riferimento DataIx in

Per fare ciò in C ++ avremmo semplicemente passato un puntatore nell'array e ogni funzione ProcessData lo avrebbe incrementato come richiesto.

Ogni classe di oggetti sa come i propri messaggi sono serializzati e su cui si può fare affidamento (in C ++) per restituire il puntatore all'inizio del messaggio successivo nello stream.

Esiste un meccanismo integrato che possiamo usare per farlo (senza andare non sicuro )? L'operazione è ad alta frequenza (~ 10kps) e molto leggera. Inoltre, non vogliamo andare a copiare o tagliare l'array.

Grazie per il tuo aiuto.

Answer 1

Non potresti semplicemente passare e restituire l'indice di array? Questo è fondamentalmente tutto ciò che un puntatore è comunque, un offset da una posizione di memoria fissa.

Answer 2

Bene, sembra che tu voglia un semplice stream (ad esempio, usa MemoryStream come un wrapper per l'array di byte: stream = new MemoryStream (data)). Avvolgi semplicemente l'array di byte in uno stream e ogni oggetto legge tutto il flusso necessario e quindi passa il flusso all'elemento successivo. Ha anche il vantaggio di non essere obbligato a caricare l'intero array di byte contemporaneamente.

A parte questo, puoi usare i puntatori in C # esattamente come hai fatto in C ++ (anche se i puntatori richiedono la parola chiave non sicura e sono sconsigliati)

In alternativa puoi semplicemente passare i dati e una variabile indice e quindi incrementare l'indice (che è, in effetti, lo stesso che usare un puntatore ma non necessita di rischi).

Answer 3

Che ne dite di avvolgere i dati in un MemoryStream e quindi passare uno StreamReader nel metodo ExtractMessage?

Answer 4

Credo che mi vengano in mente diverse cose.

È possibile simulare l'azione del puntatore avvolgendo il byte [] in una classe che mantiene anche l'offset dell'array. Ogni volta che si accede all'array, si accede ad esso attraverso la classe, probabilmente tramite un metodo accessor, che restituisce il byte successivo e incrementa anche la variabile offset. L'istanza della classe potrebbe essere passata tra le diverse chiamate della funzione ExtractMessage.

Che ne dici di usare C ++ / CLI? Ciò consentirebbe di utilizzare le tecniche familiari C / C ++ e di essere richiamabili direttamente da C # senza l'interoperabilità temuta.

Quindi ovviamente c'è l'opzione temuta non sicura, per cui si ottiene un puntatore C # sul byte [] ed si esegue l'aritmetica del puntatore richiesta.

Answer 5

È possibile creare un stream dall'array di byte.

Stream stream = new MemoryStream(data);

Quindi i processori potrebbero funzionare su stream.