Gibt es eine bessere determinis Verfügung Muster als verschachtelt „mit“ s?

Question

In C #, wenn ich will deterministisch bereinigen, nicht verwalteten Ressourcen, kann ich das „mit“ Schlüsselwort verwenden. Aber für mehrere abhängige Objekte, diese endet weiter und weiter verschachteln:

using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
{
    using (BufferedStream bs = new BufferedStream(fs))
    {
        using (StreamReader sr = new StreamReader(bs))
        {
            // use sr, and have everything cleaned up when done.
        }
    }
}

In C ++, ich verwende, um Destruktoren in der Lage, es zu benutzen, wie dies zu tun:

{    
    FileStream fs("c:\file.txt", FileMode.Open);
    BufferedStream bs(fs);
    StreamReader sr(bs);
    // use sr, and have everything cleaned up when done.
}

Gibt es eine bessere Art und Weise in C #, dies zu tun? Oder bin ich mit den verschiedenen Ebenen der Verschachtelung stecken?

Answer 1

Sie haben nicht zu Nest mit mehreren usings:

using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
    // all three get disposed when you're done
}

Answer 2

Sie können mit Aussagen zusammen, bevor die Öffnung Zahnspange wie folgt:

  using (StreamWriter w1 = File.CreateText("W1"))
  using (StreamWriter w2 = File.CreateText("W2"))
  {
      // code here
  }

http://blogs.msdn.com/ericgu /archive/2004/08/05/209267.aspx

Answer 3

Sie könnten diese Syntax verwenden, um Dinge zu kondensieren etwas nach unten:

using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
}

Dies ist eine der seltenen Gelegenheiten, bei denen nicht mit {} für alle Blöcke Sinn IMHO machen.

Answer 4

Anstelle der Verwendung von Aussagen nisten, können Sie schreiben gerade die .Dispose ruft manuell -. Aber Sie werden mit ziemlicher Sicherheit ein irgendwann vermissen

Entweder laufen FxCop oder etwas anderes, das sicherstellen kann, dass alle IDisposable-Implementierung Typinstanzen eine .Dispose () -Aufruf haben oder mit der Verschachtelung befassen.

Answer 5

Ich habe implementiert Lösungen wie

können Sie die geschweiften Klammern weglassen, wie:

using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
        // use sr, and have everything cleaned up when done.
}

oder den regulären Versuch schließlich Ansatz verwenden:

FileStream fs = new FileStream("c:\file.txt", FileMode.Open);
BufferedStream bs = new BufferedStream(fs);
StreamReader sr = new StreamReader(bs);
try
{
        // use sr, and have everything cleaned up when done.
}finally{
   sr.Close(); // should be enough since you hand control to the reader
}

Das macht für ein viel größeres Netto-Plus in Codezeilen, sondern eine greifbare Verstärkung in Lesbarkeit:

using (StreamWrapper wrapper = new StreamWrapper("c:\file.txt", FileMode.Open))
{
    // do stuff using wrapper.Reader
}

Wo StreamWrapper ist hier definiert:

private class StreamWrapper : IDisposable
{
    private readonly FileStream fs;
    private readonly BufferedStream bs;
    private readonly StreamReader sr;

    public StreamWrapper(string fileName, FileMode mode)
    {
        fs = new FileStream(fileName, mode);
        bs = new BufferedStream(fs);
        sr = new StreamReader(bs);
    }

    public StreamReader Reader
    {
        get { return sr; }
    }

    public void Dispose()
    {
        sr.Dispose();
        bs.Dispose();
        fs.Dispose();
    }
}

Mit einiger Mühe StreamWrapper Refactoring werden könnte allgemeinere und wiederverwendbar zu sein.

Es ist zu beachten, dass in der Regel, wenn Strom zu schaffen, die man schließt einen anderen Strom der neuen Stream basiert weg in weitergegeben werden also weiter zu reduzieren Ihr Beispiel:.

using (Stream Reader sr = new StreamReader( new BufferedStream( new FileStream("c:\file.txt", FileMode.Open))))
{
    // all three get disposed when you're done
}

Für dieses Beispiel nehmen wir an, Sie haben:

eine Datei mit dem Namen 1.xml unter c: \

ein Textfeld namens textBox1, mit den mehrzeiligen Eigenschaften auf EIN.

const string fname = @"c:\1.xml";

StreamReader sr=new StreamReader(new BufferedStream(new FileStream(fname,FileMode.Open,FileAccess.Read,FileShare.Delete)));
textBox1.Text = sr.ReadToEnd();

Die using-Anweisung ist syntaktischer Zucker, die konvertiert:

   try
   {
      obj declaration
      ...
   }
   finally
   {
      obj.Dispose();
   }

Sie können Dispose explizit aufrufen auf Ihre Objekte, aber es wird nicht so sicher sein, denn wenn einer von ihnen eine Ausnahme auslöst, werden die Ressourcen nicht ordnungsgemäß freigegeben werden.

Answer 6

Answer 7

Answer 8

können Sie die geschweiften Klammern weglassen, wie:

