嗯，我也有同样的问题。现在解决了。这是一个很晚的建议，但可能对其他人有帮助。
在下面的控制台示例中包括以下using语句。

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
Use of the FileStream Class

下面的示例使用FileStream类，该类具有一个选项，可导致在操作系统级别发生异步I/O。在许多情况下，这将避免阻塞ThreadPool线程。若要启用此选项，必须在构造函数调用中指定useAsync=true或options=FileOptions.Asynchronous参数。
如果通过指定文件路径直接打开StreamReader和StreamWriter，则它们不具有此选项。如果向StreamReader/Writer提供由FileStream类打开的Stream，则它们具有此选项。请注意，即使线程池线程被阻止，异步也会在UI应用程序中提供响应优势，因为UI线程在等待期间不会被阻止。
书写文本
以下示例将文本写入文件。在每个await语句中，该方法立即退出。当文件I/O完成时，该方法在await语句后面的语句中继续。请注意，异步修饰符位于使用await语句的方法的定义中。

static void Main(string[] args)
{
    ProcessWrite().Wait();
    Console.Write("Done ");
    Console.ReadKey();
}

static Task ProcessWrite()
{
    string filePath = @"c:\temp2\temp2.txt";
    string text = "Hello World\r\n";

    return WriteTextAsync(filePath, text);
}

static async Task WriteTextAsync(string filePath, string text)
{
    byte[] encodedText = Encoding.Unicode.GetBytes(text);

    using (FileStream sourceStream = new FileStream(filePath,
        FileMode.Append, FileAccess.Write, FileShare.None,
        bufferSize: 4096, useAsync: true))
    {
        await sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
    };
}

阅读文本
下面的示例从文件读取文本。文本被缓冲，在本例中，文本被放入StringBuilder中。与上一示例不同的是，对await的求值将生成一个值。ReadAsync方法返回一个Task，因此对await的求值将生成一个Int 32值（numRead），该值将在操作完成后返回。

static void Main(string[] args)
{
    ProcessRead().Wait();
    Console.Write("Done ");
    Console.ReadKey();
}

static async Task ProcessRead()
{
    string filePath = @"c:\temp2\temp2.txt";

    if (File.Exists(filePath) == false)
    {
        Console.WriteLine("file not found: " + filePath);
    }
    else {
        try {
            string text = await ReadTextAsync(filePath);
            Console.WriteLine(text);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

static async Task<string> ReadTextAsync(string filePath)
{
    using (FileStream sourceStream = new FileStream(filePath,
        FileMode.Open, FileAccess.Read, FileShare.Read,
        bufferSize: 4096, useAsync: true))
    {
        StringBuilder sb = new StringBuilder();

        byte[] buffer = new byte[0x1000];
        int numRead;
        while ((numRead = await sourceStream.ReadAsync(buffer, 0, buffer.Length)) != 0)
        {
            string text = Encoding.Unicode.GetString(buffer, 0, numRead);
            sb.Append(text);
        }

        return sb.ToString();
    }
}

原始源代码是here，但不幸的是，链接现在似乎死了。
可以在here中找到新的源代码。
希望能有所帮助...

处理异步写入文件的帮助器方法示例。

public async Task FileWriteAsync(string filePath, string messaage, bool append = true)
    {
        using (FileStream stream = new FileStream(filePath, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.None, 4096, true))
        using (StreamWriter sw = new StreamWriter(stream))
        {
            await sw.WriteLineAsync(messaage);
        }
    }

异步写入文件不能解决此问题。您需要等待文件可用。

如果你使用一个简单的StreamWriter，你可以用一个简单的类来代替它。不需要async/await。这是一个写文本文件的例子。

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Threading.Tasks;

class LogWriter : IDisposable
{
    private BlockingCollection<string> blockingCollection = new BlockingCollection<string>();
    private StreamWriter log = null;
    bool run = true;
    Task task = null;

    public LogWriter(string logFilePath)
    {
        log = new StreamWriter(logFilePath);
        task = Task.Run(() =>
        {
            while (run)
            {
                log.WriteLine(blockingCollection.Take());
            }
           });
    }

    public void WriteLine(string value)
    {
        blockingCollection.Add(value);
    }

    public void Dispose()
    {
        run = false;
        task.Dispose();
        log.Close();
        log.Dispose();
    }
}

要使用它，请像使用StreamWriter一样操作：

using (var log = new LogWriter(logFileName))
{
    log.WriteLine("Hello world");
    // Code here that should not be blocked by writing to the file
}

可接受的答案有一个常见的异步陷阱-缓冲区不是异步刷新的。https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/blob/master/AsyncGuidance.md#always-call-flushasync-on-streamwriters-or-streams-before-calling-dispose
使用新的await using或在处理之前手动刷新缓冲区

await using (var file = new StreamWriter(path)) //mind the "await using"
{
    await file.WriteAsync(content);
}

或

using (var streamWriter = new StreamWriter(context.Response.Body))
{
    await streamWriter.WriteAsync("Hello World");
    await streamWriter.FlushAsync();
}

简单明了的解决方案：

await using var file = new StreamWriter(path);
await file.WriteAsync(content);

最终，这取决于你为什么要这么做。
如果您不打算向文件写入太多数据，则可以不断地打开和关闭它。
或者，如果您知道何时要打开文件，何时要关闭文件，则可以在需要时打开它，然后保持打开状态以进行写入，直到您知道不再需要它为止。