Un MemoryStream viene eliminato automaticamente quando lo si restituisce come ActionResult?

Question

public ActionResult CustomChart(int reportID) 
{ 
    Chart chart = new Chart(); 

    // Save the chart to a MemoryStream 
    var imgStream = new MemoryStream(); 
    chart.SaveImage(imgStream); 
    imgStream.Seek(0, SeekOrigin.Begin); 

    // Return the contents of the Stream to the client 
    return File(imgStream, "image/png"); 
} 

Sono abituato a utilizzare l'istruzione 'using' in combinazione con MemoryStreams. È uno scenario in cui l'istruzione "using" non è necessaria? O è valido chiamare il ritorno all'interno di una dichiarazione 'using'?

EDIT:

Per i miei scopi ho trovato che l'introduzione di un 'utilizzando' istruzione non funziona (tiri un ObjectDisposedException). Ecco cosa sto facendo con esso lato client:

$('#ReportTest').bind('load', function() { 
         $('#LoadingPanel').hide(); 
         $(this).unbind('load'); 
        }).bind('error', function() { 
         $('#LoadingPanel').hide(); 
         $(this).unbind('error'); 
        }).attr('src', '../../Chart/CustomChart?ReportID=' + settings.id); 

Answer 1

fa un MemoryStream ottenere smaltiti automaticamente quando si ritorna come un ActionResult?

Sì, MVC (almeno versione 3) lo pulirà per voi. Si può prendere un look at the source del metodo WriteFile in FileStreamResult:

protected override void WriteFile(HttpResponseBase response) { 
    // grab chunks of data and write to the output stream 
    Stream outputStream = response.OutputStream; 
    using (FileStream) { 
     byte[] buffer = new byte[_bufferSize]; 

     while (true) { 
      int bytesRead = FileStream.Read(buffer, 0, _bufferSize); 
      if (bytesRead == 0) { 
       // no more data 
       break; 
      } 

      outputStream.Write(buffer, 0, bytesRead); 
     } 
    } 
} 

La linea using (FileStream) { metterà il flusso in un blocco dell'uso, dello smaltimento in tal modo di esso quando ha scritto il contenuto della risposta HTTP.

Si può anche verificare questo comportamento creando un flusso fittizio che fa questo:

public class DummyStream : MemoryStream 
{ 
    protected override void Dispose(bool disposing) 
    { 
     Trace.WriteLine("Do I get disposed?"); 
     base.Dispose(disposing); 
    } 
} 

Così MVC sarà smaltire.

Answer 2

Quanto segue è un codice valido che dispone del flusso. Se racchiuso in un blocco using, il metodo MemoryStream.Dispose() verrà richiamato automaticamente al momento della restituzione.

public ActionResult CustomChart(int reportID) 
{ 
    Chart chart = new Chart(); 

    using (var imgStream = new MemoryStream()) { 
     chart.SaveImage(imgStream); 
     imgStream.Seek(0, SeekOrigin.Begin); 
     return File(imgStream, "image/png"); 
    } 
} 

è possibile ottenere lo stesso risultato inserendo l'oggetto all'interno di un blocco try e quindi chiamando Dispose in un blocco finally. In effetti, secondo la documentazione MSDN, questo è il modo in cui l'istruzione using viene tradotta dal compilatore. E in un blocco try..finally lo finally verrà sempre eseguito anche quando try esce da return.

Il compilatore traduce il blocco using al seguente:

MemoryStream imgStream = new MemoryStream(); 

try 
{ 
    chart.SaveImage(imgStream); 
    imgStream.Seek(0, SeekOrigin.Begin); 
    return File(imgStream, "image/png"); 
} 
finally 
{ 
    if (imgStream != null) 
     ((IDisposable)imgStream).Dispose(); 
} 

Answer 3

Sean: NON utilizzare "l'utilizzo" in quanto eliminerà l'oggetto. Lasciando MVC l'accesso a un oggetto Disposed. Quindi l'eccezione (errore del server) che hai riscontrato è certamente una ObjectDisposedException. La funzione WriteFile precedentemente pubblicata Disporre l'oggetto per te.

Answer 4

Un MemoryStream non è necessario in questa situazione. Si può evitare la creazione di un ActionResult personalizzato come questo:

public class ChartResult : ActionResult 
{ 
    private Chart _chart; 

    public ChartResult(Chart chart) 
    { 
     if (chart == null) 
      throw new ArgumentNullException("chart"); 
     _chart = chart; 
    } 

    public override void ExecuteResult(ControllerContext context) 
    { 
     if (context == null) 
      throw new ArgumentNullException("context"); 

     HttpResponseBase response = context.HttpContext.Response; 
     response.ContentType = "image/png"; 
     response.BufferOutput = false; 

     _chart.ImageType = ChartImageType.Png; 
     _chart.SaveImage(response.OutputStream); 
    } 
}