Language: HTML | XAML

So wird’s gemacht: Verwenden des ServicingComplete-Triggers (XAML)

Applies to Windows and Windows Phone

Hier erfahren Sie, wie Sie ServicingComplete-SystemTrigger verwenden, um die Registrierung von Hintergrundaufgaben nach App-Updates zu steuern.

Wissenswertes

Technologien

Voraussetzungen

Anweisungen

Schritt 1: Erstellen einer ServicingComplete-Hintergrundaufgabe

Die Registrierung von Hintergrundaufgaben überdauert App-Updates. Wenn eine App aktualisiert wird, sind die zugehörigen Registrierungen weiterhin gültig und werden ausgelöst. Eine App kann eine Hintergrundaufgabe mit dem ServicingComplete-Trigger registrieren, damit eine Benachrichtigung erfolgt, wenn die App-aktualisiert wird, um daraufhin die Registrierung von Hintergrundaufgaben aufzuheben, die nicht mehr gültig sind.

  1. Erstellen Sie eine neue Klasse, die – wie bei jeder anderen Hintergrundaufgabe – die IBackgroundTask-Schnittstelle implementiert.

    Hinweis  In C# müssen die Hintergrundaufgabe selbst sowie alle anderen Klassen im Hintergrundaufgabenprojekt public sealed-Klassen sein.

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

    
    
    // 
    // ServicingCompleteTask.cpp
    // 
    
    #include "pch.h"
    #include "ServicingCompleteTask.h"
    
    using namespace Tasks;
    using namespace Windows::ApplicationModel::Background;
    
    void ServicingCompleteTask::Run(IBackgroundTaskInstance^ taskInstance)
    {
        
    }
    
    
  2. Suchen Sie nach dem Registrierungsobjekt für die Hintergrundaufgabe, deren Registrierung aufgehoben werden muss. Rufen Sie die Unregister-Methode auf, um die Registrierung der Aufgabe aufzuheben. Beachten Sie, dass Sie die Beendigung der Ausführung der Hintergrundaufgabe erzwingen können (falls eine Instanz aktiv ist), indem Sie den cancelTask-Parameter auf true festlegen.

    Im folgenden Beispiel wird gezeigt, wie Sie die Registrierung von Aufgaben in der ServicingComplete-Aufgabe aufheben:

    
    // 
    // ServicingCompleteTask.cpp
    // 
    
    #include "pch.h"
    #include "ServicingCompleteTask.h"
    
    using namespace Tasks;
    using namespace Windows::ApplicationModel::Background;
    
    
    void ServicingCompleteTask::Run(IBackgroundTaskInstance^ taskInstance)
    {
        // 
        // Unregister tasks that no longer exist.
        // 
        
        Platform::String ^ unregisterTask = "BadTaskName";
        
        BackgroundTaskRegistration ^ unregTask = FindTask(unregisterTask);
        
        if (unregTask != nullptr)
        {
            unregTask->Unregister(true);
        }
    }
    
    
    // 
    // Check for a registration of the named background task. If one exists,
    // return it.
    // 
    BackgroundTaskRegistration ^ 
                        ServicingCompleteTask::FindTask(Platform::String ^ taskName)
    {
        auto iter   = BackgroundTaskRegistration::AllTasks->First();
        auto hascur = iter->HasCurrent;
        
        while (hascur)
        {
            auto cur = iter->Current->Value;
            
            if(cur->Name == taskName)
            {
                // 
                // The task is registered.
                // 
                
                return (BackgroundTaskRegistration ^)(cur);
            }
            
            hascur = iter->MoveNext();
        }
            
        return nullptr;
    }
    
    
  3. Registrieren Sie nach Bedarf Ersatzaufgaben. Verwenden Sie eine Funktion zum Registrieren von Hintergrundaufgaben, wie die unter So wird's gemacht: Registrieren einer Hintergrundaufgabe beschriebene Funktion, um die Arbeit zu vereinfachen.

    Der folgende Code schließt das Beispiel ab, indem Funktionalität zum Registrieren einer neuen Hintergrundaufgabe hinzugefügt wird:

    
    // 
    // ServicingCompleteTask.cpp
    // 
    
    #include "pch.h"
    #include "ServicingCompleteTask.h"
    
    using namespace Tasks;
    using namespace Windows::ApplicationModel::Background;
    
    
    void ServicingCompleteTask::Run(IBackgroundTaskInstance^ taskInstance)
    {
        // 
        // Unregister tasks that no longer exist.
        // 
        
        Platform::String ^ unregisterTask = "BadTaskName";
        
        BackgroundTaskRegistration ^ unregTask = FindTask(unregisterTask);
        
        if (unregTask != nullptr)
        {
            unregTask->Unregister(true);
        }
        
        
        // 
        // Register new/replacement tasks.
        // 
        
        Platform::String ^ newTaskName = "NewTask";
        Platform::String ^ newTaskEntryPoint = "Tasks.NewTask";
        
        SystemTrigger ^ internetTrigger = 
                 ref new SystemTrigger(SystemTriggerType::InternetAvailable, false);
        
        BackgroundTaskRegistration ^ newTask =
                                          RegisterBackgroundTask(newTaskEntryPoint, 
                                                                 newTaskName,
                                                                 internetTrigger, 
                                                                 nullptr);
    }
    
    
    // 
    // Check for a registration of the named background task. If one exists,
    // return it.
    // 
    BackgroundTaskRegistration ^
                        ServicingCompleteTask::FindTask(Platform::String ^ taskName)
    {
        auto iter   = BackgroundTaskRegistration::AllTasks->First();
        auto hascur = iter->HasCurrent;
        
        while (hascur)
        {
            auto cur = iter->Current->Value;
            
            if(cur->Name == taskName)
            {
                // 
                // The task is registered.
                // 
                
                return (BackgroundTaskRegistration ^)(cur);
            }
            
            hascur = iter->MoveNext();
        }
            
        return nullptr;
    }
    
    

