Language: HTML | XAML

So wird’s gemacht: Behandeln einer abgebrochenen Hintergrundaufgabe (XAML)

Applies to Windows and Windows Phone

Hier erfahren Sie, wie Sie eine Hintergrundaufgabe erstellen, die Abbruchanforderungen und Stopps erkennt und den Abbruch mithilfe des beständigen Speichers an die App meldet.

  • Applies to Windows Phone

Hinweis  In Windows Phone können Hintergrundaufgaben ohne Warnung und ohne Auslösen des "OnCanceled"-Ereignisses beendet werden, wenn der Arbeitsspeicher des Geräts knapp wird. Dadurch soll die Benutzerfreundlichkeit der App im Vordergrund sichergestellt werden. Entwerfen Sie die Hintergrundaufgabe so, dass dieses Szenario behandelt wird.

Wissenswertes

Technologien

Voraussetzungen

Anweisungen

Schritt 1: Verwenden der Methode "OnCanceled" zum Erkennen von Abbruchanforderungen

Schreiben Sie eine Methode für die Behandlung des Abbruchereignisses.

  1. Erstellen Sie eine Methode mit dem Namen "OnCanceled" und der folgenden Syntax. Diese Methode ist der Einstiegspunkt, der von der Windows-Runtime aufgerufen wird, wenn eine Abbruchanforderung für die Hintergrundaufgabe erfolgt.

    Die Methode "OnCanceled" muss wie folgt aussehen:

    
    
    private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
    {
        // TODO: Add code to notify the background task that it is cancelled.
    }
    
    
  2. Fügen Sie der Hintergrundaufgabenklasse eine Kennzeichenvariable mit dem Namen _CancelRequested hinzu. Diese Variable wird verwendet, um anzuzeigen, ob eine Abbruchanforderung erfolgt ist.

    
    volatile bool _CancelRequested = false;
    
    
  3. Legen Sie in der Methode "OnCanceled", die Sie in Schritt 1 erstellt haben, die Kennzeichenvariable _CancelRequested auf true fest.

    Die vollständige Methode "OnCanceled" des Beispiels zur Hintergrundaufgabe legt _CancelRequested auf true fest und gibt eine möglicherweise hilfreiche Debugmeldung aus:

    
    private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
    {
        //
        // Indicate that the background task is canceled.
        //
    
        _cancelRequested = true;
    
        Debug.WriteLine("Background " + sender.Task.Name + " Cancel Requested...");
    }
    
    
  4. Registrieren Sie in der Methode "Run" der Hintergrundaufgabe die OnCanceled-Ereignishandlermethode, bevor Sie mit der Arbeit beginnen.

    Verwenden Sie z. B. folgende Codezeile:

    
    
    taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);
    
    

Schritt 2: Behandeln des Abbruchs durch Verlassen der Run-Methode

