Freigeben über

Überwachung des Fortschritts und Abschlusses von Hintergrundaufgaben

Wichtige APIs

Erfahren Sie, wie Ihre App den Fortschritt und den Abschluss erkennen kann, der von einer Hintergrundaufgabe gemeldet wird, die außerhalb des Prozesses läuft. (Bei Hintergrundaufgaben während des Prozesses können Sie freigegebene Variablen zum Anzeigen des Fortschritts und Abschlusses verwenden.)

Der Fortschritt und der Abschluss der Hintergrundaufgabe können 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 einer bestimmten Spezifikation folgen, die ein IBackgroundTaskRegistration--Objekt und ein BackgroundTaskCompletedEventArgs--Objekt erfordert.

Verwenden Sie den folgenden Fußabdruck für die OnCompleted Ereignishandlermethode für Hintergrundaufgaben.

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.

Beispielsweise aktualisiert das Hintergrundaufgabenbeispiel die Benutzeroberfläche.

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 Fortschritts 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 die folgende Signatur für die Ereignishandlermethode der 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.

Beispielsweise aktualisiert das -Hintergrundaufgabenbeispiel die Benutzeroberfläche mit dem Fortschrittsstatus, der über den Parameter Argumente ü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 Sie die Ereignishandlerfunktionen für neue und vorhandene 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 Hintergrundaufgabenbeispiel 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 Anwendung gestartet wird oder zu einer neuen Seite navigiert, auf der der Status der Hintergrundaufgabe relevant ist, sollte sie eine Liste der aktuell registrierten Hintergrundaufgaben abrufen und sie den Fortschritts- und Abschlussereignishandlerfunktionen zuordnen. Die Liste der derzeit von der Anwendung registrierten Hintergrundaufgaben wird in der BackgroundTaskRegistration--AllTasks--Eigenschaft gespeichert.

Beispielsweise verwendet das -Hintergrundaufgabenbeispiel den folgenden Code, um Ereignishandler anzufügen, wenn zur Seite "SampleBackgroundTask" 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();
}
  • Last updated on