主页 / coding / 问题 / 77462353
Accepted
David Thielen
Asked: 2023-11-11 03:13:15 +0800 CST

当第二个方法完成时如何执行代码

  • 772

我遇到一种情况，我需要在 2 个方法中的 1 个方法结束时执行一些代码 - 以第二个完成者为准。我的特殊情况是 Blazor 服务器，我需要在 OnInitializedAsync()/ OnAfterRenderAsync() 末尾执行此代码。在这种情况下，代码取决于可调用的 JavaScript 以及完全从数据库填充的页面模型。

我想出了以下课程来完成此任务：

public class DoubleFinish
{
    private volatile bool _firstFinished = false;
    private volatile bool _secondFinished = false;
    private volatile bool _alreadyReturnedTrue = false;

    /// <summary>
    /// Call when the first method completes. Returns true if the 2nd method is also
    /// complete and so this method can now run the code that requires both methods.
    /// </summary>
    public bool TryFirstFinished
    {
        get
        {
            lock (this)
            {
                _firstFinished = true;
                if (_alreadyReturnedTrue || ! _secondFinished)
                    return false;
                _alreadyReturnedTrue = true;
                return true;
            }
        }
    }

    /// <summary>
    /// Call when the second method completes. Returns true if the 1st method is also
    /// complete and so this method can now run the code that requires both methods.
    /// </summary>
    public bool TrySecondFinished
    {
        get
        {
            lock (this)
            {
                _secondFinished = true;
                if (_alreadyReturnedTrue || ! _firstFinished)
                    return false;
                _alreadyReturnedTrue = true;
                return true;
            }
        }
    }
}

然后，我在 razor.cs 文件中包含以下内容（这两个方法可以位于不同的任务中，因此可以同时执行）：

OnInitializedAsync() {
    // ... lots of DB access
    if (DoubleFinish.TryFirstFinished)
        await OnAfterInitializeAndRenderAsync();
}

OnAfterRenderAsync(bool firstRender) {
    if (!firstRender)
        return;
    if (DoubleFinish.TrySecondFinished)
        await OnAfterInitializeAndRenderAsync();
}

我有两个问题：

  1. 我需要在 中声明布尔值吗DoubleFinish volatile？
  2. 是否有某种原子调用来检查/设置避免使用的 bool 值lock？

更新：一个主要限制。OnInitializedAsync()在某些配置中可以被调用两次。所以我不能使用计数器。我必须具体跟踪每个方法是否已完成。

c#

2 个回答

  1. 我认为使用该Interlocked.Decrement方法会更简单，并自动减少整数计数器。当计数器减至零时，您可以确定最后一个挂起的操作已完成：

    private int _pendingCount = 2;

OnInitializedAsync()
{
    // ...
    if (Interlocked.Decrement(ref _pendingCount) == 0)
        await OnAfterInitializeAndRenderAsync();
}

OnAfterRenderAsync()
{
    // ...
    if (Interlocked.Decrement(ref _pendingCount) == 0)
        await OnAfterInitializeAndRenderAsync();
}

    更新：如果这两个方法中的每一个都可以被调用多次，它会变得更加复杂，但您仍然可以使用该类Interlocked。以下是该类型的原子按位 OR运算的实现uint：

    /// <summary>
/// Returns the result of an atomic bitwise OR operation.
/// </summary>
static uint AtomicBitwiseOr(ref uint location, uint operand)
{
    uint oldValue = location;
    while (true)
    {
        uint newValue = oldValue | operand;
        uint original = Interlocked.CompareExchange(ref location, newValue, oldValue);
        if (original == oldValue) return newValue;
        oldValue = original;
    }
}

    它可以这样使用：

    private uint _state = 0;

OnInitializedAsync()
{
    // ...
    if (AtomicBitwiseOr(ref _state, 0b1) == 0b11)
        await OnAfterInitializeAndRenderAsync();
}

OnAfterRenderAsync()
{
    // ...
    if (AtomicBitwiseOr(ref _state, 0b10) == 0b11)
        await OnAfterInitializeAndRenderAsync();
}
    • 1
  2. Best Answer

    你可以做的一件事是使用Interlocked.Increment：

    private int counter = 2;

OnInitializedAsync()
{
    // ...
    if (Interlocked.Increment(ref counter) == 2)
        YourCodeToRun();
}

OnAfterRenderAsync(bool firstRender)
{
    // ...
    if (Interlocked.Increment(ref counter) == 2)
        YourCodeToRun();
}

    或SemaphoreSlim或AsyncCountdownEvent从Nito.AsyncEx.Coordination. 类似于以下内容（如果在 Blazor 上下文中可行）：

    private AsyncCountdownEvent signal = new AsyncCountdownEvent(2);

Task.Run(async () =>
{
    await signal.WaitAsync();
    YourCodeToRun();
})

OnInitializedAsync()
{
    // ...
    signal.Signal();
}

OnAfterRenderAsync(bool firstRender)
{
    // ...
    signal.Signal();
}

    UPD

    如果OnInitializedAsync可以运行多次，那么您的解决方案应该没问题。请注意，您应该避免使用lock(this)，只需创建一个private object _locker = new object();用于锁定的字段，并且不需要 volatile ，因为您仅在锁内部使用布尔值。

    或者你可以玩这样的怪物（尽管我会坚持使用锁定）：

    private int flag1 = 0;
private int flag2 = 0;
private int hasRun = 0;

OnInitializedAsync()
{
    // ...
    Interlocked.Exchange(ref flag1, 1);
    if(Interlocked.Read(ref flag1) + Interlocked.Read(ref flag2) == 2 && Interlocked.Exchange(ref hasRun, 1) == 0)
        YourCodeToRun();
}

OnAfterRenderAsync(bool firstRender)
{
    // ...
    Interlocked.Exchange(ref flag2, 1);
    if(Interlocked.Read(ref flag1) + Interlocked.Read(ref flag2) == 2 && Interlocked.Exchange(ref hasRun, 1) == 0)
        YourCodeToRun();
}
    • 0

相关问题