La suppression de streamreader ferme-t-elle le flux?

J'envoie un flux aux méthodes sur lesquelles écrire, et dans ces méthodes, j'utilise un lecteur / rédacteur binaire. Lorsque le lecteur / écrivain est éliminé, soit par usingou juste quand il n'est pas référencé, le flux est-il également fermé?

J'enverrais un BinaryReader / Writer, mais j'utilise aussi un StreamReader (peut-être que je devrais contourner cela. Je ne l'utilise que pour GetLine et ReadLine). Ceci est assez gênant s'il ferme le flux chaque fois qu'un écrivain / lecteur est fermé.

Oui, StreamReader, StreamWriter, BinaryReaderet BinaryWritertout près / éliminer leurs flux sous - jacents lorsque vous appelez Disposesur eux. Cependant, ils ne suppriment pas le flux si le lecteur / écrivain est simplement ramassé - vous devez toujours vous débarrasser du lecteur / écrivain, de préférence avec une usinginstruction. (En fait, aucune de ces classes n'a de finaliseur, ni ne devrait en avoir.)

Personnellement, je préfère également avoir une instruction using pour le flux. Vous pouvez usingparfaitement imbriquer des instructions sans accolades:

using (Stream stream = ...)
using (StreamReader reader = new StreamReader(stream, Encoding.Whatever))
{
}

Même si l' usinginstruction pour le flux est quelque peu redondante (à moins que le StreamReaderconstructeur ne lève une exception), je considère que c'est la meilleure pratique, car si vous vous débarrassez de StreamReaderet utilisez simplement le flux directement à une date ultérieure, vous aurez déjà la bonne disposition sémantique.

C'est un ancien, mais je voulais faire quelque chose de similaire aujourd'hui et j'ai constaté que les choses avaient changé. Depuis .net 4.5, il y a un leaveOpenargument:

public StreamReader( Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen )

Le seul problème est qu'il n'est pas tout à fait évident de définir ce qu'il faut définir pour les autres paramètres. Voici de l'aide:

À partir de la page msdn pour StreamReader Constructor (Stream):

Ce constructeur initialise le codage à UTF8Encoding, la propriété BaseStream à l'aide du paramètre stream et la taille de la mémoire tampon interne à 1024 octets.

Cela laisse juste detectEncodingFromByteOrderMarksce qui à en juger par le code source esttrue

public StreamReader(Stream stream)
        : this(stream, true) {
}

public StreamReader(Stream stream, bool detectEncodingFromByteOrderMarks)
        : this(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize) {
}

Ce serait bien si certaines de ces valeurs par défaut étaient exposées ou si les arguments étaient facultatifs afin que nous puissions simplement spécifier ceux que nous voulons.

Oui. Vous pouvez le vérifier en regardant l'implémentation avec Reflector.

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;    
            this.encoding = null;
            this.decoder = null;
            this.byteBuffer = null;
            this.charBuffer = null;
            this.charPos = 0;
            this.charLen = 0;
            base.Dispose(disposing);
        }
    }
}

Six ans de retard mais peut-être que cela pourrait aider quelqu'un.

StreamReader ferme la connexion lorsqu'elle est supprimée. Cependant, "using (Stream stream = ...) {...}" avec StreamReader / StreamWriter peut entraîner la suppression du Stream deux fois: (1) lorsque l'objet StreamReader est supprimé (2) et lorsque le bloc Stream using se ferme. Cela entraîne un avertissement CA2202 lors de l'exécution de l'analyse de code de VS.

Une autre solution, tirée directement de la page CA2202 , consiste à utiliser un bloc try / finally. Configuration correctement, cela ne fermera la connexion qu'une seule fois.

Près du bas de CA2202 , Microsoft recommande d'utiliser les éléments suivants:

Stream stream = null;
try
{
    stream = new FileStream("file.txt", FileMode.OpenOrCreate);
    using (StreamWriter writer = new StreamWriter(stream))
    {
        stream = null;
        // Use the writer object...
    }
}
finally
{
    if(stream != null)
        stream.Dispose();
}

au lieu de...

// Generates a CA2202 warning
using (Stream stream = new FileStream("file.txt", FileMode.Open))
using (XmlReader reader = new XmlReader (stream))
{
    // Use the reader object...
}

Oui. L'appel de Dispose () on et IDisposable (ce que fait "using") devrait permettre à un objet de nettoyer toutes ses ressources. Cela inclut le vidage des flux et la fermeture de leurs descripteurs de fichiers.

Si, dans votre cas, vous souhaitez le passer à d'autres méthodes, vous devez vous assurer que ces méthodes ne font pas leur lecture / écriture dans un bloc using.

Un moyen simple de résoudre ce problème si vous en avez besoin est de remplacer la méthode Dispose des classes StreamWriter. Voir mon message ici pour le code sur la façon de le faire:

.Disposing a StreamWriter ferme-t-il le flux sous-jacent?

le flux éliminé soit en "utilisant" le mot-clé ou en appelant explicitement dispose