Wenn eine Abbruchanforderung empfangen wird, muss die Run-Methode angehalten und verlassen werden, indem erkannt wird, dass _cancelRequested auf true festgelegt wurde.

  1. Ändern Sie den Code der Hintergrundaufgabenklasse, um die Kennzeichenvariable zu überprüfen, während die Hintergrundaufgabe ausgeführt wird. Wenn _cancelRequested auf "true" festgelegt ist, halten Sie die Fortsetzung der Arbeit an.

    Das Beispiel zur Hintergrundaufgabe enthält eine Überprüfung, die den regelmäßigen Zeitgeberrückruf anhält, wenn die Hintergrundaufgabe abgebrochen wird:

    
    
    if ((_cancelRequested == false) && (_progress < 100))
    {
        _progress += 10;
        _taskInstance.Progress = _progress;
    }
    else
    {
        _periodicTimer.Cancel();
    
        // TODO: Record whether the task completed or was cancelled.
    }
    
    

    Hinweis  Das oben dargestellte Codebeispiel verwendet die Eigenschaft IBackgroundTaskInstance.Progress, mit der der Fortschritt der Hintergrundaufgabe aufgezeichnet wird. Dadurch kann die Windows-Runtime den Fortschritt mit der Klasse BackgroundTaskProgressEventArgs zurück an die App melden.

  2. Ändern Sie die Run-Methode, damit sie nach dem Anhalten der Arbeit aufzeichnet, ob die Aufgabe ausgeführt oder abgebrochen wurde.

    Das Beispiel zur Hintergrundaufgabe zeichnet den Status in "LocalSettings" auf:

    
    
    if ((_cancelRequested == false) && (_progress < 100))
    {
        _progress += 10;
        _taskInstance.Progress = _progress;
    }
    else
    {
        _periodicTimer.Cancel();
    
        var settings = ApplicationData.Current.LocalSettings;
        var key = _taskInstance.Task.TaskId.ToString();
    
    
        //
        // Write to LocalSettings to indicate that this background task ran.
        //
    
        if (_cancelRequested)
        {
            settings.Values[key] = "Canceled";
        }
        else
        {
            settings.Values[key] = "Completed";
        }
    
    
        Debug.WriteLine("Background " + _taskInstance.Task.Name + (_cancelRequested ? " Canceled" : " Completed"));
    
    
        //
        // Indicate that the background task has completed.
        //
    
        _deferral.Complete();
    }
    
    

Anmerkungen

Sie können das Beispiel zur Hintergrundaufgabe herunterladen, um diese Codebeispiele im Kontext von Methoden anzuzeigen.

Zu Demonstrationszwecken enthält der obige Beispielcode nur Teile der Run-Methode (und des Rückrufzeitgebers) aus dem Beispiel zur Hintergrundaufgabe.

Beispiel der Run-Methode

Im Folgenden sind die vollständige Run-Methode und der Zeitgeberrückruf-Code aus dem Beispiel zur Hintergrundaufgabe aufgeführt:


//
// The Run method is the entry point of a background task.
//
public void Run(IBackgroundTaskInstance taskInstance)
{
    Debug.WriteLine("Background " + taskInstance.Task.Name + " Starting...");


    //
    // Associate a cancellation handler with the background task.
    //

    taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);


    //
    // Get the deferral object from the task instance, and take a reference to the taskInstance;
    //

    _deferral = taskInstance.GetDeferral();
    _taskInstance = taskInstance;

    _periodicTimer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(PeriodicTimerCallback), TimeSpan.FromMilliseconds(500));
}

//
// Simulate the background task activity.
//
private void PeriodicTimerCallback(ThreadPoolTimer timer)
{
    if ((_cancelRequested == false) && (_progress < 100))
    {
        _progress += 10;
        _taskInstance.Progress = _progress;
    }
    else
    {
        _periodicTimer.Cancel();

        var settings = ApplicationData.Current.LocalSettings;
        var key = _taskInstance.Task.TaskId.ToString();


        //
        // Write to LocalSettings to indicate that this background task ran.
        //

        if (_cancelRequested)
        {
            settings.Values[key] = "Canceled";
        }
        else
        {
            settings.Values[key] = "Completed";
        }

        Debug.WriteLine("Background " + _taskInstance.Task.Name + (_cancelRequested ? " Canceled" : " Completed"));


        //
        // Indicate that the background task has completed.
        //

        _deferral.Complete();
    }
}

Verwandte Themen

Schnellstart: Erstellen und Registrieren einer Hintergrundaufgabe
So wird's gemacht: Registrieren einer Hintergrundaufgabe
How to debug a background task
So wird's gemacht: Abrufen einer Liste mit ausstehenden Hintergrundaufgaben
So wird's gemacht: Überwachen des Status und Abschlusses von Hintergrundaufgaben
So wird's gemacht: Deklarieren von Hintergrundaufgaben im Anwendungsmanifest
How to debug a background task
Richtlinien und Prüflisten für Hintergrundaufgaben

 

 

Anzeigen:
© 2014 Microsoft