一个简单的解决方案是在发送进一步的消息之前等待响应，但这可能会降低性能。
另一种选择是将多个消息打包成一个更大的消息。这个message aggregation可以保证顺序。它可以在客户端或服务器端完成。
"exactly once in order" policy (EOIO)会带来性能损失。在每条消息中写入严格递增的跟踪ID可能会有所帮助。这将允许服务器检测无序消息。这取决于整体要求，服务器应该等待延迟消息的时间。

如何使用信号量来确保每个会话一次只执行一次。

public class MyClass
{
    private readonly SemaphoreService semaphoreService;

    public MyClass(SemaphoreService semaphoreService)
    {
        this.semaphoreService = semaphoreService;
    }

    public async Task Write(string sessionId)
    {
        await semaphoreService.Execute(async () =>
        {
            await WriteToDataBase();
            await DoSomeOtherStuff();
        }, sessionId);
    }

    public async Task Read(string sessionId)
    {
        await semaphoreService.Execute(async () =>
        {
            //Do stuff
        }, sessionId);
    }

    private async Task WriteToDataBase()
    {
        //Do stuff
    }

    private async Task DoSomeOtherStuff()
    {
        //Do stuff
    }
}

public class SemaphoreService
{
    private static readonly ConcurrentDictionary<string, SemaphoreSlim> Semaphores = new();

    public void Delete(string sessionId)
    {
        Semaphores.Remove(sessionId, out var _);
    }

    public SemaphoreSlim GetSemaphore(string sessionId)
    {
        return Semaphores.GetOrAdd(sessionId, _ => new SemaphoreSlim(1));
    }

    public async Task Execute(Func<Task> action, string sessionId)
    {
        var sem = GetSemaphore(sessionId);
        await sem.WaitAsync();
        try
        {
            await action();
        }
        finally
        {
            sem.Release();
        }
    }
}

您可能需要挂接SemaphoreService.Delete以便在会话结束时调用。