Freigeben über

Überwachen des Status und Abschlusses von Hintergrundaufgaben

  • Artikel

Wichtige APIs

Erfahren Sie, wie Ihre App Den Fortschritt und abschluss erkennen kann, der von einer Hintergrundaufgabe gemeldet wird, die außerhalb des Prozesses ausgeführt wird. (Bei In-Process-Hintergrundaufgaben können Sie freigegebene Variablen festlegen, um den Fortschritt und den Abschluss zu kennzeichnen.)

Der Status und abschluss der Hintergrundaufgabe kann durch App-Code überwacht werden. Dazu abonniert die App Ereignisse aus den Hintergrundaufgaben, die sie beim System registriert hat.

Erstellen eines Ereignishandlers zum Behandeln abgeschlossener Hintergrundaufgaben

Schritt 1

Erstellen Sie eine Ereignishandlerfunktion zum Behandeln abgeschlossener Hintergrundaufgaben. Dieser Code muss einem bestimmten Fußabdruck folgen, der ein IBackgroundTaskRegistration-Objekt und ein BackgroundTaskCompletedEventArgs-Objekt verwendet.

Verwenden Sie den folgenden Fußabdruck für die Ereignishandlermethode für Die OnCompleted-Hintergrundaufgabe .

private void OnCompleted(IBackgroundTaskRegistration task, BackgroundTaskCompletedEventArgs args)
{
    // TODO: Add code that deals with background task completion.
}

auto completed{ [this](
        Windows::ApplicationModel::Background::BackgroundTaskRegistration const& /* sender */,
        Windows::ApplicationModel::Background::BackgroundTaskCompletedEventArgs const& /* args */)
{
    // TODO: Add code that deals with background task completion.
} };

auto completed = [this](BackgroundTaskRegistration^ task, BackgroundTaskCompletedEventArgs^ args)
{
    // TODO: Add code that deals with background task completion.
};

Schritt 2

Fügen Sie dem Ereignishandler Code hinzu, der den Abschluss der Hintergrundaufgabe behandelt.

Im Beispiel für die Hintergrundaufgabe wird beispielsweise die Benutzeroberfläche aktualisiert.

private void OnCompleted(IBackgroundTaskRegistration task, BackgroundTaskCompletedEventArgs args)
{
    UpdateUI();
}

auto completed{ [this](
        Windows::ApplicationModel::Background::BackgroundTaskRegistration const& /* sender */,
        Windows::ApplicationModel::Background::BackgroundTaskCompletedEventArgs const& /* args */)
{
    UpdateUI();
} };

auto completed = [this](BackgroundTaskRegistration^ task, BackgroundTaskCompletedEventArgs^ args)
{    
    UpdateUI();
};

Erstellen einer Ereignishandlerfunktion zum Behandeln des Status von Hintergrundaufgaben

Schritt 1

Erstellen Sie eine Ereignishandlerfunktion zum Behandeln abgeschlossener Hintergrundaufgaben. Dieser Code muss einem bestimmten Fußabdruck folgen, der ein IBackgroundTaskRegistration-Objekt und ein BackgroundTaskProgressEventArgs-Objekt einnimmt:

Verwenden Sie den folgenden Fußabdruck für die Ereignishandlermethode für Die OnProgress-Hintergrundaufgabe:

private void OnProgress(IBackgroundTaskRegistration task, BackgroundTaskProgressEventArgs args)
{
    // TODO: Add code that deals with background task progress.
}

auto progress{ [this](
    Windows::ApplicationModel::Background::BackgroundTaskRegistration const& /* sender */,
    Windows::ApplicationModel::Background::BackgroundTaskProgressEventArgs const& /* args */)
{
    // TODO: Add code that deals with background task progress.
} };

auto progress = [this](BackgroundTaskRegistration^ task, BackgroundTaskProgressEventArgs^ args)
{
    // TODO: Add code that deals with background task progress.
};

Schritt 2

Fügen Sie dem Ereignishandler Code hinzu, der den Abschluss der Hintergrundaufgabe behandelt.

Im Beispiel für hintergrundaufgaben wird beispielsweise die Benutzeroberfläche mit dem Status aktualisiert, der über den Args-Parameter übergeben wird:

private void OnProgress(IBackgroundTaskRegistration task, BackgroundTaskProgressEventArgs args)
{
    var progress = "Progress: " + args.Progress + "%";
    BackgroundTaskSample.SampleBackgroundTaskProgress = progress;
    UpdateUI();
}

auto progress{ [this](
    Windows::ApplicationModel::Background::BackgroundTaskRegistration const& /* sender */,
    Windows::ApplicationModel::Background::BackgroundTaskProgressEventArgs const& args)
{
    winrt::hstring progress{ L"Progress: " + winrt::to_hstring(args.Progress()) + L"%" };
    BackgroundTaskSample::SampleBackgroundTaskProgress = progress;
    UpdateUI();
} };

