AsyncLazy<T>.SuppressRelevance Méthode

Définition

Espace de noms:

Microsoft.VisualStudio.Threading

Assembly:

Microsoft.VisualStudio.Threading.dll

Paquet:

Microsoft.VisualStudio.Threading v17.12.19

Marque le code qui suit comme non pertinent pour la fabrique de valeurs de AsyncLazy<T> réception.

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

Retours

AsyncLazy<T>.RevertRelevance

Valeur à supprimer pour rétablir la pertinence dans la fabrique de valeurs.

Remarques

Dans certains cas, le travail asynchrone peut être lancé à l’intérieur d’une fabrique de valeurs. Lorsque la fabrique de valeurs ne nécessite pas la fin de ce travail avant la fin de la fabrique de valeurs, il peut être utile d’utiliser cette méthode pour marquer ce code comme non pertinent pour la fabrique de valeurs. En particulier, cela peut être nécessaire lorsque la tâche spun off peut réellement inclure du code qui peut lui-même attendre l’achèvement de la fabrique de valeurs elle-même. Une telle situation entraînerait une InvalidOperationException levée à partir de si la fabrique de GetValueAsync(CancellationToken) valeurs n’est pas déjà terminée, ce qui peut introduire des défaillances non détermintiques dans le programme.

Un using bloc autour du code spun off peut aider votre programme à obtenir un comportement fiable, comme indiqué ci-dessous.

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

Si a AsyncLazy<T> été créé avec un JoinableTaskFactory, cette méthode appelle SuppressRelevance() également sur le Context associé à cette fabrique.