Udostępnij przez

Zarejestruj zadanie w tle

ważne interfejsy API

Dowiedz się, jak utworzyć funkcję, która może być ponownie używana do bezpiecznego rejestrowania większości zadań w tle.

Ten temat ma zastosowanie zarówno do zadań w tle procesu, jak i zadań w tle poza procesem. W tym temacie założono, że masz już zadanie w tle, które należy zarejestrować. (Zobacz Tworzenie i rejestrowanie zadania w tle, które działa poza procesem lub Tworzenie i rejestrowanie zadania w tle w procesie, aby uzyskać informacje o sposobie pisania zadania w tle).

W tym temacie przedstawiono funkcję narzędzia, która rejestruje zadania w tle. Ta funkcja narzędziowa najpierw sprawdza istniejące rejestracje przed ponownym zarejestrowaniem zadania, aby uniknąć problemów związanych z wieloma rejestracjami, oraz może nałożyć warunek systemowy na zadanie w tle. Przewodnik zawiera kompletny, działający przykład tej funkcji narzędziowej.

Uwaga  

Aplikacje uniwersalne systemu Windows muszą wywoływać RequestAccessAsync przed zarejestrowaniem dowolnego typu wyzwalacza w tle.

Aby upewnić się, że aplikacja uniwersalna systemu Windows będzie nadal działać prawidłowo po wydaniu aktualizacji, należy wywołać RemoveAccess, a następnie wywołać RequestAccessAsync po uruchomieniu aplikacji po aktualizacji. Aby uzyskać więcej informacji, zobacz Wytyczne dotyczące zadań w tle.

Definiowanie podpisu metody i zwracanego typu

Ta metoda przyjmuje punkt wejścia zadania, nazwę zadania, wstępnie skonstruowany wyzwalacz zadania w tle i (opcjonalnie) SystemCondition dla zadania w tle. Ta metoda zwraca obiekt BackgroundTaskRegistration .

Ważne

taskEntryPoint — w przypadku zadań w tle, które działają poza procesem, należy to skonstruować jako nazwę przestrzeni nazw, '.', oraz nazwę klasy zawierającej klasę w tle. W ciągu jest uwzględniana wielkość liter. Jeśli na przykład masz przestrzeń nazw "MyBackgroundTasks" i klasę "BackgroundTask1", która zawiera kod klasy tła, to ciąg znaków reprezentujący taskEntryPoint miałby postać "MyBackgroundTasks.BackgroundTask1". Jeśli zadanie w tle jest uruchamiane w tym samym procesie co aplikacja (tj. zadanie w tle w procesie) taskEntryPoint nie powinno być ustawione.

public static BackgroundTaskRegistration RegisterBackgroundTask(
                                                string taskEntryPoint,
                                                string name,
                                                IBackgroundTrigger trigger,
                                                IBackgroundCondition condition)
{
    
    // We'll add code to this function in subsequent steps.

}

BackgroundTaskRegistration^ MainPage::RegisterBackgroundTask(
                                             Platform::String ^ taskEntryPoint,
                                             Platform::String ^ taskName,
                                             IBackgroundTrigger ^ trigger,
                                             IBackgroundCondition ^ condition)
{
    
    // We'll add code to this function in subsequent steps.

}

Sprawdzanie istniejących rejestracji

Sprawdź, czy zadanie jest już zarejestrowane. Należy to sprawdzić, ponieważ jeśli zadanie jest zarejestrowane wiele razy, będzie uruchamiane więcej niż raz za każdym razem, gdy zostanie wyzwolone; może to zużywać nadmiar mocy procesora i powodować nieoczekiwane zachowanie.

Możesz sprawdzić istniejące rejestracje, zapytując o właściwość BackgroundTaskRegistration.AllTasks i iterując wynik. Sprawdź nazwę każdego wystąpienia — jeśli pasuje do nazwy rejestrowanego zadania, wyłamaj się z pętli i ustaw zmienną flagową, aby kod mógł wybrać inną ścieżkę w następnym kroku.

