errore nel metodo file.readlines (..) di .NET Framework 4.0

Question

Questo codice:

IEnumerable<string> lines = File.ReadLines("file path"); 
foreach (var line in lines) 
{ 
    Console.WriteLine(line); 
} 
foreach (var line in lines) 
{ 
    Console.WriteLine(line); 
} 

genera ObjectDisposedException : {"Cannot read from a closed TextReader."} se il secondo foreach viene eseguita. Sembra che l'oggetto iteratore restituito da File.ReadLines(..) non possa essere enumerato più di una volta. È necessario ottenere un nuovo oggetto iteratore chiamando File.ReadLines(..) e quindi utilizzarlo per iterare.

Se sostituisco File.ReadLines(..) con la mia versione (parametri non sono verificate, è solo un esempio):

public static IEnumerable<string> MyReadLines(string path) 
{ 
    using (var stream = new TextReader(path)) 
    { 
     string line; 
     while ((line = stream.ReadLine()) != null) 
     { 
      yield return line; 
     } 
    } 
} 

è possibile scorrere più di una volta le righe del file.

Un'indagine che utilizza .Net Reflector ha mostrato che l'implementazione dello File.ReadLines(..) chiama un privato File.InternalReadLines(TextReader reader) che crea l'iteratore effettivo. Il lettore ha passato come parametro viene utilizzato nel metodo MoveNext() dell'iteratore per ottenere le linee del file e viene eliminato quando raggiungiamo la fine del file. Ciò significa che una volta che MoveNext() restituisce false, non c'è modo di ripetere una seconda volta perché il lettore è chiuso e devi ottenere un nuovo lettore creando un nuovo iteratore con il metodo ReadLines(..).Nella mia versione viene creato un nuovo lettore nello MoveNext() metodo ogni volta che iniziamo una nuova iterazione.

È questo il comportamento previsto del metodo File.ReadLines(..)?

Trovo problematico il fatto che sia necessario chiamare il metodo ogni volta prima di enumerare i risultati. Dovresti anche chiamare il metodo ogni volta prima di iterare i risultati di una query Linq che utilizza il metodo.

Answer 1

Non penso che sia un bug, e non penso sia insolito - in effetti è quello che mi aspetterei per qualcosa come un lettore di file di testo. L'IO è un'operazione costosa, quindi in generale si vuole fare tutto in un unico passaggio.

Answer 2

Se avete bisogno di accedere alle linee due volte si può sempre tampone in un List<T>

using System.Linq; 

List<string> lines = File.ReadLines("file path").ToList(); 
foreach (var line in lines) 
{ 
    Console.WriteLine(line); 
} 
foreach (var line in lines) 
{ 
    Console.WriteLine(line); 
} 

Answer 3

E non è un bug. Ma credo che tu possa usare ReadAllLines() per fare invece ciò che vuoi. ReadAllLines crea un array di stringhe e inserisce tutte le linee nell'array, invece di un semplice enumeratore su un flusso come fa ReadLines.

Answer 4

Non so se può essere considerato un bug o se non è in base alla progettazione, ma posso certamente dire due cose ...

1. Questo dovrebbe essere pubblicato su Connect, non StackOverflow anche se' non lo cambierò prima che venga rilasciato 4.0. E questo di solito significa che non lo risolveranno mai.
2. Il design del metodo sembra certamente imperfetto.

Si ha ragione nel notare che restituire un oggetto IEnumerable implica che dovrebbe essere riutilizzabile e non garantisce gli stessi risultati se iterato due volte. Se avesse restituito un IEnumerator invece sarebbe una storia diversa.

Quindi, in ogni caso, penso che sia una buona scoperta e penso che l'API sia pessima per cominciare.ReadAllLines e ReadAllText offrono un modo comodo e conveniente per ottenere l'intero file, ma se il chiamante si preoccupa abbastanza delle prestazioni per utilizzare un enumerabile pigro, non dovrebbero delegare così tanta responsabilità a un metodo di supporto statico in primo luogo.

