JoinableTaskContext Classe

Définition

Espace de noms:

Microsoft.VisualStudio.Threading

Assembly:

Microsoft.VisualStudio.Threading.dll

Paquet:

Microsoft.VisualStudio.Threading v17.11.20

Contexte courant dans lequel les tâches assemblables peuvent être créées et interagies pour éviter des interblocages.

public ref class JoinableTaskContext : IDisposable, Microsoft::VisualStudio::Threading::IHangReportContributor

public class JoinableTaskContext : IDisposable, Microsoft.VisualStudio.Threading.IHangReportContributor

type JoinableTaskContext = class
    interface IHangReportContributor
    interface IDisposable

Public Class JoinableTaskContext
Implements IDisposable, IHangReportContributor

Héritage

Object

JoinableTaskContext

Implémente

IHangReportContributor IDisposable

Remarques

Trois règles doivent être strictement suivies lors de l’utilisation ou de l’interaction avec JoinableTasks : 1. Si une méthode a certaines exigences d’appartement de thread (STA ou MTA), elle doit : a) avoir une signature asynchrone et marshaler de manière asynchrone sur le thread approprié si elle n’est pas appelée à l’origine sur un thread compatible. La méthode recommandée pour basculer vers le thread main est la suivante :

await JoinableTaskFactory.SwitchToMainThreadAsync();

b) Avoir une signature synchrone et lever une exception quand elle est appelée sur le thread incorrect. En particulier, aucune méthode n’est autorisée à marshaler de manière synchrone le travail vers un autre thread (bloquant pendant que ce travail est effectué). Les blocs synchrones en général doivent être évités dans la mesure du possible. 2. Lorsqu’une implémentation d’une API publique déjà fournie doit appeler du code asynchrone et bloquer pour son achèvement, elle doit le faire en suivant ce modèle simple :

JoinableTaskFactory.Run(async delegate {
    await SomeOperationAsync(...);
});

3. Si vous attendez un travail démarré précédemment, celui-ci doit être joint. Par exemple, un service lance un travail asynchrone qui peut devenir par la suite bloquant de manière synchrone :

JoinableTask longRunningAsyncWork = JoinableTaskFactory.RunAsync(async delegate {
    await SomeOperationAsync(...);
});

Ensuite, plus tard, le travail asynchrone devient bloquant :

longRunningAsyncWork.Join();

ou peut-être :

await longRunningAsyncWork;

Notez toutefois que cette étape supplémentaire n’est pas nécessaire lorsque l’attente est effectuée immédiatement après le lancement d’une opération asynchrone.

Constructeurs

JoinableTaskContext()	Initialise une nouvelle instance de la JoinableTaskContext classe en supposant que le thread actuel est le thread main et Current fournit les moyens de basculer vers le thread main à partir d’un autre thread.
JoinableTaskContext(Thread, SynchronizationContext)	Initialise une nouvelle instance de la classe JoinableTaskContext.

Propriétés

Factory	Obtient la fabrique qui crée des tâches joignables qui n'appartiennent pas à une collection de tâches joignables.
IsOnMainThread	Obtient une valeur indiquant si l’appelant s’exécute sur le thread main.
IsWithinJoinableTask	Obtient une valeur indiquant si l’appelant est en cours d’exécution dans le contexte d’une tâche joignable.
MainThread	Obtient le thread principal qui peut être partagé par les tâches créées par ce contexte.
NoMessagePumpSynchronizationContext	Obtient un SynchronizationContext qui, lorsqu’il est appliqué, supprime toute pompe de messages qui peut s’exécuter pendant les blocs synchrones du thread appelant.

Méthodes

Capture()	Capture le contexte de l’appelant et le sérialise en tant que chaîne adaptée à l’application via un appel suivant à RunAsync(Func<Task>, String, JoinableTaskCreationOptions).
CreateCollection()	Crée une collection pour les tâches assemblables à la volée.
CreateDefaultFactory()	Crée une fabrique sans JoinableTaskCollection.
CreateFactory(JoinableTaskCollection)	Crée une fabrique de tâches assemblables qui ajoute automatiquement toutes les tâches créées à une collection qui peut être assemblée conjointement.
Dispose()	Contexte courant dans lequel les tâches assemblables peuvent être créées et interagies pour éviter des interblocages.
Dispose(Boolean)	Supprime les ressources managées et non managées détenues par ce instance.
GetHangReport()	Fournit des données pour un rapport de blocage.
IsMainThreadBlocked()	Obtient une valeur indiquant si le thread main est bloqué pour l’achèvement de l’appelant.
IsMainThreadMaybeBlocked()	Obtient une valeur très probable si le thread main est bloqué pour l’achèvement de l’appelant. Il est moins précis lorsque la tâche de blocage du thread d’interface utilisateur démarre et n’a pas encore été bloquée, ou que la chaîne de dépendances est simplement supprimée. Toutefois, contrairement à IsMainThreadBlocked(), cette implémentation est sans verrou et plus rapide dans les scénarios de conflit élevé.
OnFalseHangDetected(TimeSpan, Guid)	Appelé lorsqu’un rapport de blocage antérieur est une fausse alarme.
OnHangDetected(TimeSpan, Int32, Guid)	Appelé lorsqu’un blocage est soupçonné d’avoir eu lieu impliquant le thread main.
SuppressRelevance()	Cache toutes les tâches JoinableTask avec lesquelles l'appelant est associé jusqu'à ce que la valeur retournée soit supprimée.

Implémentations d’interfaces explicites

IHangReportContributor.GetHangReport()

Fournit des données pour un rapport de blocage.

Cohérence de thread

Ce type est thread-safe pour tous les membres.