异步内存流方式：以下哪项？

Question

我正在研究使用异步内存流的解决方案，我正在考虑实现这种方法的正确方法。 哪一个更方便？ 第一，简单：

//First approach: linear async
private async static Task WriteToStreamFirstVariant()
{
    MemoryStream memoryStream = new MemoryStream();
    byte[] data = new byte[256];
    try
    {
        await memoryStream.WriteAsync(data, 0, data.Length);
    }
    catch(Exception exception)
    {
        //Handling exception
    }
    finally
    {
        memoryStream.Dispose();
    }
}

或者第二个嵌套任务和闭包？

//Second approach: nested tasks async
private async static Task WriteToStreamSecondVariant()
{
    await Task.Run(async () =>
    {
        byte[] data = new byte[256];
        using (MemoryStream memoryStream = new MemoryStream())
        {
            await memoryStream.WriteAsync(data, 0, data.Length)
                .ContinueWith((Task writingTask) =>
                {
                    //Handling exceptions
                    AggregateException exceptions = writingTask.Exception;
                });
        }
    }); 
}

Answer 1

事实上， MemoryStream的Read/WriteAsync方法实际上并没有提供任何类型的真正的异步实现。 他们所做的只是同步执行操作并返回已完成的Task 。 因此，当您知道它是一个MemoryStream时，调用异步方法没有任何好处。 实际上，这只是完全不必要的开销。

现在，忘了那一秒只是回答关于风格的问题，第一种方法更好一种，因为你没有不必要地分配/安排一个新Task （例如使用Task::Run ），但我不知道为什么你不会在该方法中使用using()语句。 所以这是最干净/最简单的恕我直言：

private async static Task WriteToStreamFirstVariantSimplified()
{
    using(MemoryStream memoryStream = new MemoryStream())
    {
        byte[] data = new byte[256];

        try
        {
            await memoryStream.WriteAsync(data, 0, data.Length);
        }
        catch(Exception exception)
        {
            //Handling exception
        }
   }
}