Windows Dev Center

Language: HTML | XAML

Schnellstart: Erstellen und Registrieren einer Hintergrundaufgabe (XAML)

Erstellen Sie eine Hintergrundaufgabenklasse, und registrieren Sie sie für die Ausführung, damit die Funktionen zur Verfügung stehen, wenn Ihre App nicht im Vordergrund ausgeführt wird.

Voraussetzungen

  • Ihre App muss im Hintergrund Aufgaben ausführen, und diese Aufgaben können nicht von anderen von der Plattform bereitgestellten Funktionen übernommen werden.

Erstellen der Hintergrundaufgabenklasse

Sie können Code im Hintergrund ausführen, indem Sie Klassen schreiben, die die IBackgroundTask-Schnittstelle implementieren. Dieser Code wird ausgeführt, wenn ein bestimmtes Ereignis z. B. durch SystemTrigger oder MaintenanceTrigger ausgelöst wird.

Die folgenden Schritte zeigen, wie Sie eine neue Klasse zum Implementieren der IBackgroundTask-Schnittstelle schreiben. Erstellen Sie zunächst ein neues Projekt in Ihrer Projektmappe für Hintergrundaufgaben. Fügen Sie zu Ihrer Hintergrundaufgabe eine neue leere Klasse hinzu, und importieren Sie den Namespace Windows.ApplicationModel.Background.

  1. Erstellen Sie ein neues Projekt für Hintergrundaufgaben, und fügen Sie es zu Ihrer Projektmappe hinzu. Klicken Sie hierzu mit der rechten Maustaste auf Ihre Projektmappe und wählen Sie „Hinzufügen->Neues Projekt“ aus. Wählen Sie dann den Projekttyp „Windows-Runtime-Komponente“ aus, geben Sie dem Projekt einen Namen, und klicken Sie auf „OK“.
  2. Verweisen Sie auf das Hintergrundaufgabenprojekt aus dem Projekt für Windows Store-Apps oder Windows Phone-Apps.

    Klicken Sie für eine C++-App mit der rechten Maustaste auf Ihr App-Projekt, und wählen Sie Eigenschaften aus. Gehen Sie dann zu Allgemeine Eigenschaften, und klicken Sie auf Neuen Verweis hinzufügen. Aktivieren Sie das Kontrollkästchen neben Ihrem Hintergrundaufgabenprojekt, und klicken Sie in beiden Dialogfeldern auf OK.

    Klicken Sie für eine C#-App in Ihrem App-Projekt mit der rechten Maustaste auf Verweise, und wählen Sie Neuen Verweis hinzufügen aus. Wählen Sie unter Projektmappe die Option Projekte. Wählen Sie dann den Namen Ihres Hintergrundaufgabenprojekts aus, und klicken Sie auf OK.

  3. Erstellen Sie eine neue Klasse zum Implementieren der IBackgroundTask-Schnittstelle. Die Run-Methode ist ein erforderlicher Einstiegspunkt und wird aufgerufen, wenn das angegebene Ereignis ausgelöst wird. Diese Methode ist in jeder Hintergrundaufgabe erforderlich.

    Hinweis  Die Hintergrundaufgabenklasse selbst sowie alle anderen Klassen im Hintergrundaufgabenprojekt müssen public-Klassen sein, die sealed sind.

    Der folgende Beispielcode zeigt einen sehr einfachen Startpunkt für eine Hintergrundaufgabenklasse:

    
    
    //
    // ExampleBackgroundTask.cpp
    //
    
    #include "ExampleBackgroundTask.h"
    
    using namespace Tasks;
    
    void ExampleBackgroundTask::Run(IBackgroundTaskInstance^ taskInstance)
    {
    
    }
    
    
    
    //
    // ExampleBackgroundTask.h
    //
    
    #pragma once
    
    using namespace Windows::ApplicationModel::Background;
    
    namespace Tasks
    {
        public ref class ExampleBackgroundTask sealed : public IBackgroundTask
        {
    
        public:
            ExampleBackgroundTask();
    
            virtual void Run(IBackgroundTaskInstance^ taskInstance);
            void OnCompleted(
                    BackgroundTaskRegistration^ task,
                    BackgroundTaskCompletedEventArgs^ args
                    );
        };
    }
    
    
  4. Wenn asynchroner Code in der Hintergrundaufgabe ausgeführt wird, muss in der Hintergrundaufgabe eine Verzögerung verwendet werden. Wenn Sie keine Verzögerung verwenden, kann die Ausführung der Hintergrundaufgabe unerwartet beendet werden, wenn die Run-Methode vor dem Aufruf der asynchronen Methode abgeschlossen wurde.

    Implementieren Sie die Verzögerung in der Run-Methode vor Aufruf der asynchronen Methode. Speichern Sie die Verzögerung in einer globalen Variable, sodass die asynchrone Methode darauf zugreifen kann. Deklarieren Sie das Objekt so, dass die Verzögerung nach Abschluss des asynchronen Codes abgeschlossen wird.

    Der folgende Beispielcode ruft die Verzögerung auf, speichert sie und gibt sie nach Abschluss des asynchronen Codes frei:

    
    void ExampleBackgroundTask::Run(IBackgroundTaskInstance^ taskInstance)
    {
        BackgroundTaskDeferral^ deferral = taskInstance->GetDeferral();
        
        //
        // TODO: Modify the following line of code to call a real async function.
        //       Note that the task<void> return type applies only to async
        //       actions. If you need to call an async operation instead, replace
        //       task<void> with the correct return type.
        //
        task<void> myTask(ExampleFunctionAsync());
        
        myTask.then([=] () {
            deferral->Complete();
        });
    }
    
    
    Hinweis  In C# werden asynchrone Methoden für Hintergrundaufgaben mithilfe der async/await-Schlüsselwörter aufgerufen. In C++ kann mit einer Aufgabenfolge ein ähnliches Ergebnis erzielt werden.

    Weitere Informationen zu asynchronen Mustern finden Sie unter Asynchrone Programmierung. Weitere Beispiele dazu, wie Sie Verzögerungen verwenden können, um das vorzeitige Beenden einer Hintergrundaufgabe zu verhindern, finden Sie im Beispiel zu Hintergrundaufgaben.

