So wird’s gemacht: Überwachen des Status und Abschlusses von Hintergrundaufgaben (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 Ihre App den von einer Hintergrundaufgabe gemeldeten Status und Abschluss erkennt. Hintergrundaufgaben sind zwar von der App entkoppelt und werden getrennt ausgeführt, Status und Abschluss können jedoch vom App-Code überwacht werden. Hierzu abonniert die App Ereignisse der Hintergrundaufgaben, die sie im System registriert hat.

Wissenswertes

Technologien

Windows.ApplicationModel.Background

Voraussetzungen

In diesem Thema wird vorausgesetzt, dass Sie über eine App verfügen, die Hintergrundaufgaben registriert. 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:

Erstellen Sie eine Funktion, die an den Ereignishandler zum Abschluss der Hintergrundaufgabe angefügt wird. Die Funktion muss ein BackgroundTaskCompletedEventArgs-Objekt und keinen weiteren Parameter übernehmen.

Wenn Sie eine Funktion lokal registrieren, können Sie das folgende Muster verwenden:
```
function OnCompleted(args)
{
    // TODO: Add code that deals with background task completion.
}
```
Dann können Sie sie einfach für das "BackgroundTaskRegistration"-Objekt verwenden, das Sie durch einen erfolgreichen Aufruf der Funktion "Register" erhalten:
```
backgroundTaskRegistration.addEventListener("completed", onCompleted);
```
Sie müssen Code hinzufügen, der den Abschluss der Hintergrundaufgabe behandelt.

So aktualisiert beispielsweise das Beispiel für eine Hintergrundaufgabe die Benutzeroberfläche mit dem in "LocalSettings" gespeicherten Status:
```
function OnCompleted(args)
{
    // 
    // 
    // 
    backgroundTaskName = this.name;

    // 
    // Call a method to update the UI (beyond the scope of this example).
    // 
    UpdateUI();
}
```

Eine robuste App kann durch Aufrufen von CheckResult nach Ausnahmen suchen, die von der Hintergrundaufgabe ausgelöst werden.

Die Methode des Beispiels für eine Hintergrundaufgabe kann wie folgt geändert werden, um von der Hintergrundaufgabe ausgelöste Ausnahmen zu behandeln:

function OnCompleted(task, args)
{
    var settings = ApplicationData.Current.LocalSettings;
    var key = task.TaskId.ToString();

    try
    {
        args.CheckResult();
        BackgroundTaskSample.SampleBackgroundTaskStatus = settings.Values[key].ToString();
    }
    catch (Exception ex)
    {
        BackgroundTaskSample.SampleBackgroundTaskStatus = "Error: " + ex.Message;
    }

    UpdateUI();
}

Schritt 2:

Erstellen Sie eine Ereignishandlerfunktion zum Behandeln abgeschlossener Hintergrundaufgaben. Dieser Code muss einem bestimmten Profil entsprechen und ein IBackgroundTaskRegistration-Objekt sowie ein BackgroundTaskProgressEventArgs-Objekt enthalten:

Verwenden Sie das folgende Profil für die Ereignishandlermethode für die OnProgress-Hintergrundaufgabe:
```
function OnProgress(task, args)
{
    // TODO: Add code that deals with background task progress.
}
```
Fügen Sie dem Ereignishandler Code zum Behandeln des Abschlusses der Hintergrundaufgabe hinzu.

So aktualisiert beispielsweise das Beispiel für eine Hintergrundaufgabe die Benutzeroberfläche mit dem Fortschrittsstatus, der mithilfe des args-Parameters übergeben wird:
```
function OnProgress(task, args)
{
    var progress = "Progress: " + args.Progress + "%";
    BackgroundTaskSample.SampleBackgroundTaskProgress = progress;
    UpdateUI();
}
```

Schritt 3:

Registrieren Sie die Ereignishandlerfunktionen mit neuen und vorhandenen Hintergrundaufgaben.

Wenn die App erstmals eine Hintergrundaufgabe registriert, muss sie sich für den Empfang von Status- und Abschlussupdates registrieren, falls die Aufgabe ausgeführt wird, während die App im Vordergrund noch aktiv ist.

So ruft beispielsweise das Beispiel für eine Hintergrundaufgabe für jede Hintergrundaufgabe, die es registriert, die folgende Funktion auf:
```
function AttachProgressAndCompletedHandlers(IBackgroundTaskRegistration task)
{
    task.Progress += new BackgroundTaskProgressEventHandler(OnProgress);
    task.Completed += new BackgroundTaskCompletedEventHandler(OnCompleted);
}
```
Wenn die App startet oder zu einer neuen Seite navigiert, für die der Hintergrundaufgabenstatus relevant ist, muss sie eine Liste mit den derzeit registrierten Hintergrundaufgaben abrufen und diese den Status- und Abschlussereignishandlerfunktionen zuordnen. Die Liste mit den derzeit von der Anwendung registrierten Hintergrundaufgaben ist in der Eigenschaft "BackgroundTaskRegistration.AllTasks" gespeichert.

So verwendet beispielsweise das Beispiel für eine Hintergrundaufgabe den folgenden Code, um Ereignishandler anzufügen, wenn zur Seite "SampleBackgroundTask" navigiert wird:
```
function OnNavigatedTo(NavigationEventArgs e)
{
    foreach (var task in BackgroundTaskRegistration.AllTasks)
    {
        if (task.Value.Name == BackgroundTaskSample.SampleBackgroundTaskName)
        {
            AttachProgressAndCompletedHandlers(task.Value);
            BackgroundTaskSample.UpdateBackgroundTaskStatus(BackgroundTaskSample.SampleBackgroundTaskName, true);
        }
    }

    UpdateUI();
}
```

Freigeben über