powrót w środku bloku

Wszystko w porządku.

Najwyraźniej myślisz, że

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

Jest ślepo tłumaczone na:

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

Co, Co prawda, byłoby problemem, i uczyniłoby using stwierdzenie raczej bezsensownym - - - dlatego to jest , a nie to, co robi.

Kompilator upewnia się, że obiekt zostanie usunięty zanim control opuści blok-niezależnie od tego jak opuści blok.

Jest absolutnie w porządku - żaden problem. Dlaczego uważasz, że to złe?

Wyrażenie using jest tylko składniowym cukrem dla bloku try / finally i jak mówi Grzenio, dobrze jest też wrócić z bloku try.

Zostanie obliczone wyrażenie zwrotne, następnie zostanie wykonany finally block, a następnie metoda powróci.

To będzie działać idealnie, tak jak powrót w środku try{}finally{}

To jest całkowicie dopuszczalne. użycie instrukcji zapewnia, że IDisposable obiekt zostanie usunięty bez względu na wszystko.

From MSDN :

Instrukcja using zapewnia, że Dispose jest wywoływane nawet wtedy, gdy wystąpi wyjątek podczas wywoływania metod w obiekcie. Można osiągnąć ten sam wynik, umieszczając obiekt wewnątrz bloku try, a następnie wywołując Dispose w bloku finally; w rzeczywistości tak jest przetłumaczone polecenie using kompilator.

Poniższy kod pokazuje jak działa using:

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());
}

Wyjście:

Tworzony jest't1'.
powstaje "t2".
powstaje "t3".
Tworzy się "utworzone z t1, t2, t3".
"t3" jest usuwany.
"t2" jest usuwany.
"t1" jest usuwany.

Disposed są wywoływane po instrukcji return, ale przed zakończeniem funkcji.

Być może nie jest to w 100% prawdą, że jest to dopuszczalne...

Jeśli zdarzy ci się, że zagnieżdżasz się i wracasz z zagnieżdżonego, może to nie być bezpieczne.

Weźmy to jako przykład:

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();
        }
    }
}

Przechodziłem przez DataTable, który miał być wyprowadzony jako csv. Z returnem w środku zapisywał wszystkie wiersze do strumienia, ale w wyjściowym pliku csv zawsze brakowało wiersza (lub wielu, w zależności od rozmiaru bufora). To mi mówiło, że coś nie jest zamknięte. jak należy.

Poprawnym sposobem jest upewnienie się, że wszystkie poprzednie zastosowania są prawidłowo usunięte:

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();
}