Uwaga Użyj nazw zadań w tle, które są unikalne dla aplikacji. Upewnij się, że każde zadanie w tle ma unikatową nazwę.

Poniższy kod rejestruje zadanie w tle przy użyciu SystemTrigger utworzone w ostatnim kroku:

public static BackgroundTaskRegistration RegisterBackgroundTask(
                                                string taskEntryPoint,
                                                string name,
                                                IBackgroundTrigger trigger,
                                                IBackgroundCondition condition)
{
    //
    // Check for existing registrations of this background task.
    //

    foreach (var cur in BackgroundTaskRegistration.AllTasks)
    {

        if (cur.Value.Name == name)
        {
            //
            // The task is already registered.
            //

            return (BackgroundTaskRegistration)(cur.Value);
        }
    }
    
    // We'll register the task in the next step.
}

BackgroundTaskRegistration^ MainPage::RegisterBackgroundTask(
                                             Platform::String ^ taskEntryPoint,
                                             Platform::String ^ taskName,
                                             IBackgroundTrigger ^ trigger,
                                             IBackgroundCondition ^ condition)
{
    //
    // Check for existing registrations of this background task.
    //
    
    auto iter   = BackgroundTaskRegistration::AllTasks->First();
    auto hascur = iter->HasCurrent;
    
    while (hascur)
    {
        auto cur = iter->Current->Value;
        
        if(cur->Name == name)
        {
            //
            // The task is registered.
            //
            
            return (BackgroundTaskRegistration ^)(cur);
        }
        
        hascur = iter->MoveNext();
    }
    
    // We'll register the task in the next step.
}

Zarejestruj zadanie w tle (lub zwróć istniejącą rejestrację)

Sprawdź, czy zadanie zostało znalezione na liście istniejących rejestracji zadań w tle. Jeśli tak, zwróć to wystąpienie zadania.

Następnie zarejestruj zadanie przy użyciu nowego obiektu BackgroundTaskBuilder . Ten kod powinien sprawdzić, czy parametr warunku ma wartość null, a jeśli nie, dodaj warunek do obiektu rejestracji. Zwróć BackgroundTaskRegistration zwróconą przez metodę BackgroundTaskBuilder.Register.

Nuta Parametry rejestracji zadań w tle są weryfikowane w momencie rejestracji. Zwracany jest błąd, jeśli którykolwiek z parametrów rejestracji jest nieprawidłowy. Upewnij się, że aplikacja bezpiecznie obsługuje scenariusze, w których rejestracja zadań w tle kończy się niepowodzeniem — jeśli zamiast tego aplikacja zależy od prawidłowego obiektu rejestracji po próbie zarejestrowania zadania, może to spowodować awarię. Uwaga Jeśli rejestrujesz zadanie w tle uruchamiane w tym samym procesie co aplikacja, wyślij String.Empty lub null jako parametr taskEntryPoint.

Poniższy przykład zwraca istniejące zadanie lub dodaje kod rejestrujący zadanie w tle (w tym opcjonalny warunek systemowy, jeśli istnieje):

public static BackgroundTaskRegistration RegisterBackgroundTask(
                                                string taskEntryPoint,
                                                string name,
                                                IBackgroundTrigger trigger,
                                                IBackgroundCondition condition)
{
    //
    // Check for existing registrations of this background task.
    //

    foreach (var cur in BackgroundTaskRegistration.AllTasks)
    {

        if (cur.Value.Name == taskName)
        {
            //
            // The task is already registered.
            //

            return (BackgroundTaskRegistration)(cur.Value);
        }
    }

    //
    // Register the background task.
    //

    var builder = new BackgroundTaskBuilder();

    builder.Name = name;

    // in-process background tasks don't set TaskEntryPoint
    if ( taskEntryPoint != null && taskEntryPoint != String.Empty)
    {
        builder.TaskEntryPoint = taskEntryPoint;
    }
    builder.SetTrigger(trigger);

    if (condition != null)
    {
        builder.AddCondition(condition);
    }

    BackgroundTaskRegistration task = builder.Register();

    return task;
}

