C# 允许一次仅调用一个实例的异步方法

我有一个方法不能同时在多个线程中执行（它写入一个文件）。我无法使用

lock

，因为该方法是

async

。如何避免在另一个线程中调用该方法？程序应该等待上一次调用完成（也是异步的），而不是第二次调用

例如，使用以下代码创建一个新的C#控制台应用程序：

using System;
using System.IO;
using System.Threading.Tasks;
namespace ConsoleApplication1 {
    internal class Program {

        private static void Main () {
            CallSlowStuff();
            CallSlowStuff();
            Console.ReadKey();
        }

        private static async void CallSlowStuff () {
            try {
                await DoSlowStuff();
                Console.WriteLine("Done!");
            }
            catch (Exception e) {
                Console.WriteLine(e.Message);
            }
        }

        private static async Task DoSlowStuff () {
            using (File.Open("_", FileMode.Create, FileAccess.Write, FileShare.None)) {
                for (int i = 0; i < 10; i++) {
                    await Task.Factory.StartNew(Console.WriteLine, i);
                    await Task.Delay(100);
                }
            }
        }
    }
}

使用系统；
使用System.IO；
使用System.Threading.Tasks；
命名空间控制台应用程序1{
内部课程计划{
私有静态void Main（）{
CallSlowStuff（）；
CallSlowStuff（）；
Console.ReadKey（）；
}
私有静态异步void CallSlowStuff（）{
试一试{
等待DoSlowStuff（）；
控制台。WriteLine（“完成！”）；
}
捕获（例外e）{
控制台写入线（e.Message）；
}
}
私有静态异步任务DoSlowStuff（）{
使用（File.Open（“”，FileMode.Create，FileAccess.Write，FileShare.None））{
对于（int i=0；i<10；i++）{
wait Task.Factory.StartNew（Console.WriteLine，i）；
等待任务。延迟（100）；
}
}
}
}
}

在本例中，对

CallSlowStuff

的第二次调用引发异常，因为它无法访问已打开的文件。添加

lock

不是一个选项，因为

lock

和

async

不会混合使用。（

Main

方法应该被认为是不可更改的。在实际应用程序中，

CallSlowStuff

是一种可以在任何地方调用的接口方法。）

---

问题：如何在不阻塞主线程的情况下对

CallSlowStuff

进行后续调用，等待当前正在运行的调用完成？可以只使用异步/等待和任务（和Rx可能）吗？< /P> < P>我会考虑修改<代码> CallSlowStuff < /Cord>的方法体来将消息发布到ActhBug，并将其配置为一个并行度：

因此，在某个地方保留一个ActionBlock：

ActionBlock actionBlock = 
    new ActionBlock<object>(
         (Func<object,Task>)CallActualSlowStuff,
         new ExecutionDataflowBlockOptions(){MaxDegreeOfParallelism=1});

ActionBlock ActionBlock=
新动作块(
（Func）调用实际流量，
新的ExecutionDataflowBlockOptions（）{MaxDegreeOfParallelism=1}）；

现在：

public void CallSlowStuff（）
{
actionBlock.Post（空）；
}
专用异步任务调用ActualSlowStuff（对象）
{
使用（File.Open（“”，FileMode.Create，FileAccess.Write，FileShare.None））{
对于（int i=0；i<10；i++）{
wait Task.Factory.StartNew（Console.WriteLine，i）；
等待任务。延迟（100）；
}
}
}

您可以在此实例中使用信号量，请参阅

比如：

private Semaphore sem = new Semaphore(1, 1);

private static async Task DoSlowStuff () {
  sem.WaitOne();
  // your stuff here
  sem.Release();
}

---

您需要某种异步锁。Stephen Toub有一个完整的（包括）。斯蒂芬·克利里（Stephen Cleary）的书中还包含了一个版本的

AsyncLock

但可能更简单的解决方案是使用内置的，它确实支持异步等待：

private static SemaphoreSlim SlowStuffSemaphore = new SemaphoreSlim(1, 1);

private static async void CallSlowStuff () {
    await SlowStuffSemaphore.WaitAsync();
    try {
        await DoSlowStuff();
        Console.WriteLine("Done!");
    }
    catch (Exception e) {
        Console.WriteLine(e.Message);
    }
    finally {
        SlowStuffSemaphore.Release();
    }
}

---

Main

方法是不可更改的。请阅读示例代码后的描述。@Athari，假设您正在寻找某种队列，在我看来，该数据流在这里是合适的。看一看我修改过的答案。虽然这会起作用，但对我来说，这样的解决方案太复杂了。这会同步等待，这在

异步

方法中是一个坏方法。顺便问一下，你真的想让你的方法

异步无效

？这通常不是个好主意，除非它是一个和事件处理程序。@svick“Async”方法链必须在某个地方停止。如果我执行

CallSlowStuff

async任务

，那么我将在

Main

方法中得到编译器警告。您对如何完全避免

async void

有什么建议吗？有可能吗？我想知道，但没有找到任何解决方案。这取决于您的应用程序类型。如果您确实有一个控制台应用程序，正确的解决方案是对返回的

任务同步
Wait（）
。如果它是GUI应用程序，那么
async void
事件处理程序将是正确的解决方案。在ASP.NET MVC中，链不必结束，因为控制器方法可以返回
任务
。SemaphoreSlim解决了我的并发问题。
private static SemaphoreSlim SlowStuffSemaphore = new SemaphoreSlim(1, 1);

private static async void CallSlowStuff () {
    await SlowStuffSemaphore.WaitAsync();
    try {
        await DoSlowStuff();
        Console.WriteLine("Done!");
    }
    catch (Exception e) {
        Console.WriteLine(e.Message);
    }
    finally {
        SlowStuffSemaphore.Release();
    }
}