utilisez MemoryStream

Mon code utilise MemoryStream de sérialiser/désérialiser des objets vers/à partir du réseau. Je tiens à re-utiliser un seul MemoryStream dans ma classe, plutôt que d'en créer un nouveau à chaque fois que j'ai besoin
pour envoyer quelque chose sur le fil.

Personne ne sait comment faire cela?

Extrait de Code:

    //Serialize object to buffer
    public  byte[] Serialize(object value)
    {
        if (value == null)
            return null;
      MemoryStream _memoryStream = new MemoryStream();

        _memoryStream.Seek(0, 0);
        _bf.Serialize(_memoryStream, value);
        return _memoryStream.GetBuffer();
    }

    //Deserialize buffer to object
    public  object Deserialize(byte[] someBytes)
    {         
        if (someBytes == null)
            return null;
        MemoryStream _memoryStream = new MemoryStream();
        _memoryStream.Write(someBytes, 0, someBytes.Length);
        _memoryStream.Seek(0, 0);
        var de = _bf.Deserialize(_memoryStream);
        return de;
    }

Merci!

Quelle est la raison de réutilisation des flux? Il sonne comme une manière assez facile à introduire memoryleaks et difficile à déboguer le code.
+1 sur le commentaire de @Richard. Ne pas le faire, sauf si vous avez présenté le code et trouvé que c'était une prestation ou d'un problème de mémoire.
Merci, les gars. Je suppose que j'ai oublié ce que quelqu'un a dit une fois à propos de l'optimisation prématurée......

OriginalL'auteur Jacko | 2011-01-07

c#memorystream reset

8

Tout d'abord votre méthode serialize a un bug:

Noter que la mémoire tampon contient alloué octets qui peuvent être utilisés. Par exemple, si la chaîne "test" est écrit dans l'objet MemoryStream, la longueur de la mémoire tampon retourné à partir de GetBuffer est de 256, pas 4, avec 252 octets inutilisés. Pour obtenir uniquement les données dans la mémoire tampon, utilisez la méthode ToArray; cependant, ToArray crée une copie des données dans la mémoire.

c'est à dire le tableau des rendements est plus grande que les données sérialisées

Pour la désérialisation, vous pouvez construire un flux de mémoire qui utilise le passé dans la gamme, afin de ne pas allouer des tampons internes. Mais à moins d'avoir des repères qui montrent que les flux de mémoire allocation est vraiment un goulot d'étranglement je ne voudrais pas ennuyer.

Si vous voulez vraiment optimiser vos allocations de mémoire, vous aurez besoin de réutiliser le byte[] tampons. Ce qui implique en particulier la modification de l'api pour travailler avec des sous-sections de tableaux de sorte que le message de la taille et de la taille du tableau n'a pas besoin d'être identiques.

Suivants sont des détails d'implémentation qui peut changer à tout moment(et peut-être déjà changé depuis que j'ai lu à ce sujet):

C'est sûrement de ne pas se donner la peine si les tampons ne pas finir sur le tas d'objets volumineux. Si les objets sont petits, ils vont être bon marché recueillies sur la prochaine Gen0 collection. Le gros tas d'objets sur l'autre main directement finit dans Gen2. AFAIR objets >250kB sont alloués.

Et bien sûr la réutilisation de la mémoire, sans jamais rétrécir, peut être une fuite de mémoire.

+1 pour la grande observation.
Wow, merci, CodeInChaos!! Je me demandais pourquoi j'étais 256 tableaux d'octets.

OriginalL'auteur CodesInChaos

En réutilisant les mêmes MemoryStream ne vous donne aucun avantage en matière de performances.

Il ya une raison pourquoi MemoryStream n'est pas clair. Parce qu'il serait plus coûteux pour l'effacer plutôt que d'en créer un nouveau.

Si vous regardez à l'intérieur de la classe, vous pouvez voir qu'il alloue un tampon, et lors de l'écriture, si le tampon est plein, il alloue un nouveau tampon et copier des octets et l'emporte alors sur. D'une manière dans la mémoire tampon est immuable.

Cela peut être vu ici à la fixation de la capacité qui est appelé par EnsureCapacity() au moment de la rédaction:

public virtual int Capacity
{
    get
    {
        if (!this._isOpen)
        {
            __Error.StreamIsClosed();
        }
        return (this._capacity - this._origin);
    }
    [SecuritySafeCritical]
    set
    {
        if (value < this.Length)
        {
            throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
        }
        if (!this._isOpen)
        {
            __Error.StreamIsClosed();
        }
        if (!this._expandable && (value != this.Capacity))
        {
            __Error.MemoryStreamNotExpandable();
        }
        if (this._expandable && (value != this._capacity))
        {
            if (value > 0)
            {
                byte[] dst = new byte[value];
                if (this._length > 0)
                {
                    Buffer.InternalBlockCopy(this._buffer, 0, dst, 0, this._length);
                }
                this._buffer = dst;
            }
            else
            {
                this._buffer = null;
            }
            this._capacity = value;
        }
    }
}

SetLength(0) est effectivement un clair. Et je suppose qu'il offre des avantages de performance(pour les tampons de grande taille) par la réutilisation de la mémoire tampon. Mais probablement pas encore en vaut la peine.
Faux! Si vous faites quelque chose de bas niveau assez pour, de réutiliser et de non-réutilisation de la mémoire tampon d'un flux de mémoire de la matière, vous voulez le réutiliser.

OriginalL'auteur Aliostad

Vous devez vous connecter pour publier un commentaire.