Dois-je appeler Close () ou Dispose () pour les objets de flux?

Classes telles que Stream, StreamReader, StreamWriteretc outils IDisposableinterface. Cela signifie que nous pouvons appeler la Dispose()méthode sur les objets de ces classes. Ils ont également défini une publicméthode appelée Close(). Maintenant, cela me trouble, que dois-je appeler une fois que j'ai fini avec les objets? Et si j'appelle les deux?

Mon code actuel est le suivant:

using (Stream responseStream = response.GetResponseStream())
{
   using (StreamReader reader = new StreamReader(responseStream))
   {
      using (StreamWriter writer = new StreamWriter(filename))
      {
         int chunkSize = 1024;
         while (!reader.EndOfStream)
         {
            char[] buffer = new char[chunkSize];
            int count = reader.Read(buffer, 0, chunkSize);
            if (count != 0)
            {
               writer.Write(buffer, 0, count);
            }
         }
         writer.Close();
      }
      reader.Close();
   }
}

Comme vous le voyez, j'ai écrit des using()constructions, qui appellent automatiquement la Dispose()méthode sur chaque objet. Mais j'appelle aussi des Close()méthodes. Est ce juste?

Veuillez me suggérer les meilleures pratiques lors de l'utilisation d'objets de flux. :-)

L'exemple MSDN n'utilise pas les using()constructions et la Close()méthode d' appel :

• Comment: télécharger des fichiers avec FTP

Est-ce bien?

Un saut rapide dans Reflector.NET montre que la Close()méthode sur StreamWriterest:

public override void Close()
{
    this.Dispose(true);
    GC.SuppressFinalize(this);
}

Et StreamReaderc'est:

public override void Close()
{
    this.Dispose(true);
}

Le Dispose(bool disposing)remplacement dans StreamReaderest:

protected override void Dispose(bool disposing)
{
    try
    {
        if ((this.Closable && disposing) && (this.stream != null))
        {
            this.stream.Close();
        }
    }
    finally
    {
        if (this.Closable && (this.stream != null))
        {
            this.stream = null;
            /* deleted for brevity */
            base.Dispose(disposing);
        }
    }
}

La StreamWriterméthode est similaire.

Ainsi, en lisant le code, il est clair que vous pouvez appeler Close()et Dispose()diffuser des flux aussi souvent que vous le souhaitez et dans n'importe quel ordre. Cela ne changera en rien le comportement.

Il s'agit donc de savoir s'il est ou non plus lisible à utiliser Dispose(), Close()et / ou using ( ... ) { ... }.

Ma préférence personnelle est que cela using ( ... ) { ... }devrait toujours être utilisé lorsque cela est possible car cela vous aide à "ne pas courir avec des ciseaux".

Mais, bien que cela contribue à l'exactitude, cela réduit la lisibilité. En C #, nous avons déjà une pléthore d'accolades fermantes, alors comment savoir laquelle effectue réellement la fermeture sur le flux?

Donc je pense qu'il est préférable de faire ceci:

using (var stream = ...)
{
    /* code */

    stream.Close();
}

Cela n'affecte pas le comportement du code, mais facilite la lisibilité.

Non, vous ne devez pas appeler ces méthodes manuellement. A la fin du usingbloc la Dispose()méthode est automatiquement appelée ce qui prendra soin de libérer les ressources non managées (au moins pour les classes standard .NET BCL telles que les flux, les lecteurs / écrivains, ...). Vous pouvez donc également écrire votre code comme ceci:

using (Stream responseStream = response.GetResponseStream())
    using (StreamReader reader = new StreamReader(responseStream))
        using (StreamWriter writer = new StreamWriter(filename))
        {
            int chunkSize = 1024;
            while (!reader.EndOfStream)
            {
                 char[] buffer = new char[chunkSize];
                 int count = reader.Read(buffer, 0, chunkSize);
                 if (count != 0)
                 {
                     writer.Write(buffer, 0, count);
                 }
            }
         }

La Close()méthode appelle Dispose().

La documentation dit que ces deux méthodes sont équivalentes:

StreamReader.Close : cette implémentation de Close appelle la méthode Dispose en passant une valeur vraie.

StreamWriter.Close : cette implémentation de Close appelle la méthode Dispose en passant une valeur vraie.

Stream.Close : cette méthode appelle Dispose, en spécifiant true pour libérer toutes les ressources.

Donc, les deux sont également valables:

/* Option 1, implicitly calling Dispose */
using (StreamWriter writer = new StreamWriter(filename)) { 
   // do something
} 

/* Option 2, explicitly calling Close */
StreamWriter writer = new StreamWriter(filename)
try {
    // do something
}
finally {
    writer.Close();
}

Personnellement, je m'en tiendrai à la première option, car elle contient moins de "bruit".

Sur de nombreuses classes prenant en charge les deux méthodes Close()et Dispose(), les deux appels seraient équivalents. Sur certaines classes, cependant, il est possible de rouvrir un objet qui a été fermé. Certaines de ces classes peuvent conserver certaines ressources actives après une fermeture, afin de permettre la réouverture; d'autres peuvent ne garder aucune ressource active Close(), mais peuvent activer un drapeau Dispose()pour interdire explicitement la réouverture.

Le contrat pour IDisposable.Disposeexige explicitement que l'appeler sur un objet qui ne sera plus jamais utilisé sera au pire inoffensif, donc je recommanderais d'appeler l'un IDisposable.Disposeou l' autre ou une méthode appelée Dispose()sur chaque IDisposableobjet, que l'on appelle également ou non Close().

C'est une vieille question, mais vous pouvez maintenant écrire en utilisant des instructions sans avoir à bloquer chacune d'elles. Ils seront éliminés dans l'ordre inverse lorsque le bloc contenant est terminé.

using var responseStream = response.GetResponseStream();
using var reader = new StreamReader(responseStream);
using var writer = new StreamWriter(filename);

int chunkSize = 1024;
while (!reader.EndOfStream)
{
    char[] buffer = new char[chunkSize];
    int count = reader.Read(buffer, 0, chunkSize);
    if (count != 0)
    {
        writer.Write(buffer, 0, count);
    }
}

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/using