Answer 5

Credo che si confonda un IQueryable con un oggetto IEnumerable. Sì, è vero che IQueryable può essere considerato come un oggetto IEnumerable, ma non sono esattamente la stessa cosa. Una query IQueryable ogni volta che viene utilizzata, mentre un oggetto IEnumerable non ha alcun riutilizzo implicito.

Una query di Linq restituisce un IQueryable. ReadLines restituisce un oggetto IEnumerable.

C'è una sottile distinzione qui a causa del modo in cui un Enumeratore viene creato. Un IQueryable crea un IEnumerator quando si chiama GetEnumerator() su di esso (operazione eseguita automaticamente da foreach). ReadLines() crea l'IEnumerator quando viene chiamata la funzione ReadLines(). Pertanto, quando riutilizzate un IQueryable, crea un nuovo IEnumerator quando lo riutilizzate, ma dal momento che ReadLines() crea l'IEnumerator (e non un IQueryable), l'unico modo per ottenere un nuovo IEnumerator è di chiamare nuovamente ReadLines() .

In altre parole, si dovrebbe essere in grado di riutilizzare un IQueryable, non un IEnumerator.

EDIT:

Su ulteriore riflessione (no pun intended) Credo che la mia risposta iniziale era un po 'troppo semplicistica. Se IEnumerable non era riutilizzabile, non si poteva fare qualcosa di simile:

List<int> li = new List<int>() {1, 2, 3, 4}; 

IEnumerable<int> iei = li; 

foreach (var i in iei) { Console.WriteLine(i); } 
foreach (var i in iei) { Console.WriteLine(i); } 

Chiaramente, non ci si aspetterebbe il secondo foreach al sicuro.

Il problema, come spesso accade con questo tipo di astrazioni, è che non tutto si adatta perfettamente. Ad esempio, gli stream sono in genere a senso unico, ma per l'utilizzo in rete devono essere adattati per funzionare in modo bidirezionale.

In questo caso, un oggetto IEnumerable era originariamente concepito come una funzionalità riutilizzabile, ma da allora è stato adattato per essere così generico che la riusabilità non è una garanzia o addirittura dovrebbe essere prevista. Prova l'esplosione di varie librerie che usano IEnumerables in modi non riutilizzabili, come la libreria PowerThreading di Jeffery Richters.

Semplicemente non penso che possiamo supporre che IEnumerables sia sempre più riutilizzabile.

Answer 6

Non è un bug. File.ReadLines() utilizza la valutazione lazy e non è idempotent. Ecco perché non è sicuro enumerarlo due volte di seguito. Ricordare che uno IEnumerable rappresenta un'origine dati che può essere enumerata, non afferma che è sicuro essere enumerato due volte, sebbene ciò potrebbe essere inaspettato poiché la maggior parte delle persone è abituata a utilizzare IEnumerable su raccolte idempotent.

Dal MSDN:

I readlines (String, System) e ReadAllLines (String, sistema) Metodi differiscono nel modo seguente: Quando si utilizza readlines, è possibile avviare l'enumerazione la raccolta delle stringhe prima che venga restituita l'intera collezione ; quando si uso ReadAllLines, è necessario attendere l'intero array di stringhe restituita prima di poter accedere al array.Therefore, quando si lavora con file di grandi dimensioni, possono readlines essere più efficiente.

I risultati ottenuti tramite riflettore sono corretti e verificano questo comportamento. L'implementazione fornita evita questo comportamento imprevisto, ma fa comunque un uso della valutazione lazy.

Answer 7

So che questo è vecchio, ma in realtà mi sono imbattuto in questo mentre lavoravo su un codice su una macchina Windows 7. Contrariamente a ciò che le persone stavano dicendo qui, questo in realtà era un errore. Vedi this link.

Quindi la soluzione più semplice è aggiornare il tuo .net framefork. Ho pensato che valesse la pena di aggiornarlo poiché questo era il risultato di ricerca più alto.