Utilisation de SynchronizationContext pour renvoyer des événements à l'interface utilisateur pour WinForms ou WPF

Le problème immédiat

Votre problème immédiat est que SynchronizationContext.Current n'est pas configuré automatiquement pour WPF. De jeu, vous aurez besoin de faire quelque chose comme ceci dans votre TheUISync code lors de l'exécution sous WPF:

var context = new DispatcherSynchronizationContext(
                    Application.Current.Dispatcher);
SynchronizationContext.SetSynchronizationContext(context);
UISync = context;

Un problème plus profond

SynchronizationContext est lié à la COM+ et est conçu pour traverser les threads. Dans WPF, vous ne pouvez pas avoir un Répartiteur qui s'étend sur plusieurs threads, donc on SynchronizationContext ne peut pas vraiment la croix-fils. Il y a un certain nombre de scénarios dans lesquels une SynchronizationContext pouvez passer à un nouveau thread - en particulier tout ce qui appelle ExecutionContext.Run(). Donc, si vous utilisez SynchronizationContext de fournir des événements pour WinForms et WPF clients, vous devez être conscient que certains scénarios de rupture, par exemple une requête web à un service web ou un site hébergé dans le même processus serait un problème.

Comment se déplacer besoin SynchronizationContext

À cause de cela, je suggère l'utilisation de WPF Dispatcher mécanisme exclusivement à cette fin, même avec les WinForms code. Vous avez créé un "TheUISync" classe singleton qui stocke la synchronisation, ce qui indique clairement que vous avez d'une certaine façon à crochet dans le haut niveau de l'application. Cependant vous le faites, vous pouvez ajouter du code qui crée ajoute quelques WPF contenu de votre application WinForms, de sorte que Dispatcher de travail, puis utiliser la nouvelle Dispatcher mécanisme qui je décris ci-dessous.

À l'aide de Dispatcher au lieu de SynchronizationContext

WPF Dispatcher mécanisme réellement élimine le besoin pour un autre SynchronizationContext objet. Sauf si vous avez certains de l'interopérabilité des scénarios de partage de code avec des objets COM+ ou WinForms de l'Isu, la meilleure solution est d'utiliser Dispatcher au lieu de SynchronizationContext.

Cela ressemble à:

public class Foo 
{ 
  public event EventHandler FooDoDoneEvent; 

  public void DoFoo() 
  { 
    //stuff 
    OnFooDoDone(); 
  } 

  private void OnFooDoDone() 
  { 
    if(FooDoDoneEvent!=null)
      Application.Current.Dispatcher.BeginInvoke(
        DispatcherPriority.Normal, new Action(() =>
        {
          FooDoDoneEvent(this, new EventArgs()); 
        }));
  }
}

Remarque que vous n'avez plus besoin d'un TheUISync objet WPF poignées de détails pour vous.

Si vous êtes plus à l'aise avec l'ancienne delegate syntaxe, vous pouvez le faire de cette façon au lieu:

      Application.Current.Dispatcher.BeginInvoke(
        DispatcherPriority.Normal, new Action(delegate
        {
          FooDoDoneEvent(this, new EventArgs()); 
        }));

Aucun bug à corriger

Notez également qu'il existe un bug dans votre code d'origine qui est reproduite ici. Le problème est que FooDoneEvent peut être mis à null entre le moment OnFooDoDone est appelé et le temps de la BeginInvoke (ou Post dans le code d'origine) appelle le délégué. Le fix est un second test à l'intérieur du délégué:

    if(FooDoDoneEvent!=null)
      Application.Current.Dispatcher.BeginInvoke(
        DispatcherPriority.Normal, new Action(() =>
        {
          if(FooDoDoneEvent!=null)
            FooDoDoneEvent(this, new EventArgs()); 
        }));