等待另一个任务 C# 更新对象

Question

我已经阅读了很多关于“等待”任务的帖子......我似乎无法弄清楚这一点，因为这可能是实际等待任务的一个转折点，我正在等待一个对象要更新，如果没有超时。

我正在使用 redis，它在单独的消息处理程序中从 redis 服务器接收到基本 acks/nack 列表时正确更新它们。 （发布的代码太多，与这个问题无关）。

有问题的代码是如何调用下面的“WaitForAck”方法，它的职责是检查上面的列表是否附加了它正在等待的 ack/nack。

因此，如果列表 'dic_DEAL_OUTPUTRESP_MessageQueue' 被单独的 redis 处理程序附加，我希望能够在任何它将等待（7 秒）的地方调用 'WaitForAck'，基本上阻止用户前进但不阻止任何其他线程，例如等待其更新的 redis 消息处理程序线程。

如果这应该是任何一种等待任务，我想我有点困惑，因为我不希望它是异步的？我希望用户等待 7 秒以查看它是否收到 ack/nack（列表有值），否则它会继续通知用户超时（单独处理）。

这是我的“WaitForAck”方法：

    public static void WaitForAck(string origUuid)
    {
        DateTime dt = DateTime.Now;

        Cursor.Current = Cursors.WaitCursor;
        try
        {
            while (dic_DEAL_OUTPUTRESP_MessageQueue[origUuid] == null)
            {
                Debug.WriteLine("Waiting for Redis Ack");
                Task.Delay(1000);
                TimeSpan ts = DateTime.Now - dt;
                if (ts.TotalSeconds > iWAIT)
                {
                    break;
                }
            }
        }
        catch { }
        Cursor.Current = Cursors.Default;
    }

提前谢谢你

编辑：添加调用

 private async void btnEnter_Click(object sender, EventArgs e)
    {
        // Process trade entry / amendment
        if (ConfirmEntries() != 0)
        {
            this.DialogResult = DialogResult.None;
            return;
        }
        DefineDeal();

        // Attempt Commit
        DEAL_REQ dEAL_REQ_ADD = new DEAL_REQ();
        dEAL_REQ_ADD.msgTimestamp = ReturnUTCTime(DateTime.Now).ToString(sDATETIME_FORMATMS);
        dEAL_REQ_ADD.uuid = Guid.NewGuid().ToString();
        dEAL_REQ_ADD.commandKey = sMeFunction == sADD ? sDEAL_REQ_ADD : sDEAL_REQ_UPDATE;
        dEAL_REQ_ADD.listenChannel = sRPC_CHANNEL_OUTPUT;
        dEAL_REQ_ADD.payload = _fxTempDeal;
        // Build json msg
        string sJson = JsonConvert.SerializeObject(dEAL_REQ_ADD);
        // Publish request
        // Prime response queue with guid in key
        dic_DEAL_OUTPUTRESP_MessageQueue.Add(dEAL_REQ_ADD.uuid, null);
        //Task.Delay(100);
        IDatabase db = redisConn.GetDatabase(redisDB);

        db.ListLeftPush(sRPC_CHANNEL_INPUT, sJson);
        //Task.Delay(100);
        //string s = db.ListLeftPop(sRPC_LB_INPUT);

        // Wait for ack 
        var value = await this.WaitForAck2(dEAL_REQ_ADD.uuid);

        // Received ack/nack
        if (value != null)
        {
            DEAL_RESP rESP = dic_DEAL_OUTPUTRESP_MessageQueue[dEAL_REQ_ADD.uuid];

            if (rESP.commandKey == sDEAL_REQ_ADD_ACK || rESP.commandKey == sDEAL_REQ_UPDATE_ACK)
            {
                this.DialogResult = DialogResult.OK;
            }
            else if (rESP.commandKey == sDEAL_REQ_ADD_NACK || rESP.commandKey == sDEAL_REQ_UPDATE_NACK)
            {
                MessageBox.Show("Unable to " + sMeFunction + " this deal. Please contact support. Reason : " + rESP.payload.display_msg, sAPP_NAME, MessageBoxButtons.OK, MessageBoxIcon.Error);
                this.DialogResult = DialogResult.Abort;
            }
        }
        // Timed out
        else
        {
            MessageBox.Show("Unable to " + sMeFunction + " this deal. Please contact support. Reason : Request Timeout", sAPP_NAME, MessageBoxButtons.OK, MessageBoxIcon.Error);
            dic_DEAL_OUTPUTRESP_MessageQueue.Remove(dEAL_REQ_ADD.uuid);
            dic_DEAL_TimedOut_MessageQueue.Add(dEAL_REQ_ADD.uuid, null);
            this.DialogResult = DialogResult.Cancel;
        }
    }

    public async Task<DEAL_RESP> WaitForAck2(string origUuid)
    {
        Stopwatch timer = new Stopwatch();
        timer.Start();

        while (timer.ElapsedMilliseconds < (7 * 1000))
        {
            if (await this.sync.WaitAsync(TimeSpan.FromSeconds(7)))
            {
                try
                {
                    if (dic_DEAL_OUTPUTRESP_MessageQueue.TryGetValue(origUuid, out var value))
                    {
                        return value;
                    }
                }
                finally
                {
                    this.sync.Release();
                }
            }

            await Task.Delay(1000);
        }

        return null;
    }

