Rückkehr in die Mitte eines using-Blocks

Etwas wie:

using (IDisposable disposable = GetSomeDisposable())
{
    //.....
    //......
    return Stg();
}

Ich glaube, es ist kein geeigneter Ort für eine Rückgabeerklärung, oder?

Wie mehrere andere allgemein betont haben, ist dies kein Problem.

Der einzige Fall, der Probleme verursacht, ist, wenn Sie in der Mitte einer using-Anweisung und zusätzlich die Variable in using zurückgeben. Andererseits würde dies auch zu Problemen führen, selbst wenn Sie nicht zurückkehren und einfach einen Verweis auf eine Variable behalten.

using ( var x = new Something() ) { 
  // not a good idea
  return x;
}

Genauso schlimm

Something y;
using ( var x = new Something() ) {
  y = x;
}

Es ist vollkommen in Ordnung.

Sie denken das anscheinend

using (IDisposable disposable = GetSomeDisposable())
{
    //.....
    //......
    return Stg();
}

wird blind übersetzt in:

IDisposable disposable = GetSomeDisposable()
//.....
//......
return Stg();
disposable.Dispose();

Was zugegebenermaßen ein Problem wäre und die usingAussage ziemlich sinnlos machen würde - weshalb dies nicht der Fall ist.

Der Compiler stellt sicher, dass das Objekt entsorgt wird, bevor die Steuerung den Block verlässt - unabhängig davon, wie sie den Block verlässt.

Es ist absolut in Ordnung - überhaupt kein Problem. Warum glaubst du, ist es falsch?

Eine using-Anweisung ist nur syntaktischer Zucker für einen try / finally-Block, und wie Grzenio sagt, ist es in Ordnung, auch von einem try-Block zurückzukehren.

Der Rückgabeausdruck wird ausgewertet, dann wird der finally-Block ausgeführt, und die Methode wird zurückgegeben.

Dies wird einwandfrei funktionieren, genauso wie die Rückkehr in die Mitte von try{}finally{}

Das ist völlig akzeptabel. Eine using- Anweisung stellt sicher, dass das IDisposable-Objekt unabhängig davon entsorgt wird.

Von MSDN :

Die using-Anweisung stellt sicher, dass Dispose aufgerufen wird, auch wenn beim Aufrufen von Methoden für das Objekt eine Ausnahme auftritt. Sie können das gleiche Ergebnis erzielen, indem Sie das Objekt in einen try-Block einfügen und dann Dispose in einem finally-Block aufrufen. Auf diese Weise wird die using-Anweisung vom Compiler übersetzt.

Der folgende Code zeigt, wie usinges funktioniert:

private class TestClass : IDisposable
{
   private readonly string id;

   public TestClass(string id)
   {
      Console.WriteLine("'{0}' is created.", id);
      this.id = id;
   }

   public void Dispose()
   {
      Console.WriteLine("'{0}' is disposed.", id);
   }

   public override string ToString()
   {
      return id;
   }
}

private static TestClass TestUsingClose()
{
   using (var t1 = new TestClass("t1"))
   {
      using (var t2 = new TestClass("t2"))
      {
         using (var t3 = new TestClass("t3"))
         {
            return new TestClass(String.Format("Created from {0}, {1}, {2}", t1, t2, t3));
         }
      }
   }
}

[TestMethod]
public void Test()
{
   Assert.AreEqual("Created from t1, t2, t3", TestUsingClose().ToString());
}

Ausgabe:

't1' wird erstellt.
't2' wird erstellt.
't3' wird erstellt.
'Erstellt aus t1, t2, t3' wird erstellt.
't3' ist entsorgt.
't2' ist entsorgt.
't1' ist entsorgt.

Die disposed werden nach der return-Anweisung, jedoch vor dem Beenden der Funktion aufgerufen.

Vielleicht ist es nicht 100% wahr, dass dies akzeptabel ist ...

Wenn Sie zufällig Benutzer verschachteln und aus einem verschachtelten zurückkehren, ist dies möglicherweise nicht sicher.

Nehmen Sie dies als Beispiel:

using (var memoryStream = new MemoryStream())
{
    using (var textwriter = new StreamWriter(memoryStream))
    {
        using (var csv = new CsvWriter(textwriter))
        {
            //..write some stuff to the stream using the CsvWriter
            return memoryStream.ToArray();
        }
    }
}

Ich habe eine DataTable übergeben, die als CSV ausgegeben werden soll. Mit der Rückgabe in der Mitte wurden alle Zeilen in den Stream geschrieben, aber der ausgegebenen CSV fehlte immer eine Zeile (oder mehrere, abhängig von der Größe des Puffers). Dies sagte mir, dass etwas nicht richtig geschlossen wurde.

Der richtige Weg ist, sicherzustellen, dass alle vorherigen Verwendungen ordnungsgemäß entsorgt werden:

using (var memoryStream = new MemoryStream())
{
    using (var textwriter = new StreamWriter(memoryStream))
    {
        using (var csv = new CsvWriter(textwriter))
        {
            //..write some stuff to the stream using the CsvWriter
        }
    }

    return memoryStream.ToArray();
}