Tamponner les données de l'octet en C #

Il suffit d'utiliser un grand tableau d'octets et de la Matrice.La copie, il devrait faire l'affaire.
Si non, utilisez List<byte>.

Si vous utilisez le tableau que vous avez à mettre en œuvre un index (où vous copiez des données supplémentaires) vous-même (même pour vérifier le contenu de taille), mais il est simple.

Si vous êtes intéressés: ici est une simple mise en œuvre d'un "tampon cyclique". Le test doit être exécuté (j'ai jeté un couple de test de l'unité à elle, mais il n'a pas vérifier tous les de chemin critique):

public class ReadWriteBuffer
{
private readonly byte[] _buffer;
private int _startIndex, _endIndex;
public ReadWriteBuffer(int capacity)
{
_buffer = new byte[capacity];
}
public int Count
{
get
{
if (_endIndex > _startIndex)
return _endIndex - _startIndex;
if (_endIndex < _startIndex)
return (_buffer.Length - _startIndex) + _endIndex;
return 0;
}
}
public void Write(byte[] data)
{
if (Count + data.Length > _buffer.Length)
throw new Exception("buffer overflow");
if (_endIndex + data.Length >= _buffer.Length)
{
var endLen = _buffer.Length - _endIndex;
var remainingLen = data.Length - endLen;
Array.Copy(data, 0, _buffer, _endIndex, endLen);
Array.Copy(data, endLen, _buffer, 0, remainingLen);
_endIndex = remainingLen;
}
else
{
Array.Copy(data, 0, _buffer, _endIndex, data.Length);
_endIndex += data.Length;
}
}
public byte[] Read(int len, bool keepData = false)
{
if (len > Count)
throw new Exception("not enough data in buffer");
var result = new byte[len];
if (_startIndex + len < _buffer.Length)
{
Array.Copy(_buffer, _startIndex, result, 0, len);
if (!keepData)
_startIndex += len;
return result;
}
else
{
var endLen = _buffer.Length - _startIndex;
var remainingLen = len - endLen;
Array.Copy(_buffer, _startIndex, result, 0, endLen);
Array.Copy(_buffer, 0, result, endLen, remainingLen);
if (!keepData)
_startIndex = remainingLen;
return result;
}
}
public byte this[int index]
{
get
{
if (index >= Count)
throw new ArgumentOutOfRangeException();
return _buffer[(_startIndex + index) % _buffer.Length];
}
}
public IEnumerable<byte> Bytes
{
get
{
for (var i = 0; i < Count; i++)
yield return _buffer[(_startIndex + i) % _buffer.Length];
}
}
}

Veuillez noter: le code "consomme" à la lecture si vous ne voulez pas qu'il suffit de retirer le "_startIndex = ..." de pièces (ou de faire une surcharge de paramètre facultatif et de contrôler ou de quoi que ce soit).

Voici une autre mise en œuvre d'un tampon que j'ai écrit il y a longtemps:

• Redimensionnables: permettre à la file d'attente de données et ne pas jeter débordement de la mémoire tampon d'exception;
• Efficace: utilise un seul tampon et Tampon.Opérations de copie pour mettre en file d'attente/file d'attente de données

Je pense que BufferedStream est la solution au problème. Il est également possible d'aller non lus len octet de données en appelant les Chercher.

BufferdStream buffer = new BufferedStream(tcpStream, size); //we have a buffer of size
...
...
while(...)
{
buffer.Read(...);
//do my staff
//I read too much, I want to put back len bytes
buffer.Seek(-len, SeekOrigin.End);
//I shall come back and read later
}

Croissante de la mémoire

Contrairement à BufferedStream où la size est spécifié initialement, MemoryStream peut se développer.

Se souvenir de flux de données en continu

MemoryStream détient tous les dara-lire tout le temps, alors que BufferedStream ne détient qu'un segment de flux de données.

Cours d'eau de Source vs tableau d'octets

MemoryStream permet d'ajouter des entrées-octets dans Write() méthode qui peut être Read() à l'avenir. Alors que BufferedSteam prend en entrée-octets à partir d'une autre source-flux spécifié dans le constructeur.

Vous pouvez le faire avec un Stream l'enveloppant d'un ConcurrentQueue<ArraySegment<byte>> (gardez à l'esprit ce fait en avant uniquement). Cependant, je n'aime vraiment pas l'idée de conserver les données en mémoire avant de faire quelque chose avec elle; il vous ouvre à tout un tas d'attaques (intentionnelle ou non) à propos de la taille du message. Vous pouvez également Google "tampon circulaire".

En fait, vous devez écrire du code qui n'quelque chose de significatif avec les données dès qu'il est reçu: "Pousser l'Analyse" (c'est ce que, par exemple, SAXOPHONE prend en charge). Comme un exemple de la façon dont vous le faire avec du texte:

private Encoding _encoding;
private Decoder _decoder;
private char[] _charData = new char[4];
public PushTextReader(Encoding encoding)
{
_encoding = encoding;
_decoder = _encoding.GetDecoder();
}
//A single connection requires its own decoder
//and charData. That connection should never
//call this method from multiple threads
//simultaneously.
//If you are using the ReadAsyncLoop you
//don't need to worry about it.
public void ReceiveData(ArraySegment<byte> data)
{
//The two false parameters cause the decoder
//to accept 'partial' characters.
var charCount = _decoder.GetCharCount(data.Array, data.Offset, data.Count, false);
charCount = _decoder.GetChars(data.Array, data.Offset, data.Count, _charData, 0, false);
OnCharacterData(new ArraySegment<char>(_charData, 0, charCount));
}

Si vous doit être en mesure d'accepter les messages dans leur intégralité avant de la désérialisation, vous pouvez utiliser un MemoryMappedFilequi a l'avantage de l'envoi de l'entité ne sera pas en mesure de out-of-mémoire de votre serveur. Ce qui est difficile est de réinitialiser le fichier de retour à zéro; car qui peut tas de questions. Une façon de lutter contre cela est de:

TCP Récepteur Fin

1. Écrire pour le stream actuel.
2. Si le flux dépasse une certaine longueur de passer à un nouveau.

Désérialisation Fin

1. Lire à partir du courant de flot.
2. Une fois que vous avez vidé le flux de la détruire.

Le TCP récepteur fin est très simple. Le deserializer fin aurez besoin élémentaire de la mémoire tampon de couture logique (n'oubliez pas d'utiliser Buffer.BlockCopy et pas Array.Copy).

Note de côté: Sonne comme un projet amusant, si j'ai le temps et rappelez-vous que je puisse aller de l'avant et de mettre en œuvre ce système.