Die folgenden Schritte werden in einer Ihrer App-Klassen durchgeführt (beispielsweise in "MainPage.xaml.cs").

Hinweis  Sie können auch eine Funktion erstellen, die sich nur um das Registrieren von Hintergrundaufgaben kümmert. Siehe dazu Registrieren einer Hintergrundaufgabe. In einem solchen Fall können Sie die nächsten drei Schritte überspringen, einfach den Auslöser konstruieren und der Registrierungsfunktion zur Verfügung stellen, zusammen mit dem Aufgabennamen, dem entsprechenden Einstiegspunkt und, optional, einer Bedingung.

Registrieren der auszuführenden Hintergrundaufgabe

  1. Finden Sie heraus, ob die Hintergrundaufgabe bereits registriert ist, indem Sie die BackgroundTaskRegistration.AllTasks-Eigenschaft durchlaufen lassen. Dieser Schritt ist sehr wichtig. Sollte Ihre App nicht überprüfen, ob Hintergrundaufgaberegistrierungen vorhanden sind, könnte es passieren, dass sie die Aufgabe mehrere Male registriert, was zu Leistungseinbrüchen führt und die verfügbare CPU-Zeit der Aufgabe maximiert, bevor die Arbeit abgeschlossen werden kann.

    Das folgende Beispiel wiederholt die AllTasks-Eigenschaft und legt eine Kennzeichenvariable auf "true" fest, wenn die Aufgabe bereits registriert ist:

    
    boolean taskRegistered = false;
    Platform::String^ exampleTaskName = "ExampleBackgroundTask";
    
    auto iter = BackgroundTaskRegistration::AllTasks->First();
    auto hascur = iter->HasCurrent;
    
    while (hascur)
    {
        auto cur = iter->Current->Value;
    
        if(cur->Name == exampleTaskName)
        {
            taskRegistered = true;
            break;
        }
    
        hascur = iter->MoveNext();
    }
    
    
  2. Wenn die Hintergrundaufgabe noch nicht registriert ist, verwenden Sie BackgroundTaskBuilder, um eine Instanz Ihrer Hintergrundaufgabe zu generieren. Bei dem Einstiegspunkt der Aufgabe sollte es sich um den Namen der Hintergrundaufgabenklasse mit dem Namespace als Präfix handeln.

    Der Hintergrundaufgabenauslöser bestimmt, ob die Hintergrundaufgabe ausgeführt wird. Eine Liste mit möglichen Auslösern erhalten Sie in SystemTrigger.

    Dieser Code beispielsweise generiert eine neue Hintergrundaufgabe und stellt sie so ein, dass sie beim aktivieren des TimeZoneChanged-Auslösers ausgelöst wird:

    
    auto builder = ref new BackgroundTaskBuilder();
    
    builder->Name = exampleTaskName;
    builder->TaskEntryPoint = "Tasks.ExampleBackgroundTask";
    builder->SetTrigger(ref new SystemTrigger(SystemTriggerType::TimeZoneChange, false));
    
    
  3. Sie können eine Bedingung hinzufügen, die bestimmt, wann Ihre Aufgabe ausgeführt wird, nachdem das Auslöseereignis auftritt (optional). Wenn Sie zum Beispiel möchten, dass die Aufgabe erst ausgeführt wird, wenn der Benutzer anwesend ist, verwenden Sie die Bedingung UserPresent. Eine Liste mit möglichen Bedingungen finden Sie in SystemConditionType.

    Der folgende Beispielcode weist eine Bedingung zu, die die Anwesenheit des Benutzers voraussetzt:

    
    builder->AddCondition(ref new SystemCondition(SystemConditionType::UserPresent));
    
    
  4. Registrieren Sie die Hintergrundaufgabe, indem Sie die Register-Methode für das BackgroundTaskBuilder-Objekt aufrufen. Speichern Sie das BackgroundTaskRegistration-Ergebnis, sodass es im nächsten Schritt verwendet werden kann.

    Der folgende Code registriert die Hintergrundaufgaben und speichert das Ergebnis:

    
    BackgroundTaskRegistration^ task = builder->Register();
    
    

    Hinweis  

    Für Windows Phone Store-Apps müssen Sie RequestAccessAsync aufrufen, bevor Sie versuchen, Hintergrundaufgaben zu registrieren. Unter Windows ist dieser Aufruf nur für die Hintergrundaufgaben erforderlich, die nur ausgeführt werden können, wenn sich Ihre App auf dem Sperrbildschirm befindet. Auf dem Smartphone müssen Sie diese Methode vor dem Registrieren einer Hintergrundaufgabe einmal aufrufen.

    Um sicherzustellen, dass Ihre Windows Phone Store-App nach dem Freigeben eines Updates weiterhin ordnungsgemäß ausgeführt wird, rufen Sie RemoveAccess und RequestAccessAsync auf, wenn Ihre App nach dem Update startet. Weitere Infos finden Sie unter Richtlinien für Hintergrundaufgaben (Windows-Runtime-Apps).

    Hinweis  

    Ab Windows 8.1 werden Parameter für die Registrierung von Hintergrundaufgaben zum Zeitpunkt der Registrierung überprüft. Bei ungültigen Registrierungsparametern wird ein Fehler zurückgegeben. Ihre App muss Szenarios, in denen die Registrierung von Hintergrundaufgaben fehlschlägt, problemlos verarbeiten können. Verwenden Sie beispielsweise eine Bedingungsanweisung, um die App auf Registrierungsfehler zu prüfen, und führen Sie die fehlgeschlagene Registrierung mit anderen Parameterwerten erneut durch.

