Wo ist die Application.DoEvents () in WPF?

Ich habe den folgenden Beispielcode, der jedes Mal zoomt, wenn eine Taste gedrückt wird:

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

Die Ausgabe ist:

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

Wie Sie sehen können, gibt es ein Problem, das ich mithilfe von lösen wollte, Application.DoEvents();aber ... es existiert nicht a priori in .NET 4.

Was ist zu tun?

Die alte Application.DoEvents () -Methode wurde in WPF zugunsten der Verwendung eines Dispatchers oder eines Background Worker-Threads für die von Ihnen beschriebene Verarbeitung veraltet . Unter den Links finden Sie einige Artikel zur Verwendung beider Objekte.

Wenn Sie Application.DoEvents () unbedingt verwenden müssen, können Sie einfach die Datei system.windows.forms.dll in Ihre Anwendung importieren und die Methode aufrufen. Dies wird jedoch wirklich nicht empfohlen, da Sie alle Vorteile verlieren, die WPF bietet.

Versuchen Sie so etwas

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

Nun, ich habe gerade einen Fall getroffen, 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 stellt sich heraus, dass msdn erklärt, wie ein DoEvents () basierend auf dem Dispatcher selbst implementiert wird:

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 der Dispatcher.PushFrame-Methode )

Einige bevorzugen es möglicherweise in einer einzigen Methode, die dieselbe Logik erzwingt:

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

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 besteht darin, dass die CPU im Leerlauf ausgelastet ist (meiner Erfahrung nach bis zu 12%). Dies ist in einigen Fällen nicht optimal, beispielsweise wenn das Verhalten der modalen Benutzeroberfläche mithilfe dieser Technik implementiert wird.

Die folgende Variante führt eine minimale Verzögerung zwischen Frames mit einem Timer ein (beachten Sie, dass sie hier mit Rx geschrieben wird, aber mit jedem regulären 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 asyncund es ist awaitnun möglich, den UI-Thread teilweise durch einen (ehemals) * synchronen Codeblock abzugeben, indem Task.Delayz

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 genauen Code oben versucht, aber ich verwende es in engen Schleifen, wenn ich viele Artikel in eine ItemsControlVorlage mit einer teuren Artikelvorlage lege und manchmal eine kleine Verzögerung hinzufüge, um den anderen zu geben Sachen auf der Benutzeroberfläche mehr Zeit.

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

Wenn es im Windows Store einen schönen Themenübergang in der Sammlung gibt, ist der Effekt durchaus wünschenswert.

Luke

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

Machen Sie Ihr DoEvent () in WPF:

Thread t = new Thread(() => {
            // do some thing in thread
            
            for (var i = 0; i < 500; i++)
            {
                Thread.Sleep(10); // in thread

                // call owner thread
                this.Dispatcher.Invoke(() => {
                    MediaItem uc = new MediaItem();
                    wpnList.Children.Add(uc);
                });
            }
            

        });
        t.TrySetApartmentState(ApartmentState.STA); //for using Clipboard in Threading
        t.Start();

Arbeite gut für mich!

Beantwortung der ursprünglichen Frage: Wo ist DoEvents?

Ich denke, DoEvents ist VBA. Und VBA scheint keine Schlaffunktion zu haben. VBA bietet jedoch die Möglichkeit, genau den gleichen Effekt wie Sleep oder Delay zu erzielen. Mir scheint, dass DoEvents dem Schlaf (0) entspricht.

In VB und C # handelt es sich um .NET. Und die ursprüngliche Frage ist eine C # -Frage. In C # würden Sie Thread.Sleep (0) verwenden, wobei 0 0 Millisekunden ist.

Du brauchst

using System.Threading.Task;

oben in der Datei, um zu verwenden

Sleep(100);

in Ihrem Code.