Attente synchrone pour une opération asynchrone, et pourquoi Wait () bloque le programme ici

appeler async le code du code synchrone peut être assez délicat.

j'explique les raisons complètes de cette impasse sur mon blog . En bref, il y a un "contexte" qui est enregistré par défaut au début de chaque await et pour reprendre la méthode.

donc si cela est appelé dans un contexte D'UI, lorsque la await est terminée, la méthode async essaie de revenir dans ce contexte pour continuer exécuter. Malheureusement, le code utilisant Wait (ou Result ) va bloquer un thread dans ce contexte, de sorte que la méthode async ne peut pas être complète.

Les lignes directrices pour éviter ce sont:

1. utiliser ConfigureAwait(continueOnCapturedContext: false) autant que possible. Cela permet à vos méthodes async de continuer à exécuter sans avoir à entrer de nouveau dans le contexte.
2. Utiliser async tout le chemin. Utilisez await au lieu de Result ou Wait .

si votre méthode est naturellement asynchrone, alors vous (probablement) ne devriez pas exposer une enveloppe synchrone .

voici ce que j'ai fait

private void myEvent_Handler(object sender, SomeEvent e)
{
  // I dont know how many times this event will fire
  Task t = new Task(() =>
  {
    if (something == true) 
    {
        DoSomething(e);  
    }
  });
  t.RunSynchronously();
}

fonctionne très bien et ne bloque pas thread d'INTERFACE utilisateur

avec un petit contexte de synchronisation personnalisé, la fonction de synchronisation peut attendre l'achèvement de la fonction async, sans créer d'impasse. Voici un petit exemple pour L'application WinForms.

Imports System.Threading
Imports System.Runtime.CompilerServices

Public Class Form1

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        SyncMethod()
    End Sub

    ' waiting inside Sync method for finishing async method
    Public Sub SyncMethod()
        Dim sc As New SC
        sc.WaitForTask(AsyncMethod())
        sc.Release()
    End Sub

    Public Async Function AsyncMethod() As Task(Of Boolean)
        Await Task.Delay(1000)
        Return True
    End Function

End Class

Public Class SC
    Inherits SynchronizationContext

    Dim OldContext As SynchronizationContext
    Dim ContextThread As Thread

    Sub New()
        OldContext = SynchronizationContext.Current
        ContextThread = Thread.CurrentThread
        SynchronizationContext.SetSynchronizationContext(Me)
    End Sub

    Dim DataAcquired As New Object
    Dim WorkWaitingCount As Long = 0
    Dim ExtProc As SendOrPostCallback
    Dim ExtProcArg As Object

    <MethodImpl(MethodImplOptions.Synchronized)>
    Public Overrides Sub Post(d As SendOrPostCallback, state As Object)
        Interlocked.Increment(WorkWaitingCount)
        Monitor.Enter(DataAcquired)
        ExtProc = d
        ExtProcArg = state
        AwakeThread()
        Monitor.Wait(DataAcquired)
        Monitor.Exit(DataAcquired)
    End Sub

    Dim ThreadSleep As Long = 0

    Private Sub AwakeThread()
        If Interlocked.Read(ThreadSleep) > 0 Then ContextThread.Resume()
    End Sub

    Public Sub WaitForTask(Tsk As Task)
        Dim aw = Tsk.GetAwaiter

        If aw.IsCompleted Then Exit Sub

        While Interlocked.Read(WorkWaitingCount) > 0 Or aw.IsCompleted = False
            If Interlocked.Read(WorkWaitingCount) = 0 Then
                Interlocked.Increment(ThreadSleep)
                ContextThread.Suspend()
                Interlocked.Decrement(ThreadSleep)
            Else
                Interlocked.Decrement(WorkWaitingCount)
                Monitor.Enter(DataAcquired)
                Dim Proc = ExtProc
                Dim ProcArg = ExtProcArg
                Monitor.Pulse(DataAcquired)
                Monitor.Exit(DataAcquired)
                Proc(ProcArg)
            End If
        End While

    End Sub

     Public Sub Release()
         SynchronizationContext.SetSynchronizationContext(OldContext)
     End Sub

End Class