AsyncLazy<T>.SuppressRelevance Método

Definição

Namespace:

Microsoft.VisualStudio.Threading

Assembly:

Microsoft.VisualStudio.Threading.dll

Pacote:

Microsoft.VisualStudio.Threading v17.12.19

Marca o código a seguir como irrelevante para a fábrica de valores de AsyncLazy<T> recebimento.

public Microsoft.VisualStudio.Threading.AsyncLazy<T>.RevertRelevance SuppressRelevance ();

member this.SuppressRelevance : unit -> Microsoft.VisualStudio.Threading.AsyncLazy<'T>.RevertRelevance

Public Function SuppressRelevance () As AsyncLazy(Of T).RevertRelevance

Retornos

AsyncLazy<T>.RevertRelevance

Um valor a ser descartado para restaurar a relevância na fábrica de valores.

Comentários

Em alguns casos, o trabalho assíncrono pode ser desativado dentro de uma fábrica de valores. Quando a fábrica de valores não exige que esse trabalho seja concluído antes que a fábrica de valores possa ser concluída, pode ser útil usar esse método para marcar esse código como irrelevante para a fábrica de valores. Em particular, isso pode ser necessário quando a tarefa desativada pode realmente incluir código que pode aguardar a conclusão da própria fábrica de valores. Tal situação levaria a uma geração InvalidOperationException de se a fábrica de GetValueAsync(CancellationToken) valores ainda não tiver sido concluída, o que pode introduzir falhas não determinísticas no programa.

Um using bloco em torno do código desativado pode ajudar seu programa a obter um comportamento confiável, conforme mostrado abaixo.

class MyClass {
  private readonly AsyncLazy<int> numberOfApples;

  public MyClass() {
    this.numberOfApples = new AsyncLazy<int>(async delegate {
      // We have some fire-and-forget code to run.
      // This is *not* relevant to the value factory, which is allowed to complete without waiting for this code to finish.
      using (this.numberOfApples.SuppressRelevance()) {
        this.FireOffNotificationsAsync();
      }

      // This code is relevant to the value factory, and must complete before the value factory can complete.
      return await this.CountNumberOfApplesAsync();
    });
  }

  public event EventHandler? ApplesCountingHasBegun;

  public async Task<int> GetApplesCountAsync(CancellationToken cancellationToken) {
    return await this.numberOfApples.GetValueAsync(cancellationToken);
  }

  private async Task<int> CountNumberOfApplesAsync() {
    await Task.Delay(1000);
    return 5;
  }

  private async Task FireOffNotificationsAsync() {
    // This may call to 3rd party code, which may happen to call back into GetApplesCountAsync (and thus into our AsyncLazy instance),
    // but such calls should *not* be interpreted as value factory reentrancy. They should just wait for the value factory to finish.
    // We accomplish this by suppressing relevance of the value factory while this code runs (see the caller of this method above).
    this.ApplesCountingHasBegun?.Invoke(this, EventArgs.Empty);
  }
}

Se o AsyncLazy<T> tiver sido criado com um JoinableTaskFactory, esse método também chamará SuppressRelevance() no associado a Context essa fábrica.