Pendant que je codais la suite du projet (un premier bout ici) sur lequel je bosse actuellement (et qui fera l'objet d'un prochain post ), j'ai voulu utiliser la méthode suivante :

Application.DoEvents()

Or cette méthode n'existe pas dans WPF. Pour palier à cela j'ai effectué quelques recherches sur Internet et voici 2 différentes solutions que j'ai trouvées et ensuite testées, et qui peuvent remplacer cette méthode.

La première consiste à faire référence à System.Windows.Form.dll et à utiliser Application.DoEvents() qui est disponible dans cette assembly.

Le seconde consiste en deux méthodes qui permettent de remplacer la méthode souhaitée (je copie les méthodes pour ceux qui aurait la flemme de cliquer sur le lien, et pour les autres c'est par ici) :

using System;
using System.Windows;
using System.Windows.Threading;

namespace Sheva.Windows
{

/// <summary>
/// Designates a Windows Presentation Foundation application model with added functionalities.
/// </summary>

public class WpfApplication : Application
{
   private static DispatcherOperationCallback exitFrameCallback = new

   DispatcherOperationCallback(ExitFrame);

   /// <summary> 
   /// Processes all UI messages currently in the message queue.
   /// </summary>

   public static void DoEvents()
   {
      // Create new nested message pump.

      DispatcherFrame nestedFrame = new DispatcherFrame();

      // Dispatch a callback to the current message queue, when getting called,
      // this callback will end the nested message loop.
      // note that the priority of this callback should be lower than the that of UI event messages.

      DispatcherOperation exitOperation = Dispatcher.CurrentDispatcher.BeginInvoke(
      DispatcherPriority.Background, exitFrameCallback, nestedFrame);

      // pump the nested message loop, the nested message loop will
      // immediately process the messages left inside the message queue.

      Dispatcher.PushFrame(nestedFrame);

      // If the "exitFrame" callback doesn't get finished, Abort it.

      if (exitOperation.Status != DispatcherOperationStatus.Completed)
      {
         exitOperation.Abort();
      }
   }

   private static Object ExitFrame(Object state)
   {
      DispatcherFrame frame = state as DispatcherFrame;

      // Exit the nested message loop.

      frame.Continue = false;
      return null;
   }

}
}

J'aurai tendance à dire que la première méthode est la plus simple à mettre en place et la plus compréhensible pour quelqu'un qui devrait maintenir le code de l'application. La seconde permet de ne pas faire référence à une autre assembly, et de pouvoir modifier au besoin le travail du DoEvents().

Et vous qu'en pensez-vous ? Toutes les suggestions sont les bienvenues !