在任务中使用语句

Question

在 ASP.NET Web API 控制器中，我想返回一个图像。要流式传输图像，我需要MemoryStream。通常我会将它包装在using 语句中，以确保它在之后得到正确处理。但是，由于它在 Task 中异步执行，因此不起作用：

public class ImagesController : ApiController
{
    private HttpContent GetPngBitmap(Stream stream)
    {
        var pngBitmapEncoder = new PngBitmapEncoder();
        pngBitmapEncoder.Save(stream);
        stream.Seek(0, SeekOrigin.Begin);
        return new StreamContent(stream);
    }

    // GET api/images
    public Task<HttpResponseMessage> Get(string id, string path)
    {            
        //do stuff           
        return Task.Factory.StartNew(() =>
        {
            var stream = new MemoryStream(); //as it's asynchronous we can't use a using statement here!
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = GetPngBitmap(stream)
                };
                response.Content.Headers.ContentType =
                    new System.Net.Http.Headers.MediaTypeHeaderValue("image/png");
                return response;
            }
            //how can I dispose stream???
        });
    }
}

Answer 1

1. MemoryStream 是实现IDisposable 的类之一，因为它们的基类实现了。 MemoryStream 不保存任何资源（托管内存除外），因此实际上没有必要处理它。
2. HttpResponseMessage 是一次性的。这意味着当它发送整个响应时，该对象被释放。这样做会处理包含的HttpContent，在StreamContent 的情况下会处理底层的Stream。因此，即使您有一个应该处理的 Stream，在这种情况下您也不必担心。

Answer 2

使用“使用”然后它会自动处理。

public class ImagesController : ApiController
{
    // GET api/images
    public Task<HttpResponseMessage> Get(string id, string path)
    {            
        //do stuff           
        return Task.Factory.StartNew(() =>
        {
           using( stream = new MemoryStream()) //as it's asynchronous we can't use a using statement here!
           {
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = GetPngBitmap(stream)
                };
                response.Content.Headers.ContentType =
                    new System.Net.Http.Headers.MediaTypeHeaderValue("image/png");
                return response;
            }
            //how can I dispose stream???
           }
        });
    }
}

Answer 3

也许返回一个Tuple<HttpResponseMessage, Stream> 并附加一个继续任务来处理Stream？

public Task<Tuple<HttpResponseMessage,Stream>> Get(string id, string path)
{            
    //do stuff           
    return Task.Factory.StartNew(() =>
    {
        var stream = new MemoryStream();
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = GetPngBitmap(stream)
            };
            response.Content.Headers.ContentType =
                new System.Net.Http.Headers.MediaTypeHeaderValue("image/png");
            return Tuple.Create(response, stream);
        }
    })
    .ContinueWith(t => t.Result.Item2.Close());
}

Answer 4

也许这听起来很幼稚，但你不能在任务结束时处理它吗？

var stream = new MemoryStream();
//use the stream...
stream.Dispose();

edit: 或“Close()”，在 MemoryStream 上也是一样的。

Answer 5

你可以这样做。这将首先执行您的 initialRun，在异步调用之后，返回并执行 continue with。

        Task<System.IO.MemoryStream> initialRun = new Task<System.IO.MemoryStream>(() =>
        {
            System.IO.MemoryStream stream = new System.IO.MemoryStream();
            // use stream
            return stream;
        });
        initialRun.ContinueWith(new Action<Task<System.IO.MemoryStream>>((stream) =>
        {
            stream.Dispose();
        }), 
        TaskScheduler.FromCurrentSynchronizationContext());
        initialRun.Start();