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

Artikel
12/12/2015

[ Dieser Artikel richtet sich an Windows 8.x- und Windows Phone 8.x-Entwickler, die Windows-Runtime-Apps schreiben. Wenn Sie für Windows 10 entwickeln, finden Sie weitere Informationen unter neueste Dokumentation]

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

Hinweis Für Windows Phone Store-Apps 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

In diesem Thema wird davon ausgegangen, dass Sie bereits eine Hintergrundaufgabe mit JavaScript erstellt haben. Informationen zum schnellen Erstellen einer Hintergrundaufgabe finden Sie unter Schnellstart: Erstellen und Registrieren einer Hintergrundaufgabe. Ausführlichere Informationen zu Bedingungen und Triggern finden Sie unter Unterstützen der App mit Hintergrundaufgaben.

Anweisungen

Schritt 1: Verwenden eines Ereignishandlers zum Erkennen von Abbruchanforderungen

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

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 Funktion "OnCanceled" muss wie folgt aussehen:
```
function onCanceled(cancelSender, cancelReason)
{
    // TODO: Add code to notify the background task that it is cancelled.
}
```
Fügen Sie der Hintergrundaufgabe die Variable cancel hinzu. Diese gibt den Erhalt einer Abbruchanforderung an.

Setzen Sie beispielsweise diese Codezeile zusammen mit anderen Variablendefinitionen an den Anfang der Klasse "IBackgroundTask":
```
var cancel = false;
```
Legen Sie in der Methode "OnCanceled", die Sie in Schritt 1 erstellt haben, cancel auf true fest.

Im vollständigen Beispiel zur Hintergrundaufgabe legt die "OnCanceled"-Methode cancel auf true fest:
```
function onCanceled(cancelSender, cancelReason) {
    cancel = true;
}
```
Registrieren Sie die "OnCanceled"-Methode mit dem Ereignislistener "canceled", bevor Sie in der Hintergrundaufgabe mit der Arbeit beginnen.

Verwenden Sie z. B. folgende Codezeile:
```
backgroundTaskInstance.addEventListener("canceled", onCanceled);
```

Schritt 2: Behandeln von Abbrechen und Beenden

Die "Run"-Methode muss die cancel-Variable überwachen, sodass sie abbrechen kann, wenn die Variable auf true festgelegt wird.

Ändern Sie den Code der Hintergrundaufgabe so, dass die Arbeit beendet wird, wenn cancel auf "true" festgelegt wird.

Das Beispiel zur Hintergrundaufgabe enthält eine Überprüfung, die den regelmäßigen Zeitgeberrückruf anhält, wenn die Hintergrundaufgabe abgebrochen wird:
```
if (!cancel) {
    // Do work.
}
else
{
    // Cancel.
}
```

Räumen Sie nach Beendigung der Arbeit auf, indem Sie die succeeded-Eigenschaft der Instanz der Hintergrundaufgabe auf "false" festlegen, und halten Sie fest, dass die Aufgabe abgebrochen wurde. Rufen Sie dann close() auf, um die Funktion zu verlassen.

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


if ((_cancelRequested == false) && (_progress < 100))
{
    // See the background task sample for this code.
}
else
{
    //
    // If the cancellation handler indicated that the task was canceled, stop the background task.
    //
    console.log("Background " + backgroundTaskInstance.task.name + " Canceled");
    backgroundTaskInstance.succeeded = false;

    key = backgroundTaskInstance.task.taskId.toString();
    settings.values[key] = "Canceled";

    close();
}

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 zur Run-Methode

Im Folgenden wird die vollständige Hintergrundaufgabe in JavaScript aus dem Beispiel zur Hintergrundaufgabe im Kontext aufgeführt:

//
// A JavaScript background task runs a specified JavaScript file.
//
(function () {
    "use strict";

    //
    // The background task instance's activation parameters are available via Windows.UI.WebUI.WebUIBackgroundTaskInstance.current
    //
    var cancel = false,
        progress = 0,
        backgroundTaskInstance = Windows.UI.WebUI.WebUIBackgroundTaskInstance.current;

    console.log("Background " + backgroundTaskInstance.task.name + " Starting...");

    //
    // Associate a cancellation handler with the background task.
    //
    function onCanceled(cancelSender, cancelReason) {
        cancel = true;
    }
    backgroundTaskInstance.addEventListener("canceled", onCanceled);

    //
    // This function is set to run every 1000 milliseconds ten times and perform background task activity.
    //
    function onTimer() {
        var key = null,
            settings = Windows.Storage.ApplicationData.current.localSettings;

        if (!cancel) {
            if (progress < 100) {
                //
                // Simulate work being done.
                //
                setTimeout(onTimer, 1000);

                //
                // Indicate progress to the foreground application.
                //
                backgroundTaskInstance.progress = progress;
                progress += 10;
            } else {
                //
                // Use the succeeded property to indicate that this background task completed successfully.
                //
                backgroundTaskInstance.succeeded = true;
                backgroundTaskInstance.progress = progress;
                console.log("Background " + backgroundTaskInstance.task.name + " Completed");

                //
                // Write to localSettings to indicate that this background task completed.
                //
                key = backgroundTaskInstance.task.name;
                settings.values[key] = "Completed";

                //
                // A JavaScript background task must call close when it is done.
                //
                close();
            }
        } else {
            //
            // If the cancellation handler indicated that the task was canceled, stop the background task.
            //
            console.log("Background " + backgroundTaskInstance.task.name + " Canceled");
            backgroundTaskInstance.succeeded = false;

            key = backgroundTaskInstance.task.taskId.toString();
            settings.values[key] = "Canceled";

            close();
        }
    }

    //
    // Start the timer function to simulate background task work.
    //
    setTimeout(onTimer, 1000);
})();

Freigeben über