Schritt 2: Registrieren der ServicingComplete-Hintergrundaufgabe

Die ServicingComplete-Hintergrundaufgabe sollte zusammen mit anderen Hintergrundaufgaben registriert werden, damit sie bei einem App-Update ausgelöst werden kann. Der Einstiegspunkt für die ServicingComplete-Hintergrundaufgabe muss im App-Update der gleiche bleiben

  1. Erstellen Sie ein neues SystemTrigger-Objekt.

    • Der erste Parameter, triggerType, sollte auf servicingComplete festgelegt werden.

    • Der zweite Parameter, OneShot, sollte auf false festgelegt werden.

    Durch diesen Beispielcode wird ein ServicingComplete-Trigger erstellt:

    
    SystemTrigger ^ servicingCompleteTrigger =
                 ref new SystemTrigger(SystemTriggerType::ServicingComplete, false);
    
    
    Hinweis  Es wird davon abgeraten, eine Bedingung zu einem ServicingComplete-Hintergrundaufgabentrigger hinzuzufügen.
  2. Rufen Sie die Registrierungsfunktion für die Hintergrundaufgabe auf, um die Aufgabe zu registrieren. Weitere Informationen zum Registrieren von Hintergrundaufgaben finden Sie unter So wird's gemacht: Registrieren einer Hintergrundaufgabe.

    Durch den folgenden Code wird die ServicingComplete-Aufgabe registriert:

    
    Platform::String ^ entryPoint = "Tasks.ServicingCompleteTask";
    Platform::String ^ taskName   = "ServicingComplete background task";
    
    BackgroundTaskRegistration ^ task = RegisterBackgroundTask(entryPoint,
                                                          taskName,
                                                          servicingCompleteTrigger,
                                                          nullptr);
    
    

    Hinweis  Unter Windows Phone müssen Sie vor dem Registrieren von Hintergrundaufgaben einmal RequestAccessAsync aufrufen.

Schritt 3: Deklarieren der Hintergrundaufgabe im Paketmanifest

Die ServicingComplete-Hintergrundaufgabe muss, wie jede andere Hintergrundaufgabe, im Paketmanifest aufgeführt werden. Weitere Informationen finden Sie unter So wird's gemacht: Deklarieren von Hintergrundaufgaben im Anwendungsmanifest. Beispiel:

ServicingComplete-Aufgabe, die im App-Manifest deklariert ist

Anmerkungen

Wichtige Informationen zum Debuggen von App-Updates mit Hintergrundaufgaben finden Sie unter How to debug a background task (Windows Store apps).

Verwandte Themen

Schnellstart: Erstellen und Registrieren einer Hintergrundaufgabe
So wird's gemacht: Registrieren einer Hintergrundaufgabe
So wird's gemacht: Reagieren auf Systemereignisse mit Hintergrundaufgaben
So wird's gemacht: Festlegen von Bedingungen für die Ausführung einer Hintergrundaufgabe
So wird's gemacht: Deklarieren von Hintergrundaufgaben im App-Manifest
How to debug a background task
Richtlinien und Prüflisten für Hintergrundaufgaben

 

 

Anzeigen:
© 2015 Microsoft