Anzeige "Warten", Bildschirm in WPF

Tun es single-threaded ist wirklich das gehen zu sein, ein Schmerz, und es wird nie funktionieren, wie Sie möchten. Das Fenster wird schließlich schwarz in WPF, und das Programm wechselt zu "Reagiert Nicht".

Ich würde empfehlen, mit einem BackgroundWorker, um Ihre lang Laufenden task.

Es ist nicht so kompliziert. So etwas wie dies funktionieren würde.

private void DoWork(object sender, DoWorkEventArgs e)
{
    //Do the long running process
}

private void WorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    //Hide your wait dialog
}

private void StartWork()
{
   //Show your wait dialog
   BackgroundWorker worker = new BackgroundWorker();
   worker.DoWork += DoWork;
   worker.RunWorkerCompleted += WorkerCompleted;
   worker.RunWorkerAsync();
}

Können Sie sich dann an die ProgressChanged-Ereignis anzeigen, um eine Fortschritt, wenn Sie möchten (denken Sie daran, WorkerReportsProgress true). Sie können auch ein parameter übergeben werden, um runworkerasync erfasst, wenn Ihre DoWork-Methoden muss ein Objekt (in e.Argument).

Dies ist wirklich der einfachste Weg, anstatt zu versuchen, es zu tun ausgezeichnet eingefädelt.

Schauen Sie sich meine umfangreichen Forschungen von diesem sehr heiklen Thema. Wenn es nichts, was Sie tun können, um zu verbessern, die tatsächliche Leistungsfähigkeit, haben Sie die folgenden Optionen, um die Anzeige einer wartenden Nachricht:

Option #1 Ausführen einen code für die Anzeige einer wartenden Nachricht synchron in die gleiche Methode, die nicht die eigentliche Aufgabe. Nur setzen Sie diese Zeile vor ein langwieriger Prozess:

Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Normal, (Action)(() => { /* Your code to display a waiting message */ }));

Werde es Prozess anstehenden Meldungen auf der main-dispatcher-thread am Ende des Invoke().

Hinweis: Grund für die Auswahl der Anwendung.Aktuelle.Dispatcher Dispatcher aber.CurrentDispatcher erklärt hier.

Option #2 Display ein "Wait" - Bildschirm und update UI (Prozess anstehenden Meldungen).

Tun es WinForms Entwickler ausgeführt - Anwendung.DoEvents Methode. WPF bietet zwei alternativen, um ähnliche Ergebnisse erzielen:

Option #2.1 Mit DispatcherFrame Klasse.

Schauen Sie ein bisschen sperrig Beispiel aus MSDN:

[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
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;
}

Option #2.2 Aufrufen eine leere Aktion

Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, (Action)(() => { }));

Finden Sie Diskussionen, die man (2.1 oder 2.2) ist besser hier. IMHO option #1 ist immer noch besser als #2.

Option #3 Anzeige einer wartenden Nachricht in einem separaten Fenster.

Es kommt in handliches, wenn Sie die Anzeige nicht einfach warten, Nachricht, sondern eine animation. Rendern einer animation zum laden in der gleichen Zeit, die wir warten, für eine lange rendering-Vorgang abzuschließen, ist ein problem. Im Grunde brauchen wir zwei rendering-threads. Sie können nicht mehrere rendering-threads in einem einzigen Fenster, aber Sie können Ihre be-animation in einem neuen Fenster mit eigener rendering-thread und machen es so Aussehen, dass es nicht in einem separaten Fenster.

Download WpfLoadingOverlay.zip von dies github (es war ein Beispiel aus dem Artikel "WPF Reaktionsfähigkeit: Asynchrone Laden von Animationen Während der Wiedergabe", aber ich kann ihn nicht finden auf der Web mehr) oder haben einen Blick auf die Haupt-Idee unten:

public partial class LoadingOverlayWindow : Window
{
    ///<summary>
    ///    Launches a loading window in its own UI thread and positions it over <c>overlayedElement</c>.
    ///</summary>
    ///<param name="overlayedElement"> An element for overlaying by the waiting form/message </param>
    ///<returns> A reference to the created window </returns>
    public static LoadingOverlayWindow CreateAsync(FrameworkElement overlayedElement)
    {
        //Get the coordinates where the loading overlay should be shown
        var locationFromScreen = overlayedElement.PointToScreen(new Point(0, 0));

        //Launch window in its own thread with a specific size and position
        var windowThread = new Thread(() =>
            {
                var window = new LoadingOverlayWindow
                    {
                        Left = locationFromScreen.X,
                        Top = locationFromScreen.Y,
                        Width = overlayedElement.ActualWidth,
                        Height = overlayedElement.ActualHeight
                    };
                window.Show();
                window.Closed += window.OnWindowClosed;
                Dispatcher.Run();
            });
        windowThread.SetApartmentState(ApartmentState.STA);
        windowThread.Start();

        //Wait until the new thread has created the window
        while (windowLauncher.Window == null) {}

        //The window has been created, so return a reference to it
        return windowLauncher.Window;
    }

    public LoadingOverlayWindow()
    {
        InitializeComponent();
    }

    private void OnWindowClosed(object sender, EventArgs args)
    {
        Dispatcher.InvokeShutdown();
    }
}