Une fuite de mémoire est-elle créée si un MemoryStream en .NET n'est pas fermé ?

Question

J'ai le code suivant :

MemoryStream foo(){
    MemoryStream ms = new MemoryStream();
    // write stuff to ms
    return ms;
}

void bar(){
    MemoryStream ms2 = foo();
    // do stuff with ms2
    return;
}

Y a-t-il une chance que le MemoryStream que j'ai alloué ne soit pas éliminé plus tard ?

J'ai un examen par les pairs qui insiste pour que je ferme manuellement ce dossier, et je n'arrive pas à trouver les informations qui me permettraient de savoir si son point de vue est valable ou non.

Answer 1

Vous ne fuirez rien - du moins dans l'implémentation actuelle.

L'appel à Dispose ne nettoiera pas plus rapidement la mémoire utilisée par MemoryStream. Il s'agit de se empêche votre flux d'être viable pour les appels de lecture/écriture après l'appel, ce qui peut ou non vous être utile.

Si vous êtes absolument sûr que vous jamais vous voulez passer d'un MemoryStream à un autre type de flux, vous ne risquez rien à ne pas appeler Dispose. Cependant, c'est généralement une bonne pratique, en partie parce que si jamais vous faire changer pour utiliser un autre Stream, vous ne voulez pas vous faire piquer par un bug difficile à trouver parce que vous avez choisi la solution de facilité dès le début. (D'un autre côté, il y a l'argument YAGNI...)

L'autre raison de le faire quand même est qu'une nouvelle implémentation mai introduire des ressources qui seraient libérées lors du Dispose.

Answer 2

Si un objet est jetable, vous devez toujours le jeter. Vous devez utiliser un using dans votre bar() pour s'assurer que ms2 est éliminé.

Il sera éventuellement nettoyé par le ramasseur d'ordures, mais il est toujours bon d'appeler Dispose. Si vous exécutez FxCop sur votre code, il le signalera comme un avertissement.

Answer 3

Oui, il y a a fuite selon la définition que vous donnez à une FUITE et le temps écoulé...

Si par "fuite" vous entendez "la mémoire reste allouée, non disponible pour l'utilisation, même si vous avez fini de l'utiliser" et par "dernière" vous entendez n'importe quel moment après avoir appelé "dispose", alors oui, il peut y avoir une fuite, bien qu'elle ne soit pas permanente (c'est-à-dire pour toute la durée d'exécution de vos applications).

Pour libérer la mémoire gérée utilisée par le MemoryStream, vous devez le déréférencer en annulant votre référence à celui-ci, de sorte qu'il devient immédiatement éligible à la collecte des déchets. Si vous ne le faites pas, vous créez une fuite temporaire à partir du moment où vous avez fini de l'utiliser, jusqu'à ce que votre référence sorte du champ d'application, car entre-temps la mémoire ne sera pas disponible pour l'allocation.

L'avantage de l'instruction using (par rapport au simple appel à la fonction dispose) est que vous pouvez DECLARE votre référence dans l'instruction using. À la fin de l'instruction using, non seulement l'instruction dispose est appelée, mais votre référence sort de sa portée, ce qui annule effectivement la référence et rend votre objet éligible à la collecte des déchets immédiatement, sans que vous ayez à vous souvenir d'écrire le code "reference=null".

Bien que le fait de ne pas déréférencer quelque chose immédiatement ne constitue pas une fuite de mémoire "permanente" classique, cela a certainement le même effet. Par exemple, si vous gardez votre référence au MemoryStream (même après avoir appelé dispose), et qu'un peu plus loin dans votre méthode vous essayez d'allouer plus de mémoire... la mémoire utilisée par votre flux de mémoire toujours référencé ne sera pas disponible pour vous jusqu'à ce que vous annuliez la référence ou qu'elle sorte de la portée, même si vous avez appelé dispose et que vous avez fini de l'utiliser.

Answer 4

La réponse à cette question a déjà été donnée, mais j'ajouterai simplement que le bon vieux principe de la dissimulation de l'information signifie qu'il se peut qu'à un moment donné, vous souhaitiez procéder à une refonte :

MemoryStream foo()
{    
    MemoryStream ms = new MemoryStream();    
    // write stuff to ms    
    return ms;
}

à :

Stream foo()
{    
   ...
}

Cela souligne le fait que les appelants ne doivent pas se soucier du type de Stream renvoyé et permet de modifier l'implémentation interne (par exemple, lors de la création de simulateurs pour les tests unitaires).

Vous aurez alors besoin d'être en difficulté si vous n'avez pas utilisé Dispose dans votre implémentation de la barre :

void bar()
{    
    using (Stream s = foo())
    {
        // do stuff with s
        return;
    }
}

Answer 5

Tous les flux implémentent IDisposable. Enveloppez votre flux de mémoire dans une déclaration using et tout ira bien. Le bloc using garantit que votre flux est fermé et mis au rebut quoi qu'il arrive.

Chaque fois que vous appelez Foo, vous pouvez faire using(MemoryStream ms = foo()) et je pense que tout devrait bien se passer.