Behandeln des Abschlusses der Hintergrundaufgabe mithilfe von Ereignishandlern

Sie sollten eine Methode mit dem BackgroundTaskCompletedEventHandler registrieren, damit Ihre App Ergebnisse von der Hintergrundaufgabe erhält. Beim Starten oder Fortsetzen der App wird die OnCompleted-Methode aufgerufen, wenn die Hintergrundaufgabe abgeschlossen wurde, seit sich die App zum letzten Mal im Vordergrund befand. (Die OnCompleted-Methode wird sofort aufgerufen, wenn die Hintergrundaufgabe abgeschlossen wird, während sich Ihre App im Vordergrund befindet.)

  1. Schreiben Sie eine OnCompleted-Methode, um den Abschluss von Hintergrundaufgaben zu behandeln. Das Ergebnis der Hintergrundaufgabe kann z. B. eine Aktualisierung der Benutzeroberfläche auslösen. Das hier gezeigte Methodenprofil ist für die OnCompleted-Ereignishandlermethode erforderlich, obwohl dieses Beispiel nicht den args-Parameter verwendet.

    Der folgende Beispielcode erkennt den Abschluss der Hintergrundaufgabe und ruft eine Beispielmethode zur Aktualisierung der Benutzeroberfläche auf, die eine Meldungszeichenfolge erfordert.

    
    
    void ExampleBackgroundTask::OnCompleted(BackgroundTaskRegistration^ task, BackgroundTaskCompletedEventArgs^ args)
    {
        auto settings = ApplicationData::Current->LocalSettings->Values;
        auto key = task->TaskId.ToString();
        auto message = dynamic_cast<String^>(settings->Lookup(key));
        UpdateUIExampleMethod(message);
    }
    
    
    Hinweis  Aktualisierungen der Benutzeroberfläche sollten asynchron durchgeführt werden, um den Benutzeroberflächenthread nicht zu blockieren. Ein Beispiel dazu finden Sie in der UpdateUI-Methode im Beispiel für eine Hintergrundaufgabe.
  2. Gehen Sie dorthin zurück, wo Sie die Hintergrundaufgabe registriert haben. Fügen Sie nach dieser Codezeile ein neues BackgroundTaskCompletedEventHandler-Objekt hinzu. Stellen Sie Ihre OnCompleted-Methode als Parameter für den BackgroundTaskCompletedEventHandler-Konstruktor zur Verfügung.

    Der folgende Beispielcode fügt der BackgroundTaskRegistration einen BackgroundTaskCompletedEventHandler hinzu:

    
    task->Completed += ref new BackgroundTaskCompletedEventHandler(this, &ExampleBackgroundTask::OnCompleted);
    
    

