Delen via

Een achtergrondtaak registreren

Belangrijke API's

Meer informatie over het maken van een functie die opnieuw kan worden gebruikt om de meeste achtergrondtaken veilig te registreren.

Dit onderwerp is van toepassing op zowel in-process achtergrondtaken als achtergrondtaken buiten het proces. In dit onderwerp wordt ervan uitgegaan dat u al een achtergrondtaak hebt die moet worden geregistreerd. (Zie Een achtergrondtaak maken en registreren dat buiten het proces draait of Een in-process achtergrondtaak maken en registreren voor informatie over het schrijven van een achtergrondtaak).

In dit onderwerp wordt een hulpprogrammafunctie beschreven waarmee achtergrondtaken worden geregistreerd. Met deze hulpprogrammafunctie wordt eerst gecontroleerd op bestaande registraties voordat de taak meerdere keren wordt geregistreerd om problemen met meerdere registraties te voorkomen en kan er een systeemvoorwaarde worden toegepast op de achtergrondtaak. Het overzicht bevat een volledig, werkend voorbeeld van deze hulpprogrammafunctie.

Opmerking   

Universele Windows-apps moeten RequestAccessAsync- aanroepen voordat een van de typen achtergrondtriggers wordt geregistreerd.

Om ervoor te zorgen dat uw Universele Windows-app correct blijft worden uitgevoerd nadat u een update hebt uitgebracht, moet u RemoveAccess- aanroepen en vervolgens RequestAccessAsync- aanroepen wanneer uw app wordt gestart nadat deze is bijgewerkt. Zie Richtlijnen voor achtergrondtakenvoor meer informatie.

De signatuur van de methode en het retourtype definiëren

Deze methode ontvangt het startpunt van de taak, de taaknaam, een voorgeconfigureerde trigger voor de achtergrondtaak, en (optioneel) een SystemCondition. Met deze methode wordt een BackgroundTaskRegistration-object geretourneerd.

Belangrijk

taskEntryPoint: voor achtergrondtaken die in een aparte proces worden uitgevoerd, moet dit worden samengesteld als de naam van de naamruimte, '.', en de naam van de klasse die uw achtergrondtaak bevat. De tekenreeks is hoofdlettergevoelig. Als u bijvoorbeeld een naamruimte 'MyBackgroundTasks' en een klasse BackgroundTask1 had die uw achtergrondklassecode bevatte, zou de tekenreeks taskEntryPoint 'MyBackgroundTasks.BackgroundTask1' zijn. Als uw achtergrondtaak wordt uitgevoerd in hetzelfde proces als uw app (d.w.: een achtergrondtaak in het proces) taskEntryPoint moet niet worden ingesteld.

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.

}

Controleren op bestaande registraties

Controleer of de taak al is geregistreerd. Het is belangrijk om dit te controleren omdat als een taak meerdere keren is geregistreerd, deze meer dan één keer wordt uitgevoerd wanneer deze wordt geactiveerd; dit kan overtollige CPU gebruiken en kan onverwacht gedrag veroorzaken.

U kunt controleren op bestaande registraties door een query uit te voeren op de eigenschap BackgroundTaskRegistration.AllTasks en het resultaat te herhalen. Controleer de naam van elk exemplaar. Als deze overeenkomt met de naam van de taak die u registreert, breekt u de lus uit en stelt u een vlagvariabele in, zodat uw code in de volgende stap een ander pad kan kiezen.

Notitie Gebruik achtergrondtaaknamen die uniek zijn voor uw app. Zorg ervoor dat elke achtergrondtaak een unieke naam heeft.

Met de volgende code wordt een achtergrondtaak geregistreerd met behulp van de SystemTrigger die we in de laatste stap hebben gemaakt:

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.
}

De achtergrondtaak registreren (of de bestaande registratie retourneren)

Controleer of de taak is gevonden in de lijst met bestaande registraties van achtergrondtaken. Als dat het geval is, geef dat exemplaar van de taak terug.

Registreer vervolgens de taak met behulp van een nieuw BackgroundTaskBuilder-object . Met deze code moet worden gecontroleerd of de voorwaardeparameter null is. Als dat niet het geval is, voegt u de voorwaarde toe aan het registratieobject. Retourneer de BackgroundTaskRegistration geretourneerd door de BackgroundTaskBuilder.Register methode.

Notitie Parameters voor registratie van achtergrondtaken worden gevalideerd op het moment van registratie. Er wordt een fout geretourneerd als een van de registratieparameters ongeldig is. Zorg ervoor dat uw app probleemloos scenario's verwerkt waarbij de registratie van achtergrondtaken mislukt. Als uw app in plaats daarvan afhankelijk is van een geldig registratieobject nadat u een taak hebt geregistreerd, kan deze vastlopen. Notitie Als u een achtergrondtaak registreert die wordt uitgevoerd in hetzelfde proces als uw app, verzendt String.Empty of null voor de taskEntryPoint parameter.

In het volgende voorbeeld wordt de bestaande taak geretourneerd of code toegevoegd waarmee de achtergrondtaak wordt geregistreerd (inclusief de optionele systeemvoorwaarde indien aanwezig):

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;
}

De functie Registratie van achtergrondtaken voltooien

In dit voorbeeld ziet u de voltooide achtergrondtaakregistratiefunctie. Deze functie kan worden gebruikt om de meeste achtergrondtaken te registreren, met uitzondering van netwerkachtergrondtaken.

//
// 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