using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
        // use sr, and have everything cleaned up when done.
}

oder den regulären Versuch schließlich Ansatz verwenden:

FileStream fs = new FileStream("c:\file.txt", FileMode.Open);
BufferedStream bs = new BufferedStream(fs);
StreamReader sr = new StreamReader(bs);
try
{
        // use sr, and have everything cleaned up when done.
}finally{
   sr.Close(); // should be enough since you hand control to the reader
}

Answer 9

Das macht für ein viel größeres Netto-Plus in Codezeilen, sondern eine greifbare Verstärkung in Lesbarkeit:

using (StreamWrapper wrapper = new StreamWrapper("c:\file.txt", FileMode.Open))
{
    // do stuff using wrapper.Reader
}

Wo StreamWrapper ist hier definiert:

private class StreamWrapper : IDisposable
{
    private readonly FileStream fs;
    private readonly BufferedStream bs;
    private readonly StreamReader sr;

    public StreamWrapper(string fileName, FileMode mode)
    {
        fs = new FileStream(fileName, mode);
        bs = new BufferedStream(fs);
        sr = new StreamReader(bs);
    }

    public StreamReader Reader
    {
        get { return sr; }
    }

    public void Dispose()
    {
        sr.Dispose();
        bs.Dispose();
        fs.Dispose();
    }
}

Mit einiger Mühe StreamWrapper Refactoring werden könnte allgemeinere und wiederverwendbar zu sein.

Es ist zu beachten, dass in der Regel, wenn Strom zu schaffen, die man schließt einen anderen Strom der neuen Stream basiert weg in weitergegeben werden also weiter zu reduzieren Ihr Beispiel:.

using (Stream Reader sr = new StreamReader( new BufferedStream( new FileStream("c:\file.txt", FileMode.Open))))
{
    // all three get disposed when you're done
}

Für dieses Beispiel nehmen wir an, Sie haben:

eine Datei mit dem Namen 1.xml unter c: \

ein Textfeld namens textBox1, mit den mehrzeiligen Eigenschaften auf EIN.

const string fname = @"c:\1.xml";

StreamReader sr=new StreamReader(new BufferedStream(new FileStream(fname,FileMode.Open,FileAccess.Read,FileShare.Delete)));
textBox1.Text = sr.ReadToEnd();

Die using-Anweisung ist syntaktischer Zucker, die konvertiert:

   try
   {
      obj declaration
      ...
   }
   finally
   {
      obj.Dispose();
   }

Sie können Dispose explizit aufrufen auf Ihre Objekte, aber es wird nicht so sicher sein, denn wenn einer von ihnen eine Ausnahme auslöst, werden die Ressourcen nicht ordnungsgemäß freigegeben werden.

Answer 10

Das macht für ein viel größeres Netto-Plus in Codezeilen, sondern eine greifbare Verstärkung in Lesbarkeit:

using (StreamWrapper wrapper = new StreamWrapper("c:\file.txt", FileMode.Open))
{
    // do stuff using wrapper.Reader
}

Wo StreamWrapper ist hier definiert:

private class StreamWrapper : IDisposable
{
    private readonly FileStream fs;
    private readonly BufferedStream bs;
    private readonly StreamReader sr;

    public StreamWrapper(string fileName, FileMode mode)
    {
        fs = new FileStream(fileName, mode);
        bs = new BufferedStream(fs);
        sr = new StreamReader(bs);
    }

    public StreamReader Reader
    {
        get { return sr; }
    }

    public void Dispose()
    {
        sr.Dispose();
        bs.Dispose();
        fs.Dispose();
    }
}

Mit einiger Mühe StreamWrapper Refactoring werden könnte allgemeinere und wiederverwendbar zu sein.

Answer 11

Es ist zu beachten, dass in der Regel, wenn Strom zu schaffen, die man schließt einen anderen Strom der neuen Stream basiert weg in weitergegeben werden also weiter zu reduzieren Ihr Beispiel:.

using (Stream Reader sr = new StreamReader( new BufferedStream( new FileStream("c:\file.txt", FileMode.Open))))
{
    // all three get disposed when you're done
}

Answer 12

Für dieses Beispiel nehmen wir an, Sie haben:

eine Datei mit dem Namen 1.xml unter c: \

ein Textfeld namens textBox1, mit den mehrzeiligen Eigenschaften auf EIN.

const string fname = @"c:\1.xml";

StreamReader sr=new StreamReader(new BufferedStream(new FileStream(fname,FileMode.Open,FileAccess.Read,FileShare.Delete)));
textBox1.Text = sr.ReadToEnd();

Answer 13

Die using-Anweisung ist syntaktischer Zucker, die konvertiert:

   try
   {
      obj declaration
      ...
   }
   finally
   {
      obj.Dispose();
   }

Sie können Dispose explizit aufrufen auf Ihre Objekte, aber es wird nicht so sicher sein, denn wenn einer von ihnen eine Ausnahme auslöst, werden die Ressourcen nicht ordnungsgemäß freigegeben werden.

Answer 14

Answer 15