Answer 1

我认为您对您的问题有所回击，因为线程要求的上下文尚不清楚。如果这只是在服务中运行的两个线程，那么可以使用简单的 autoresetevent 来表示新消息已添加到队列中，然后该线程可以响应。但是从你的例子看来——由于 Cursor 类的使用——你在 UI 线程中运行，这使它变得复杂。您不能阻止 UI 线程。

我怀疑有比轮询队列 7 秒更好的 UI 模式来处理这个问题。但如果这符合您当前的设计，那么我认为以下代码将启用异步轮询。我使用一个简单的控制台应用程序对此进行了测试，并且线程按预期工作。外部类没有显示..

class MyClass 
{
    SemaphoreSlim sync = new SemaphoreSlim(1, 1);
    Dictionary<string, string> messages = new Dictionary<string, string>();

    public async void OnButtonClicked(EventArgs sender)
    {
        string origUuid = string.Empty; // get key from button click?

        var value = await this.WaitForAck(origUuid);

        if (null != value)
        {
            /// display it somehow...
            Console.WriteLine(value);
        }
    }

    public async Task<string> WaitForAck(string origUuid)
    {
        Stopwatch timer = new Stopwatch();
        timer.Start();

        while (timer.ElapsedMilliseconds < (7 * 1000))
        {
            if (await this.sync.WaitAsync(TimeSpan.FromSeconds(7)))
            {
                try
                {
                    if (this.messages.TryGetValue(origUuid, out var value))
                    {
                        return value;
                    }
                }
                finally
                {
                    this.sync.Release();
                }
            }

            await Task.Delay(1000);
        }

        return null;
    }

    public async Task PushAck(string origUuid, string value)
    {
        await this.sync.WaitAsync();

        try
        {
            this.messages.Add(origUuid, value);
        }
        finally
        {
            this.sync.Release();
        }
    }
}

class Program
{
    static async Task Main(string[] args)
    {
        var myform = new MyClass();

        var pub = Task.Run(() =>
        {
            int index = 0;

            while (true)
            {
                Task.Delay(1000).Wait();

                myform.PushAck(index.ToString(), "gotit").Wait();

                ++index;
            }
        });

        Stopwatch timer = new Stopwatch();
        timer.Start();

        var mymessage = await myform.WaitForAck("1");
        timer.Stop();

        Console.WriteLine($"message \"{mymessage}\" recieved in {timer.ElapsedMilliseconds} ms");
    }