"L'oggetto può essere smaltito più di una volta" Errore

Question

Quando eseguo l'analisi del codice sul seguente pezzo di codice ottengo questo messaggio:

Oggetto 'stream' possono essere smaltiti più di una volta nel metodo 'upload.Page_Load (oggetto, EventArgs) '. Per evitare di generare System.ObjectDisposedException, non chiamare Dispose più di una volta su un oggetto.

using(var stream = File.Open(newFilename, FileMode.CreateNew)) 
using(var reader = new BinaryReader(file.InputStream)) 
using(var writer = new BinaryWriter(stream)) 
{ 
    var chunk = new byte[ChunkSize]; 
    Int32 count; 
    while((count = reader.Read(chunk, 0, ChunkSize)) > 0) 
    { 
     writer.Write(chunk, 0, count); 
    } 
} 

Non capisco perché potrebbe essere chiamato due volte e come risolverlo per eliminare l'errore. Qualsiasi aiuto?

Answer 1

BinaryReader/BinaryWriter disporrà il flusso sottostante quando si dispone. Non è necessario farlo esplicitamente.

Per risolvere il problema è possibile rimuovere l'utilizzo attorno al flusso stesso.

Answer 2

Il tuo scrittore disporrà il tuo stream, sempre.

Answer 3

Per illustrare, modifichiamo il codice

using(var stream = File.Open(newFilename, FileMode.CreateNew)) 
{ 
    using(var reader = new BinaryReader(file.InputStream)) 
    { 
     using(var writer = new BinaryWriter(stream)) 
     { 
      var chunk = new byte[ChunkSize]; 
      Int32 count; 
      while((count = reader.Read(chunk, 0, ChunkSize)) > 0) 
      { 
       writer.Write(chunk, 0, count); 
      } 
     } // here we dispose of writer, which disposes of stream 
    } // here we dispose of reader 
} // here we dispose a stream, which was already disposed of by writer 

Per evitare questo, basta creare lo scrittore direttamente

using(var reader = new BinaryReader(file.InputStream)) 
    { 
     using(var writer = new BinaryWriter(File.Open(newFilename, FileMode.CreateNew))) 
     { 
      var chunk = new byte[ChunkSize]; 
      Int32 count; 
      while((count = reader.Read(chunk, 0, ChunkSize)) > 0) 
      { 
       writer.Write(chunk, 0, count); 
      } 
     } // here we dispose of writer, which disposes of its inner stream 
    } // here we dispose of reader 

---

edit: tener conto di ciò che Eric Lippert sta dicendo, non ci potrebbe effettivamente essere un momento in cui il flusso viene rilasciato dal finalizzatore solo se BinaryWriter genera un'eccezione. Secondo il codice BinaryWriter, che potrebbe avvenire in tre casi

If (output Is Nothing) Then 
     Throw New ArgumentNullException("output") 
    End If 
    If (encoding Is Nothing) Then 
     Throw New ArgumentNullException("encoding") 
    End If 
    If Not output.CanWrite Then 
     Throw New ArgumentException(Environment.GetResourceString("Argument_StreamNotWritable")) 
    End If 

• se non è stato specificato un output, vale a dire se il flusso è nullo. Questo non dovrebbe essere un problema dato che un flusso null significa nessuna risorsa da smaltire :)
• se non hai specificato una codifica. dal momento che non usiamo la forma di costruzione in cui viene specificata la codifica, non ci dovrebbe essere alcun problema neanche qui (non ho guardato in contructor codifica troppo, ma una tabella di codici non valida può buttare)
  • se si don' passare un flusso scrivibile. Questo dovrebbe essere catturati abbastanza rapidamente durante lo sviluppo ...

In ogni caso, buon punto, quindi la modifica :)

Answer 4

Una corretta attuazione della Dispose viene esplicitamente richiesto di non preoccuparsi se è stato chiamato più di una volta sullo stesso oggetto. Mentre più chiamate a Dispose sono a volte indicative di problemi logici o di codice che potrebbero essere meglio scritti, l'unico modo per migliorare il codice pubblicato originale sarebbe quello di convincere Microsoft ad aggiungere un'opzione a BinaryReader e BinaryWriter che li istruisce a non disporre del loro passato- in streaming (e quindi utilizzare tale opzione). In caso contrario, il codice richiesto per garantire che il file venga chiuso anche se il lettore o lo scrittore getta nel suo costruttore sarebbe sufficientemente brutto che semplicemente lasciare che il file venga eliminato più di una volta sembrerebbe più pulito.

Answer 5

Ho faticato con questo problema e ho trovato l'esempio here molto utile.Vi posto il codice per una rapida visualizzazione:

using (Stream stream = new FileStream("file.txt", FileMode.OpenOrCreate)) 
{ 
    using (StreamWriter writer = new StreamWriter(stream)) 
    { 
     // Use the writer object... 
    } 
} 

Sostituire l'esterno mediante dichiarazione con un try/finally avendo cura di entrambi NULL torrente dopo averlo usato in StreamWriter e controllare per assicurarsi che non è nulla in il finalmente prima di smaltire.

Stream stream = null; 
try 
{ 
    stream = new FileStream("file.txt", FileMode.OpenOrCreate); 
    using (StreamWriter writer = new StreamWriter(stream)) 
    { 
     stream = null; 
     // Use the writer object... 
    } 
} 
finally 
{ 
    if(stream != null) 
     stream.Dispose(); 
} 

Questa operazione ha risolto i miei errori.