BackgroundTaskRegistration^ MainPage::RegisterBackgroundTask(
                                             Platform::String ^ taskEntryPoint,
                                             Platform::String ^ taskName,
                                             IBackgroundTrigger ^ trigger,
                                             IBackgroundCondition ^ condition)
{

    //
    // Check for existing registrations of this background task.
    //

    auto iter   = BackgroundTaskRegistration::AllTasks->First();
    auto hascur = iter->HasCurrent;

    while (hascur)
    {
        auto cur = iter->Current->Value;

        if(cur->Name == name)
        {
            //
            // The task is registered.
            //

            return (BackgroundTaskRegistration ^)(cur);
        }

        hascur = iter->MoveNext();
    }

    //
    // Register the background task.
    //

    auto builder = ref new BackgroundTaskBuilder();

    builder->Name = name;
    builder->TaskEntryPoint = taskEntryPoint;
    builder->SetTrigger(trigger);

    if (condition != nullptr) {
        
        builder->AddCondition(condition);
    }

    BackgroundTaskRegistration ^ task = builder->Register();

    return task;
}

Kompletna funkcja pomocnicza do rejestracji zadań w tle

W tym przykładzie przedstawiono ukończoną funkcję rejestracji zadań w tle. Ta funkcja może służyć do rejestrowania większości zadań w tle, z wyjątkiem zadań w tle sieci.

//
// Register a background task with the specified taskEntryPoint, name, trigger,
// and condition (optional).
//
// taskEntryPoint: Task entry point for the background task.
// taskName: A name for the background task.
// trigger: The trigger for the background task.
// condition: Optional parameter. A conditional event that must be true for the task to fire.
//
public static BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint,
                                                                string taskName,
                                                                IBackgroundTrigger trigger,
                                                                IBackgroundCondition condition)
{
    //
    // Check for existing registrations of this background task.
    //

    foreach (var cur in BackgroundTaskRegistration.AllTasks)
    {

        if (cur.Value.Name == taskName)
        {
            //
            // The task is already registered.
            //

            return (BackgroundTaskRegistration)(cur.Value);
        }
    }

    //
    // Register the background task.
    //

    var builder = new BackgroundTaskBuilder();

    builder.Name = taskName;
    builder.TaskEntryPoint = taskEntryPoint;
    builder.SetTrigger(trigger);

    if (condition != null)
    {

        builder.AddCondition(condition);
    }

    BackgroundTaskRegistration task = builder.Register();

    return task;
}

//
// Register a background task with the specified taskEntryPoint, name, trigger,
// and condition (optional).
//
// taskEntryPoint: Task entry point for the background task.
// taskName: A name for the background task.
// trigger: The trigger for the background task.
// condition: Optional parameter. A conditional event that must be true for the task to fire.
//
BackgroundTaskRegistration^ MainPage::RegisterBackgroundTask(Platform::String ^ taskEntryPoint,
                                                             Platform::String ^ taskName,
                                                             IBackgroundTrigger ^ trigger,
                                                             IBackgroundCondition ^ condition)
{

    //
    // Check for existing registrations of this background task.
    //

    auto iter   = BackgroundTaskRegistration::AllTasks->First();
    auto hascur = iter->HasCurrent;

    while (hascur)
    {
        auto cur = iter->Current->Value;

        if(cur->Name == name)
        {
            //
            // The task is registered.
            //

            return (BackgroundTaskRegistration ^)(cur);
        }

        hascur = iter->MoveNext();
    }


    //
    // Register the background task.
    //

    auto builder = ref new BackgroundTaskBuilder();

    builder->Name = name;
    builder->TaskEntryPoint = taskEntryPoint;
    builder->SetTrigger(trigger);

    if (condition != nullptr) {

        builder->AddCondition(condition);
    }

    BackgroundTaskRegistration ^ task = builder->Register();

    return task;
}
  • Last updated on