Comment itérer dans un tableau en C # lors d'appels multiples

Question

Nous avons une application dans laquelle nous devons désérialiser certaines données d’un flux en plusieurs objets.

Le tableau de données représente un certain nombre de messages de longueur variable regroupés. Il n'y a pas de code de délimitation de message dans le flux.

Nous voulons faire quelque chose comme:

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

où chaque appel ProcessData sait par où commencer dans le tableau. Idéalement, nous ferions cela sans passer une référence DataIx dans.

Pour faire cela en C ++, il suffit de placer un pointeur dans le tableau et chaque fonction ProcessData l'incrémente selon les besoins.

Chaque classe d'objet sait comment ses propres messages sont sérialisés et on peut s'y fier (en C ++) pour renvoyer le pointeur au début du message suivant dans le flux.

Existe-t-il un mécanisme intégré que nous pouvons utiliser pour cela (sans passer au non sécurisé )? Le fonctionnement est haute fréquence (~ 10kps) et très léger. Nous ne voulons pas non plus copier ou couper le tableau.

Merci de votre aide.

Answer 1

Ne pouvez-vous pas simplement passer et renvoyer l'index du tableau? C'est en gros tout ce qu'un pointeur est de toute façon, un décalage par rapport à un emplacement de mémoire fixe.

Answer 2

Cela donne l’impression que vous voulez un flux simple (par exemple, utilisez simplement MemoryStream pour encapsuler votre tableau d’octets: stream = new MemoryStream (données)). Emballez simplement le tableau d’octets dans un flux et chaque objet lit autant de fois qu'il le faut dans le flux, puis le transfère au prochain élément. Il a même l'avantage de ne pas être obligé de charger tout le tableau d'octets à la fois.

Sinon, vous pouvez utiliser les pointeurs en C # exactement comme vous l'avez fait en C ++ (bien que les pointeurs nécessitent le mot clé unsafe et qu'ils soient déconseillés)

Vous pouvez également simplement transmettre des données et une variable d'index, puis incrémenter l'index (ce qui revient à utiliser un pointeur, mais vous n'avez pas besoin de sécurité.)

.

Answer 3

Pourquoi ne pas encapsuler les données dans un MemoryStream et ensuite transmettre un StreamReader à la méthode ExtractMessage?

Answer 4

Je suppose que plusieurs choses me viennent à l'esprit.

Vous pouvez simuler l'action du pointeur en encapsulant l'octet [] dans une classe qui conserve également le décalage du tableau. Chaque fois que vous accédez au tableau, vous y accéderez via la classe, probablement via une méthode d'accès, qui renvoyait l'octet suivant et incrémentait également la variable offset. L’instance de la classe peut être transmise entre les différents appels de fonction ExtractMessage.

Pourquoi utiliser C ++ / CLI? Cela vous permettrait d’utiliser des techniques C / C ++ familières tout en étant directement appelable à partir de C # sans l’interopérabilité redoutable.

Ensuite, bien sûr, il existe l’option redoutée, qui consiste à obtenir un pointeur C # sur l’octet [] et à effectuer l’arithmétique de pointeur requise.

Answer 5

Vous pouvez créer un flux à partir du tableau d'octets.

Stream stream = new MemoryStream(data);

Ensuite, votre processeur pourrait utiliser des flux.