Où se trouve la fonction Application.DoEvents() dans WPF ?

Question

J'ai l'exemple de code suivant qui effectue un zoom à chaque fois qu'un bouton est pressé :

XAML :

<Window x:Class="WpfApplication12.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">

    <Canvas x:Name="myCanvas">

        <Canvas.LayoutTransform>
            <ScaleTransform x:Name="myScaleTransform" />
        </Canvas.LayoutTransform> 

        <Button Content="Button" 
                Name="myButton" 
                Canvas.Left="50" 
                Canvas.Top="50" 
                Click="myButton_Click" />
    </Canvas>
</Window>

*.cs

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void myButton_Click(object sender, RoutedEventArgs e)
    {
        Console.WriteLine("scale {0}, location: {1}", 
            myScaleTransform.ScaleX,
            myCanvas.PointToScreen(GetMyByttonLocation()));

        myScaleTransform.ScaleX =
            myScaleTransform.ScaleY =
            myScaleTransform.ScaleX + 1;

        Console.WriteLine("scale {0}, location: {1}",
            myScaleTransform.ScaleX,
            myCanvas.PointToScreen(GetMyByttonLocation()));
    }

    private Point GetMyByttonLocation()
    {
        return new Point(
            Canvas.GetLeft(myButton),
            Canvas.GetTop(myButton));
    }
}

le résultat est :

scale 1, location: 296;315
scale 2, location: 296;315

scale 2, location: 346;365
scale 3, location: 346;365

scale 3, location: 396;415
scale 4, location: 396;415

comme vous pouvez le voir, il y a un problème, que j'ai pensé résoudre en utilisant Application.DoEvents(); mais... il n'existe pas a priori dans .NET 4.

Que faire ?

Answer 1

Essayez quelque chose comme ceci

public static void DoEvents()
{
    Application.Current.Dispatcher.Invoke(DispatcherPriority.Background,
                                          new Action(delegate { }));
}

Answer 2

Eh bien, je viens de rencontrer un cas où je commence à travailler sur une méthode qui s'exécute sur le thread du Dispatcher, et il faut qu'elle se bloque sans bloquer le thread de l'interface utilisateur. Il s'avère que msdn explique comment implémenter un DoEvents() basé sur le Dispatcher lui-même :

public void DoEvents()
{
    DispatcherFrame frame = new DispatcherFrame();
    Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background,
        new DispatcherOperationCallback(ExitFrame), frame);
    Dispatcher.PushFrame(frame);
}

public object ExitFrame(object f)
{
    ((DispatcherFrame)f).Continue = false;

    return null;
}

(extrait de Méthode Dispatcher.PushFrame )

Certains préfèreront peut-être une méthode unique qui appliquera la même logique :

public static void DoEvents()
{
    var frame = new DispatcherFrame();
    Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background,
        new DispatcherOperationCallback(
            delegate (object f)
            {
                ((DispatcherFrame)f).Continue = false;
                return null;
            }),frame);
    Dispatcher.PushFrame(frame);
}

Answer 3

L'ancienne méthode Application.DoEvents() a été dépréciée dans WPF en faveur de l'utilisation d'une méthode de type Dispatcher ou un Fil de travail d'arrière-plan pour effectuer le traitement que vous avez décrit. Voir les liens pour un couple d'articles sur la façon d'utiliser les deux objets.

Si vous devez absolument utiliser Application.DoEvents(), vous pouvez simplement importer la dll system.Windows.forms.dll dans votre application et appeler la méthode. Toutefois, cela n'est pas vraiment recommandé, car vous perdez tous les avantages offerts par WPF.

Answer 4

myCanvas.UpdateLayout();

semble fonctionner aussi bien.

Answer 5

Un problème avec les deux approches proposées est qu'elles impliquent une utilisation inactive du CPU (jusqu'à 12% dans mon expérience). Cela est sous-optimal dans certains cas, par exemple lorsque le comportement modal de l'interface utilisateur est mis en œuvre en utilisant cette technique.

La variation suivante introduit un délai minimum entre les trames en utilisant un timer (notez qu'il est écrit ici avec Rx mais peut être réalisé avec n'importe quel timer ordinaire) :

 var minFrameDelay = Observable.Interval(TimeSpan.FromMilliseconds(50)).Take(1).Replay();
 minFrameDelay.Connect();
 // synchronously add a low-priority no-op to the Dispatcher's queue
 Application.Current.Dispatcher.Invoke(DispatcherPriority.Background, new Action(() => minFrameDelay.Wait()));