Quando si utilizza il rendimento all'interno di un'istruzione "using", quando si verifica Dispose?

Question

Ho una domanda riguardante l'esecuzione differita e lo smaltimento dei dati.

consideri il seguente esempio:

private IEnumerable<string> ParseFile(string fileName) 
{ 
    using(StreamReader sr = new StreamReader(fileName)) 
    { 
     string line; 
     while((line = sr.ReadLine()) != null) 
     { 
      yield return line; 
     } 
    } 
} 

private void LineReader(string fileName) 
{ 
    int counter = 0; 

    foreach(string line in ParseFile(fileName)) 
    { 
     if(counter == 2) 
     { 
      break; // will this cause a dispose on the StreamReader? 
     } else 
     { 
      Console.WriteLine(line); 
      counter++; 
     } 
    } 
} 

disposta la dichiarazione break immediatamente causare il lettore in ParseFile di disporre o è ancora considerata nel contesto e si blocca il file aperto fino a quando il programma stesso è chiuso?

Answer 1

Quindi abbiamo diversi problemi separati in corso qui.

Prima di tutto, si occupa dello using nel blocco iteratore. IEnumerator estende IDisposable. Il codice che genera i blocchi iteratore è in realtà abbastanza robusto che qualsiasi blocco try/finally (a using viene creato un blocco try/finally) il contenuto del blocco finally viene chiamato nel metodo Dispose dell'enumeratore, se non è stato già chiamato. Finché l'enumeratore è disposto, non perderà lo StreamReader.

Così ora ci chiediamo se l'enumeratore è disposto. Tutte le istruzioni foreach chiameranno Dispose sull'enumeratore (dovrebbe implementare IDisposable). Lo fanno anche se si esce usando una dichiarazione break o return, così come quando finisce normalmente.

Quindi si può essere sicuri che in tutte le circostanze la risorsa non sarà trapelata, salvo i casi in cui non si può impedire a nessuna perdita (ad esempio, qualcuno che scollega la macchina).