c# - 可等待的 lambda

Question

关键听众的动态评价

public class KeyUpper {
    Func<Key, bool> _evaluate;

    public void RegisterEvaluator(Func<Key, bool> evaluate){
        _evaluate = evaluate;
    }

    public void KeyUp(object sender, KeyEventArgs e){
        if (_evaluate(e.KeyCode))
            SomeResponse();
    }

    public void SomeResponse(){
        // ...
    }
}

这个 Lambda 应该在每一行等待

keyUpper.RegisterEvaluator(key => 
    {
    if (key == Key.A)
        if (key == Key.W)
            if (key == Key.A)
                return true;
    }
);

• 即客户端代码将对相同的 key 参数提供一系列评估，并期望等待每一行评估，以便在一系列 1:A 2 的 keyup 事件之后调用 SomeResponse() :W 3:A
• 显然目前永远不会发生，因为该方法一直运行到最后，key == Key.W 永远不会为真
• 这可能是不可能的，但是有没有办法让方法调用在计算结果为 false 时自动从下一行返回，但返回到它直到该行计算结果为 true，然后一直到下一行，然后到方法结束后的那一行？
• 即可能有一种简单的方法来提供这种可等待的 lambda 表达式吗？

Answer 1

如果异步性不是必需的，并且您可以接受一个几乎总是等待的线程，您可以通过为 lambda 提供一些阻塞方式来访问 key 来实现。例如:

public void RegisterEvaluator(Func<Func<Key>, bool> evaluate);

…

keyUpper.RegisterEvaluator(
    getKey => getKey() == Key.A && getKey() == Key.W);

RegisterEvaluator然后将启动一个新线程，在循环中调用 lambda，向它传递一个访问 key 的方法，如果此时没有可用 key ，则阻塞，例如使用 BlockingCollection<Key> .

如果你认为这样做很浪费(确实如此)，你可以使用 async-await，只需将 lambda async并将传入的方法也更改为异步方法:

public Task RegisterEvaluator(Func<Func<Task<Key>>, Task<bool>> evaluate);

…

keyUpper.RegisterEvaluator(
    async getKey => await getKey() == Key.A && await getKey() == Key.W);

后一个版本的实现(使用 BlockBuffer<Key> )可能如下所示:

class KeyUpper
{
    private readonly BufferBlock<Key> m_keyBuffer = new BufferBlock<Key>();

    public async Task RegisterEvaluator(
        Func<Func<Task<Key>>, Task<bool>> evaluate)
    {
        while (true)
        {
            if (await evaluate(m_keyBuffer.ReceiveAsync))
                SomeResponse();
        }
    }

    public void KeyUp(object sender, KeyEventArgs e)
    {
        m_keyBuffer.Post(e.Key);
    }

    private void SomeResponse()
    {
        // whatever
    }
}

现在，我不确定您想如何处理匹配键，但我认为不是这样的。例如，此示例代码将匹配键序列 BAW , 但不是 AAW .

另一种选择是不使用 Func<Task<Key>> ，但是您的自定义可等待对象可以等待多次，并且每次执行此操作时都会提供一个 key :

public Task RegisterEvaluator(Func<KeyAwaitable, Task<bool>> evaluate);

…

keyUpper.RegisterEvaluator(
    async getKey => await getKey == Key.A && await getKey == Key.W);

但我认为这样做更令人困惑，也更难做到。