Início / coding / Perguntas / 77462353
Accepted
David Thielen
Asked: 2023-11-11 03:13:15 +0800 CST

Como executar o código quando o segundo método for concluído

  • 772

Tenho uma situação em que preciso executar algum código no final de 1 de 2 métodos - o que for concluído em segundo lugar. Meu caso particular é o servidor Blazor onde preciso executar este código no final de OnInitializedAsync()/OnAfterRenderAsync(). Nesse caso, o código depende de o JavaScript poder ser chamado e de o modelo da página ser totalmente preenchido a partir do banco de dados.

Eu criei a seguinte classe para fazer isso:

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;
            }
        }
    }
}

Então, em meu arquivo razor.cs, tenho o seguinte (os dois métodos em que estão podem estar em tarefas diferentes e, portanto, estar em execução ao mesmo tempo):

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

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

Eu tenho duas perguntas:

  1. Preciso declarar os bools em DoubleFinish volatile?
  2. Existe algum tipo de chamada atômica para verificar/definir os valores bool que evita o uso de lock?

Atualização: uma restrição importante. OnInitializedAsync()pode ser chamado duas vezes em algumas configurações. Então não posso usar um contador. Tenho que monitorar especificamente se cada método foi concluído.

c#

2 respostas

  1. Acho que seria mais simples usar o Interlocked.Decrementmétodo, e diminuir atomicamente um contador inteiro. Quando o contador chegar a zero, você pode ter certeza de que a última operação pendente foi concluída:

    private int _pendingCount = 2;

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

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

    Atualizado: Caso cada um dos dois métodos possa ser chamado mais de uma vez, fica mais complexo, mas você ainda pode usar a Interlockedclasse. Aqui está uma implementação da operação OR bit a bit atômica para o uinttipo:

    /// <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;
    }
}

    Poderia ser usado assim:

    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

    Uma coisa que você pode fazer é usar Interlocked.Increment:

    private int counter = 2;

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

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

    Ou SemaphoreSlimou AsyncCountdownEventde Nito.AsyncEx.Coordination. Algo como o seguinte (se for viável no contexto do Blazor):

    private AsyncCountdownEvent signal = new AsyncCountdownEvent(2);

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

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

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

    Atualização

    Se OnInitializedAsyncpuder ser executado várias vezes, sua solução deverá funcionar bem. Observe que você deve evitar usar lock(this), basta criar um private object _locker = new object();campo para bloqueio e volátil não deve ser necessário, pois você está usando booleanos apenas dentro de bloqueios.

    Ou você pode brincar com essa monstruosidade (embora eu preferisse o bloqueio):

    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

relate perguntas