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:

    
    
    // 
    // ExampleBackgroundTask.cs
    // 
    
    using Windows.ApplicationModel.Background;
    
    namespace Tasks
    {
        public sealed class ServicingCompleteTask : IBackgroundTask
        {
            public void 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:

    
    // 
    // ExampleBackgroundTask.cs
    // 
    
    using Windows.ApplicationModel.Background;
    
    namespace Tasks
    {
        public sealed class ServicingCompleteTask : IBackgroundTask
        {
            public void Run(IBackgroundTaskInstance taskInstance)
            {
                // 
                // Unregister tasks that no longer exist.
                // 
    
                string unregisterTask = "BadTaskName";
    
                var task = FindTask(unregisterTask);
                if (task != null)
                {
                    task.Unregister(true);
                }
            }
    
    
            // 
            // Check for a registration of the named background task. If one
            // exists, return it.
            // 
            public static BackgroundTaskRegistration FindTask(string taskName)
            {
                foreach (var cur in BackgroundTaskRegistration.AllTasks)
                {
                    if (cur.Value.Name == taskName)
                    {
                        // 
                        // The task is registered.
                        // 
    
                        return (BackgroundTaskRegistration)(cur.Value);
                    }
                }
    
                return null;
            }
    
        }
    }
    
    
  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:

    
    // 
    // ExampleBackgroundTask.cs
    // 
    
    using Windows.ApplicationModel.Background;
    
    namespace Tasks
    {
        public sealed class ServicingCompleteTask : IBackgroundTask
        {
            public void Run(IBackgroundTaskInstance taskInstance)
            {
                // 
                // Unregister tasks that no longer exist.
                // 
    
                string unregisterTask = "BadTaskName";
    
                var task = FindTask(unregisterTask);
                if (task != null)
                {
                    task.Unregister(true);
                }
                 
                // 
                // Register new/replacement tasks.
                // 
                 
                string newTaskName = "NewTask";
                string newTaskEntryPoint = "Tasks.NewTask";
                
                SystemTrigger internetTrigger =
                      new SystemTrigger(SystemTriggerType.InternetAvailable, false);
                
                var newTask = RegisterBackgroundTask(newTaskEntryPoint,
                                                     newTaskName, 
                                                     internetTrigger, 
                                                     null);
            }
        
        
            // 
            // Check for a registration of the named background task. If one exists,
            // return it.
            // 
            public static BackgroundTaskRegistration FindTask(string taskName)
            {
                foreach (var cur in BackgroundTaskRegistration.AllTasks)
                {
                    if (cur.Value.Name == taskName)
                    {
                        // 
                        // The task is registered.
                        // 
                        
                        return (BackgroundTaskRegistration)cur.Value;
                    }
                }
            
                return null;
            }
        }
    }
    
    

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 =
                      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:

    
    string entryPoint = "Tasks.ServicingCompleteTask";
    string taskName = "ServicingComplete background task";
    
    BackgroundTaskRegistration task = RegisterBackgroundTask(entryPoint, 
                                                          taskName, 
                                                          servicingCompleteTrigger,
                                                          null);
    
    

    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:
© 2014 Microsoft