Qual è la differenza tra SynchronizationContext.Send e SynchronizationContext.Post?

Question

Grazie al buon lavoro di Jeremy Miller in Functional Programming For Everyday .NET Development, ho un executor di comando funzionante che fa tutto ciò che voglio (fare un po 'di fatica sul pool di thread, inviare risultati o errori al contesto di sincronizzazione e persino postare i progressi verso il contesto di sincronizzazione), ma non posso spiegare perché utilizza SynchronizationContext.Send dal pool di thread e Synchronization.Post dal Func passato nel metodo che esegue il sollevamento pesi. Ho letto la documentazione, diverse volte, ma non riesco a capire la differenza. Che cosa dovrei ottenere dal fatto che uno si chiama Send e uno si chiama Post? Sento la magia sta nel fatto Send "inizia una sincrono richiesta " e Post "avvia una richiesta asincrona ", ma entrambe le richieste provengono dal pool di thread e devono essere inviati/pubblicati di nuovo al thread UI.

Qualcuno può spiegare la differenza, anche se è solo un dispositivo mnemonico che mi consente di sapere quando scegliere l'uno rispetto all'altro?

Nel caso in cui è importante, questo è il mio codice prova dove io uso Post per inviare il progresso di nuovo alla UI:

private Action _ExecuteCommand 
       (SynchronizationContext context 
       , Action<int, int> progress 
       , Action<int, int> after) 
{ 
    int count = 3; 
    int accumulatedValue = 0; 
    int threadId = Thread.CurrentThread.ManagedThreadId; 
    for (int i = 0; i < count; i++) 
    { 
     Thread.Sleep(1000); 
     context.Post(delegate { progress(i + 1, threadId); }); 
     accumulatedValue += i; 
    } 

    return() => after(threadId, accumulatedValue); 
} 

Che _ExecuteCommand metodo viene passato come parametro command di seguito, per lo più dalla Articolo originale, che utilizza per inviare Send completamento e messaggio di errore alla UI:

public void Execute(Func<Action> command, Action<Exception> error) 
{ 
    ThreadPool.QueueUserWorkItem(o => 
    { 
     try 
     { 
      Action continuation = command(); 
      _Context.Send(s => continuation()); 
     } 
     catch (Exception e) 
     { 
      _Context.Send(s => error(e)); 
     } 
    }); 
} 

Answer 1

invia - sincrono: aspettare fo R risposta (o un'azione completata)

Post - asincrono: far scendere e proseguire

Così il vostro esempio utilizza i metodi corretti al momento giusto. Non è necessario interrompere il ciclo for finché non viene completato l'aggiornamento del progresso (al contrario).
E Execute desidera attendere il completamento dell'azione, altrimenti la gestione delle eccezioni non ha alcuno scopo.