Deklarieren im App-Manifest, dass die App Hintergrundaufgaben verwendet

Bevor Ihre App Hintergrundaufgaben ausführen kann, müssen Sie alle Hintergrundaufgaben im App-Manifest deklarieren.

  • Öffnen Sie das App-Manifest (die Datei mit dem Namen "package.appmanifest"), und rufen Sie das Erweiterungselement auf. Fügen Sie ein Erweiterungselement hinzu, wobei die Kategorie für jede in der App verwendete Hintergrundaufgabenklasse auf "windows.backgroundTasks" festgelegt ist.

    Sie müssen alle in Ihrer Hintergrundaufgabe verwendeten Triggertypen aufführen. Wenn Ihre App versucht, eine Hintergrundaufgabe mit einem Trigger zu registrieren, der nicht im Manifest aufgeführt ist, schlägt die Registrierung fehl.

    Das folgende Beispiel für ein Erweiterungselement registriert die in diesem Thema erstellte Hintergrundaufgabe:

    
    
    <Extensions>
      <Extension Category="windows.backgroundTasks" EntryPoint="Tasks.ExampleBackgroundTask">
        <BackgroundTasks>
          <Task Type="systemEvent" />
        </BackgroundTasks>
      </Extension>
    </Extensions>
    
    

Zusammenfassung

Sie sollten jetzt über die Grundlagen verfügen, um eine Hintergrundaufgabenklasse zu schreiben, die Hintergrundaufgabe in Ihrer App zu registrieren und Ihre App so zu konfigurieren, dass Sie den Abschluss der Hintergrundaufgabe erkennt. Sie sollten auch mit der Aktualisierung des Anwendungsmanifests vertraut sein, damit Ihre App unter Windows 8 die Hintergrundaufgabe registrieren kann.

Hinweis  Laden Sie das Beispiel für eine Hintergrundaufgabe herunter, um ähnliche Codebeispiele im Kontext einer vollständigen und stabilen Windows Store-App mit Hintergrundaufgaben zu erhalten.

Eine API-Referenz, konzeptionelle Richtlinien zu Hintergrundaufgaben und ausführlichere Anweisungen zum Schreiben von Apps, die Hintergrundaufgaben verwenden, finden Sie unter den folgenden verwandten Themen:

Verwandte Themen

Ausführliche Themen mit Anweisungen zu Hintergrundaufgaben
So wird's gemacht: Reagieren auf Systemereignisse mit Hintergrundaufgaben
So wird's gemacht: Registrieren einer Hintergrundaufgabe
So wird's gemacht: Festlegen von Bedingungen für die Ausführung einer Hintergrundaufgabe
So wird's gemacht: Verwenden von Wartungstriggern
So wird's gemacht: Behandeln einer abgebrochenen Hintergrundaufgabe
So wird's gemacht: Überwachen des Status und Abschlusses von Hintergrundaufgaben
Ausführen einer Hintergrundaufgabe für einen Zeitgeber
Leitfaden für Hintergrundaufgaben
Richtlinien und Prüflisten für Hintergrundaufgaben
How to debug a background task
So wird's gemacht: Auslösen von Anhalte-, Fortsetzungs- und Hintergrundereignissen in Windows Store-Apps (beim Debuggen)
Hintergrundaufgabe – API-Referenz
Windows.ApplicationModel.Background

 

 

Anzeigen:
© 2015 Microsoft