Wo ist die Application.DoEvents () in WPF?

Versuchen Sie so etwas

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

Nun, ich bin gerade auf einen Fall gestoßen, in dem ich mit der Arbeit an einer Methode beginne, die auf dem Dispatcher-Thread ausgeführt wird, und die blockiert werden muss, ohne den UI-Thread zu blockieren. Es stellte sich heraus, dass msdn erklärt, wie DoEvents () basierend auf dem Dispatcher selbst implementiert werden:

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;
}

(entnommen aus Dispatcher.PushFrame-Methode )

Wenn Sie nur die Fenstergrafik aktualisieren müssen, verwenden Sie diese besser

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

myCanvas.UpdateLayout();

scheint auch zu funktionieren.

Ein Problem bei beiden vorgeschlagenen Ansätzen ist, dass sie eine inaktive CPU-Auslastung mit sich bringen (nach meiner Erfahrung bis zu 12%). Dies ist in einigen Fällen suboptimal, wenn beispielsweise das modale Verhalten der Benutzeroberfläche mithilfe dieser Technik implementiert wird.

Die folgende Variation führt eine minimale Verzögerung zwischen Frames mit einem Timer ein (beachten Sie, dass dies hier mit Rx geschrieben ist, aber mit jedem normalen Timer erreicht werden kann):

 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()));

Seit der Einführung von async und await ist es jetzt möglich, den UI-Thread teilweise durch einen (früher) * synchronen Codeblock mit Task.Delay, Z.

private async 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;

    await Task.Delay(1); // In my experiments, 0 doesn't work. Also, I have noticed
                         // that I need to add as much as 100ms to allow the visual tree
                         // to complete its arrange cycle and for properties to get their
                         // final values (as opposed to NaN for widths etc.)

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

Ich bin ehrlich, ich habe es nicht mit dem exakten Code oben versucht, aber ich verwende es in engen Schleifen, wenn ich viele Elemente in eine ItemsControl lege, die eine teure Elementvorlage enthält, manchmal füge ich eine hinzu kleine Verzögerung, um den anderen Dingen auf der Benutzeroberfläche mehr Zeit zu geben.

Beispielsweise:

        var levelOptions = new ObservableCollection<GameLevelChoiceItem>();

        this.ViewModel[LevelOptionsViewModelKey] = levelOptions;

        var syllabus = await this.LevelRepository.GetSyllabusAsync();
        foreach (var level in syllabus.Levels)
        {
            foreach (var subLevel in level.SubLevels)
            {
                var abilities = new List<GamePlayingAbility>(100);

                foreach (var g in subLevel.Games)
                {
                    var gwa = await this.MetricsRepository.GetGamePlayingAbilityAsync(g.Value);
                    abilities.Add(gwa);
                }

                double PlayingScore = AssessmentMetricsProcessor.ComputePlayingLevelAbility(abilities);

                levelOptions.Add(new GameLevelChoiceItem()
                    {
                        LevelAbilityMetric = PlayingScore,
                        AbilityCaption = PlayingScore.ToString(),
                        LevelCaption = subLevel.Name,
                        LevelDescriptor = level.Ordinal + "." + subLevel.Ordinal,
                        LevelLevels = subLevel.Games.Select(g => g.Value),
                    });

                await Task.Delay(100);
            }
        }

Im Windows Store ist der Effekt bei einem Nice-Themaübergang in der Sammlung sehr wünschenswert.

Luke

• zeige Kommentare. Als ich schnell meine Antwort schrieb, dachte ich darüber nach, einen synchronen Codeblock zu nehmen und den Thread dann wieder an den Aufrufer zurückzugeben, wodurch der Codeblock asynchron wird. Ich möchte meine Antwort nicht komplett umformulieren, da die Leser dann nicht sehen können, worüber Servy und ich gestritten haben.