auto progress = [this](BackgroundTaskRegistration^ task, BackgroundTaskProgressEventArgs^ args)
{
    auto progress = "Progress: " + args->Progress + "%";
    BackgroundTaskSample::SampleBackgroundTaskProgress = progress;
    UpdateUI();
};

Registrieren der Ereignishandlerfunktionen bei neuen und vorhandenen Hintergrundaufgaben

Schritt 1

Wenn die App eine Hintergrundaufgabe zum ersten Mal registriert, sollte sie sich registrieren, um Status- und Abschlussaktualisierungen dafür zu erhalten, falls die Aufgabe ausgeführt wird, während die App noch im Vordergrund aktiv ist.

Beispielsweise ruft das Beispiel für hintergrundaufgaben die folgende Funktion für jede Hintergrundaufgabe auf, die registriert wird:

private void AttachProgressAndCompletedHandlers(IBackgroundTaskRegistration task)
{
    task.Progress += new BackgroundTaskProgressEventHandler(OnProgress);
    task.Completed += new BackgroundTaskCompletedEventHandler(OnCompleted);
}

void SampleBackgroundTask::AttachProgressAndCompletedHandlers(Windows::ApplicationModel::Background::IBackgroundTaskRegistration const& task)
{
    auto progress{ [this](
        Windows::ApplicationModel::Background::BackgroundTaskRegistration const& /* sender */,
        Windows::ApplicationModel::Background::BackgroundTaskProgressEventArgs const& args)
    {
        winrt::hstring progress{ L"Progress: " + winrt::to_hstring(args.Progress()) + L"%" };
        BackgroundTaskSample::SampleBackgroundTaskProgress = progress;
        UpdateUI();
    } };

    task.Progress(progress);

    auto completed{ [this](
        Windows::ApplicationModel::Background::BackgroundTaskRegistration const& /* sender */,
        Windows::ApplicationModel::Background::BackgroundTaskCompletedEventArgs const& /* args */)
    {
        UpdateUI();
    } };

    task.Completed(completed);
}

void SampleBackgroundTask::AttachProgressAndCompletedHandlers(IBackgroundTaskRegistration^ task)
{
    auto progress = [this](BackgroundTaskRegistration^ task, BackgroundTaskProgressEventArgs^ args)
    {
        auto progress = "Progress: " + args->Progress + "%";
        BackgroundTaskSample::SampleBackgroundTaskProgress = progress;
        UpdateUI();
    };

    task->Progress += ref new BackgroundTaskProgressEventHandler(progress);

    auto completed = [this](BackgroundTaskRegistration^ task, BackgroundTaskCompletedEventArgs^ args)
    {
        UpdateUI();
    };

    task->Completed += ref new BackgroundTaskCompletedEventHandler(completed);
}

Schritt 2

Wenn die App gestartet wird oder zu einer neuen Seite navigiert, auf der der Status der Hintergrundaufgabe relevant ist, sollte eine Liste der derzeit registrierten Hintergrundaufgaben abgerufen und den Status- und Abschlussereignishandlerfunktionen zugeordnet werden. Die Liste der derzeit von der Anwendung registrierten Hintergrundaufgaben wird im BackgroundTaskRegistration-Verzeichnis gespeichert.AllTasks-Eigenschaft .

Im Beispiel für die Hintergrundaufgabe wird beispielsweise der folgende Code zum Anfügen von Ereignishandlern verwendet, wenn die SampleBackgroundTask-Seite navigiert wird:

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    foreach (var task in BackgroundTaskRegistration.AllTasks)
    {
        if (task.Value.Name == BackgroundTaskSample.SampleBackgroundTaskName)
        {
            AttachProgressAndCompletedHandlers(task.Value);
            BackgroundTaskSample.UpdateBackgroundTaskStatus(BackgroundTaskSample.SampleBackgroundTaskName, true);
        }
    }

    UpdateUI();
}

void SampleBackgroundTask::OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs const& /* e */)
{
    // A pointer back to the main page. This is needed if you want to call methods in MainPage such
    // as NotifyUser().
    m_rootPage = MainPage::Current;

    // Attach progress and completed handlers to any existing tasks.
    auto allTasks{ Windows::ApplicationModel::Background::BackgroundTaskRegistration::AllTasks() };

    for (auto const& task : allTasks)
    {
        if (task.Value().Name() == SampleBackgroundTaskName)
        {
            AttachProgressAndCompletedHandlers(task.Value());
            break;
        }
    }

    UpdateUI();
}

void SampleBackgroundTask::OnNavigatedTo(NavigationEventArgs^ e)
{
    // A pointer back to the main page.  This is needed if you want to call methods in MainPage such
    // as NotifyUser().
    rootPage = MainPage::Current;

    // Attach progress and completed handlers to any existing tasks.
    auto iter = BackgroundTaskRegistration::AllTasks->First();
    auto hascur = iter->HasCurrent;
    while (hascur)
    {
        auto cur = iter->Current->Value;

        if (cur->Name == SampleBackgroundTaskName)
        {
            AttachProgressAndCompletedHandlers(cur);
            break;
        }

        hascur = iter->MoveNext();
    }

    UpdateUI();
}