Como lidar com maiúsculas e minúsculas, em que o usuário pode pressionar o botão, que chama a operação assíncrona de execução longa, várias vezes.

Minha idéia foi verificar primeiro se a operação assíncrona está sendo executada, cancelá-la e acioná-la novamente.

Até o momento, tentei criar esse tipo de funcionalidade usando CancellationTokenSource, mas não está funcionando conforme o esperado. Algumas vezes, existem duas operações assíncronas em execução, portanto as operações assíncronas "antigas" ainda não são canceladas quando inicio uma nova e isso confunde a manipulação de resultados.

Alguma sugestão ou exemplo de como lidar com esse tipo de caso?

public async void Draw()
{
    bool result = false;

    if (this.cts == null)
    {
        this.cts = new CancellationTokenSource();

        try
        {
            result = await this.DrawContent(this.TimePeriod, this.cts.Token);
        }
        catch (Exception ex)
        {}
        finally
        {
            this.cts = null;
        }
    }

    else
    {
        this.cts.Cancel();
        this.cts = new CancellationTokenSource();

        try
        {
            result = await this.DrawContent(this.TimePeriod, this.cts.Token);
        }
        catch (Exception ex)
        {}
        finally
        {
            this.cts = null;
        }
    }

}

EDIT: No final, acho que não é ruim que haja duas operações assíncronas em execução em pouco tempo (quando o novo é acionado, mas o antigo ainda não foi cancelado).

O verdadeiro problema aqui é como eu mostro o progresso do usuário final. Como quando a operação assíncrona antiga termina, oculta o indicador de progresso do usuário final, mas a operação assíncrona recém-acionada ainda está em execução.

EDIT2: Inside DrawContent (...) Eu uso ThrowIfCancellationRequested, portanto, o cancelamento da tarefa em execução parece funcionar corretamente.

Sobre a exibição do progresso. Quando o Draw () é chamado, defino o indicador de carregamento visível e, quando esse método termina, oculto o indicador de carregamento. Portanto, agora, quando a operação assíncrona anterior é cancelada após iniciar uma nova, meu indicador de carregamento fica oculto. Como devo acompanhar se ainda existe outro método assíncrono em execução quando o "antigo" termina.