Achtergrondoverdrachten

Gebruik de API voor achtergrondoverdracht om bestanden betrouwbaar via het netwerk te kopiëren. De API voor achtergrondoverdracht biedt geavanceerde functies voor uploaden en downloaden die op de achtergrond worden uitgevoerd tijdens het opschorten van apps en deze blijven behouden na beëindiging van de app. De API bewaakt de netwerkstatus en onderbreekt en hervat de overdrachten wanneer de verbinding is verbroken en overdrachten zijn ook Data Sense-aware en Battery Sense-aware, wat betekent dat de downloadactiviteit wordt aangepast op basis van de huidige connectiviteit en de batterijstatus van uw apparaat. De API is ideaal voor het uploaden en downloaden van grote bestanden met behulp van HTTP(S). FTP wordt ook ondersteund, maar alleen voor downloads.

Achtergrondoverdracht wordt afzonderlijk uitgevoerd van de aanroepende app en is voornamelijk ontworpen voor langdurige overdrachtsbewerkingen voor resources zoals video, muziek en grote afbeeldingen. Voor deze scenario's is het gebruik van Achtergrondoverdracht essentieel omdat downloads doorgaan met de voortgang, zelfs wanneer de app wordt onderbroken.

Als u kleine resources downloadt die waarschijnlijk snel worden voltooid, moet u HttpClient-API's gebruiken in plaats van Achtergrondoverdracht.

Windows.Networking.BackgroundTransfer gebruiken

Hoe werkt de functie Achtergrondoverdracht?

Wanneer een app Achtergrondoverdracht gebruikt om een overdracht te starten, wordt de aanvraag geconfigureerd en geïnitialiseerd met behulp van BackgroundDownloader - of BackgroundUploader-klasseobjecten . Elke overdrachtsbewerking wordt afzonderlijk verwerkt door het systeem en gescheiden van de aanroepende app. Voortgangsgegevens zijn beschikbaar als u de status wilt geven aan de gebruiker in de gebruikersinterface van uw app en uw app de gegevens kan onderbreken, hervatten, annuleren of zelfs lezen terwijl de overdracht plaatsvindt. De manier waarop overdrachten worden verwerkt door het systeem bevordert slim energieverbruik en voorkomt problemen die zich kunnen voordoen wanneer een verbonden app gebeurtenissen tegenkomt, zoals app-schorsing, beëindiging of plotselinge wijzigingen in de netwerkstatus.

Wanneer een toepassing wordt gestart, moet deze AttachAsync aanroepen voor alle bestaande DownloadOperation - en UploadOperation-objecten . Als u dit niet doet, wordt het lekken van reeds voltooide overdrachten veroorzaakt en wordt uw gebruik van de functie Achtergrondoverdracht onbruikbaar.

Geverifieerde bestandsaanvragen uitvoeren met achtergrondoverdracht

Background Transfer biedt methoden die ondersteuning bieden voor basisserver- en proxyreferenties, cookies en het gebruik van aangepaste HTTP-headers (via SetRequestHeader) voor elke overdrachtsbewerking.

Hoe past deze functie zich aan bij wijzigingen in de netwerkstatus of onverwachte afsluitingen?

De functie Achtergrondoverdracht behoudt een consistente ervaring voor elke overdrachtsbewerking wanneer er wijzigingen in de netwerkstatus optreden, door op intelligente wijze gebruik te maken van statusinformatie over connectiviteit en gegevensplan van de provider die wordt verstrekt door de connectiviteitsfunctie. Voor het definiëren van gedrag voor verschillende netwerkscenario's stelt een app een kostenbeleid in voor elke bewerking met behulp van waarden die zijn gedefinieerd door BackgroundTransferCostPolicy.

Het kostenbeleid dat is gedefinieerd voor een bewerking kan bijvoorbeeld aangeven dat de bewerking automatisch moet worden onderbroken wanneer het apparaat een netwerk met datalimiet gebruikt. De overdracht wordt vervolgens automatisch hervat (of opnieuw gestart) wanneer er een verbinding met een 'onbeperkt' netwerk tot stand is gebracht. Zie NetworkCostType voor meer informatie over hoe netwerken worden gedefinieerd op basis van kosten.

Hoewel de functie Achtergrondoverdracht zijn eigen mechanismen heeft voor het afhandelen van wijzigingen in de netwerkstatus, zijn er andere algemene overwegingen voor connectiviteit voor apps die zijn verbonden met het netwerk. Lees informatie over het benutten van beschikbare netwerkverbindingen voor meer details.

Notitie Voor apps die worden uitgevoerd op mobiele apparaten, zijn er functies waarmee de gebruiker de hoeveelheid gegevens kan bewaken en beperken die wordt overgedragen op basis van het type verbinding, roamingstatus en het gegevensabonnement van de gebruiker. Hierdoor kunnen achtergrondoverdrachten op de telefoon worden onderbroken, zelfs wanneer de BackgroundTransferCostPolicy aangeeft dat de overdracht moet worden voortgezet.

De volgende tabel geeft aan wanneer achtergrondoverdrachten zijn toegestaan op de telefoon voor elke BackgroundTransferCostPolicy-waarde , gezien de huidige status van de telefoon. U kunt de ConnectionCost-klasse gebruiken om de huidige status van de telefoon te bepalen.

Bestanden uploaden

Wanneer u Achtergrondoverdracht gebruikt, bestaat er een upload als een UploadOperation- die een aantal besturingsmethoden beschikbaar maakt die worden gebruikt om de bewerking opnieuw op te starten of te annuleren. App-gebeurtenissen (bijvoorbeeld schorsing of beëindiging) en connectiviteitswijzigingen worden automatisch verwerkt door het systeem per UploadOperation; uploads worden voortgezet tijdens de onderbrekingsperioden van de app of onderbreken en blijven behouden na beëindiging van de app. Daarnaast geeft het instellen van de eigenschap CostPolicy aan of uw app uploadt terwijl een netwerk met datalimiet wordt gebruikt voor internetverbinding.

In de volgende voorbeelden wordt u begeleid bij het maken en initialiseren van een eenvoudige upload en het inventariseren en opnieuw introduceren van bewerkingen die zijn opgeslagen vanuit een vorige app-sessie.

Eén bestand uploaden

Het maken van een upload begint met BackgroundUploader. Deze klasse wordt gebruikt om de methoden op te geven waarmee uw app de upload kan configureren voordat u de resulterende UploadOperation maakt. In het volgende voorbeeld ziet u hoe u dit doet met de vereiste URI - en StorageFile-objecten .

Het bestand en de bestemming voor het uploaden identificeren

Voordat we kunnen beginnen met het maken van een UploadOperation, moeten we eerst de URI van de locatie identificeren waarnaar moet worden geüpload en het bestand dat wordt geüpload. In het volgende voorbeeld wordt de uriString-waarde gevuld met behulp van een tekenreeks uit UI-invoer, en de bestandswaarde door het StorageFile--object dat wordt geretourneerd door een PickSingleFileAsync--bewerking.

function uploadFile() {
    var filePicker = new Windows.Storage.Pickers.FileOpenPicker();
    filePicker.fileTypeFilter.replaceAll(["*"]);

    filePicker.pickSingleFileAsync().then(function (file) {
        if (!file) {
            printLog("No file selected");
            return;
        }

        var upload = new UploadOp();
        var uriString = document.getElementById("serverAddressField").value;
        upload.start(uriString, file);

        // Store the upload operation in the uploadOps array.
        uploadOperations.push(upload);
    });
}

De uploadbewerking maken en initialiseren

In de vorige stap worden de uriString - en bestandswaarden doorgegeven aan een exemplaar van ons volgende voorbeeld, UploadOp, waar ze worden gebruikt om de nieuwe uploadbewerking te configureren en te starten. Eerst wordt uriString geparseerd om het vereiste Uri-object te maken.

Vervolgens worden de eigenschappen van het opgegeven StorageFile (bestand) door BackgroundUploader gebruikt om de aanvraagheader te vullen en de eigenschap SourceFile in te stellen met het StorageFile-object . De methode SetRequestHeader wordt vervolgens aangeroepen om de bestandsnaam in te voegen, opgegeven als een tekenreeks en de eigenschap StorageFile.Name .

Ten slotte maakt BackgroundUploader de UploadOperation- (upload).

function UploadOp() {
    var upload = null;
    var promise = null;

    this.start = function (uriString, file) {
        try {
        
            var uri = new Windows.Foundation.Uri(uriString);
            var uploader = new Windows.Networking.BackgroundTransfer.BackgroundUploader();

            // Set a header, so the server can save the file (this is specific to the sample server).
            uploader.setRequestHeader("Filename", file.name);

            // Create a new upload operation.
            upload = uploader.createUpload(uri, file);

            // Start the upload and persist the promise to be able to cancel the upload.
            promise = upload.startAsync().then(complete, error, progress);
        } catch (err) {
            displayError(err);
        }
    };
    // On application activation, reassign callbacks for a upload
    // operation persisted from previous application state.
    this.load = function (loadedUpload) {
        try {
            upload = loadedUpload;
            promise = upload.attachAsync().then(complete, error, progress);
        } catch (err) {
            displayError(err);
        }
    };
}

Noteer de asynchrone methodeaanroepen die zijn gedefinieerd met behulp van JavaScript-promises. Bekijk een regel uit het laatste voorbeeld:

promise = upload.startAsync().then(complete, error, progress);

De aanroep van de asynchrone methode wordt gevolgd door een then instructie die methoden aangeeft die worden gedefinieerd door de app, die worden aangeroepen wanneer een resultaat van de aanroep van de asynchrone methode wordt geretourneerd. Zie Asynchrone programmering in JavaScript met behulp van beloften voor meer informatie over dit programmeerpatroon.

Meerdere bestanden uploaden

De bestanden en bestemming voor het uploaden identificeren

In een scenario waarbij meerdere bestanden worden overgebracht met één UploadOperation, begint het proces zoals meestal gebeurt door eerst de vereiste doel-URI en lokale bestandsgegevens op te geven. Net als in het voorbeeld in de vorige sectie, wordt de URI als een tekenreeks door de eindgebruiker geleverd en kan FileOpenPicker worden gebruikt om ook bestanden via de gebruikersinterface aan te geven. In dit scenario moet de app echter de methode PickMultipleFilesAsync aanroepen om de selectie van meerdere bestanden via de gebruikersinterface in te schakelen.

function uploadFiles() {
       var filePicker = new Windows.Storage.Pickers.FileOpenPicker();
       filePicker.fileTypeFilter.replaceAll(["*"]);

       filePicker.pickMultipleFilesAsync().then(function (files) {
          if (files === 0) {
             printLog("No file selected");
                return;
          }

          var upload = new UploadOperation();
          var uriString = document.getElementById("serverAddressField").value;
          upload.startMultipart(uriString, files);

          // Persist the upload operation in the global array.
          uploadOperations.push(upload);
       });
    }

Objecten maken voor de opgegeven parameters

In de volgende twee voorbeelden wordt code gebruikt die is opgenomen in één voorbeeldmethode, startMultipart, die aan het einde van de laatste stap is aangeroepen. Voor het doel van instructies is de code in de methode waarmee een matrix van BackgroundTransferContentPart-objecten objecten is gesplitst op basis van de code waarmee de resulterende UploadOperation-wordt gemaakt.

Eerst wordt de URI-tekenreeks die door de gebruiker wordt geleverd, geïnitialiseerd als een URI. Vervolgens wordt de matrix van IStorageFile-objecten (bestanden) die aan deze methode worden doorgegeven, doorgegeven, elk object gebruikt om een nieuw BackgroundTransferContentPart-object te maken dat vervolgens in de contentParts-matrix wordt geplaatst.

    upload.startMultipart = function (uriString, files) {
        try {
            var uri = new Windows.Foundation.Uri(uriString);
            var uploader = new Windows.Networking.BackgroundTransfer.BackgroundUploader();

            var contentParts = [];
            files.forEach(function (file, index) {
                var part = new Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart("File" + index, file.name);
                part.setFile(file);
                contentParts.push(part);
            });

De uploadbewerking met meerdere onderdelen maken en initialiseren

Nu onze contentParts-matrix is gevuld met alle BackgroundTransferContentPart-objecten die elke IStorageFile vertegenwoordigen voor uploaden, zijn we klaar om CreateUploadAsync aan te roepen met behulp van de URI om aan te geven waar de aanvraag wordt verzonden.

        // Create a new upload operation.
            uploader.createUploadAsync(uri, contentParts).then(function (uploadOperation) {

               // Start the upload and persist the promise to be able to cancel the upload.
               upload = uploadOperation;
               promise = uploadOperation.startAsync().then(complete, error, progress);
            });

         } catch (err) {
             displayError(err);
         }
     };

Onderbroken uploadbewerkingen opnieuw starten

Na voltooiing of annulering van een Upload-operatie () worden alle gekoppelde systeembronnen vrijgegeven. Als uw app echter wordt beëindigd voordat een van deze dingen kan plaatsvinden, worden actieve bewerkingen onderbroken en blijven de resources die aan elke app zijn gekoppeld, bezet. Als deze bewerkingen niet zijn geïnventariseerd en opnieuw worden geïntroduceerd in de volgende app-sessie, worden ze niet voltooid en blijven ze apparaatresources in beslag nemen.

1. Voordat u de functie definieert die persistente bewerkingen opsommen, moeten we een matrix maken die de UploadOperation-objecten bevat die worden geretourneerd:

   var uploadOperations = [];
   

2. Vervolgens definiëren we de functie die persistente bewerkingen opsommen en opslaat in onze matrix. Houd er rekening mee dat de laadmethode die wordt aangeroepen om callbacks opnieuw toe te wijzen aan UploadOperation, moet blijven bestaan via app-beëindiging. Deze methode bevindt zich in de UploadOp-klasse die we verderop in deze sectie definiëren.

   function Windows.Networking.BackgroundTransfer.BackgroundUploader.getCurrentUploadsAsync() {
       .then(function (uploads) {
           for (var i = 0; i < uploads.size; i++) {
               var upload = new UploadOp();
               upload.load(uploads[i]);
               uploadOperations.push(upload);
           }
       }
   };
   

Bestanden downloaden

Wanneer u Achtergrondoverdracht gebruikt, bestaat elke download als DownloadOperation waarmee een aantal besturingsmethoden beschikbaar wordt gemaakt voor het onderbreken, hervatten, opnieuw opstarten en annuleren van de bewerking. App-gebeurtenissen (bijvoorbeeld schorsing of beëindiging) en connectiviteitswijzigingen worden automatisch verwerkt door het systeem per DownloadOperation; downloads worden voortgezet tijdens de onderbrekingsperioden van de app of onderbreken en blijven behouden na beëindiging van de app. Voor mobiele netwerkscenario's geeft het instellen van de eigenschap CostPolicy aan of uw app begint of blijft downloaden terwijl een netwerk met datalimiet wordt gebruikt voor internetverbinding.

Als u kleine resources downloadt die waarschijnlijk snel worden voltooid, moet u HttpClient-API's gebruiken in plaats van Achtergrondoverdracht.

In de volgende voorbeelden wordt u begeleid bij het maken en initialiseren van een eenvoudige download en het inventariseren en opnieuw introduceren van bewerkingen die zijn opgeslagen vanuit een vorige app-sessie.

Configureer en start een achtergrondoverdracht voor bestandsdownloads.

In het volgende voorbeeld ziet u hoe tekenreeksen die een URI en een bestandsnaam vertegenwoordigen, kunnen worden gebruikt om een URI-object en het StorageFile te maken dat het aangevraagde bestand bevat. In dit voorbeeld wordt het nieuwe bestand automatisch op een vooraf gedefinieerde locatie geplaatst. FileSavePicker kan ook worden gebruikt om gebruikers te laten aangeven waar het bestand op het apparaat moet worden opgeslagen. Houd er rekening mee dat de methode die wordt aangeroepen om callbacks opnieuw toe te wijzen aan de DownloadOperation-, zodat deze blijft bestaan na het beëindigen van de app, zich in de DownloadOp-klasse bevindt die verder in deze sectie is gedefinieerd.

function DownloadOp() {
    var download = null;
    var promise = null;
    var imageStream = null;

    this.start = function (uriString, fileName) {
        try {
            // Asynchronously create the file in the pictures folder.
            Windows.Storage.KnownFolders.picturesLibrary.createFileAsync(fileName, Windows.Storage.CreationCollisionOption.generateUniqueName).done(function (newFile) {
                var uri = Windows.Foundation.Uri(uriString);
                var downloader = new Windows.Networking.BackgroundTransfer.BackgroundDownloader();

                // Create a new download operation.
                download = downloader.createDownload(uri, newFile);

                // Start the download and persist the promise to be able to cancel the download.
                promise = download.startAsync().then(complete, error, progress);
            }, error);
        } catch (err) {
            displayException(err);
        }
    };
    // On application activation, reassign callbacks for a download
    // operation persisted from previous application state.
    this.load = function (loadedDownload) {
        try {
            download = loadedDownload;
            printLog("Found download: " + download.guid + " from previous application run.<br\>");
            promise = download.attachAsync().then(complete, error, progress);
        } catch (err) {
            displayException(err);
        }
    };
}

Noteer de asynchrone methodeaanroepen die zijn gedefinieerd met behulp van JavaScript-promises. Bekijk regel 17 uit het vorige codevoorbeeld:

promise = download.startAsync().then(complete, error, progress);

De aanroep van de asynchrone methode wordt gevolgd door een vervolgens-instructie die methoden aangeeft die worden gedefinieerd door de app, die worden aangeroepen wanneer een resultaat van de aanroep van de asynchrone methode wordt geretourneerd. Zie Asynchrone programmering in JavaScript met behulp van beloften voor meer informatie over dit programmeerpatroon.

Aanvullende methoden voor bewerkingsbeheer toevoegen

Het beheerniveau kan worden verhoogd door aanvullende DownloadOperation-methoden te implementeren. Als u bijvoorbeeld de volgende code toevoegt aan het bovenstaande voorbeeld, krijgt u de mogelijkheid om de download te annuleren.

// Cancel download.
this.cancel = function () {
    try {
        if (promise) {
            promise.cancel();
            promise = null;
            printLog("Canceling download: " + download.guid + "<br\>");
            if (imageStream) {
                imageStream.close();
            }
        }
        else {
            printLog("Download " + download.guid + " already canceled.<br\>");
        }
    } catch (err) {
        displayException(err);
    }
};

Persistente bewerkingen bij het opstarten inventariseren

Na voltooiing of annulering van een DownloadOperation worden alle bijbehorende systeembronnen vrijgegeven. Als uw app echter wordt beëindigd voordat een van deze gebeurtenissen plaatsvindt, zullen downloads pauzeren en op de achtergrond worden bewaard. In de volgende voorbeelden ziet u hoe u persistente downloads opnieuw kunt introduceren in een nieuwe app-sessie.

1. Voordat u de functie definieert die persistente bewerkingen opsommen, moeten we een matrix maken die de DownloadOperation-objecten bevat die worden geretourneerd:

   var downloadOps = [];
   

2. Vervolgens definiëren we de functie die persistente bewerkingen opsommen en opslaat in onze matrix. Houd er rekening mee dat de methode voor het opnieuw toewijzen van callbacks aan een persistente DownloadOperation zich in het DownloadOp-voorbeeld bevindt dat we verderop in deze sectie definiëren.

   // Enumerate outstanding downloads.
   Windows.Networking.BackgroundTransfer.BackgroundDownloader.getCurrentDownloadsAsync().done(function (downloads) {
   
       for (var i = 0; i < downloads.size; i++) {
           var download = new DownloadOp();
           download.load(downloads[i]);
           downloadOps.push(download);
       }
   });
   

3. U kunt nu de ingevulde lijst gebruiken om bewerkingen die in behandeling zijn opnieuw te starten.

Naverwerking

Een nieuwe functie in Windows 10 is de mogelijkheid om toepassingscode uit te voeren bij het voltooien van een achtergrondoverdracht, zelfs wanneer de app niet wordt uitgevoerd. Uw app kan bijvoorbeeld een lijst met beschikbare films bijwerken nadat een film is gedownload, in plaats van dat uw app elke keer dat deze wordt gestart, scant op nieuwe films. Of uw app wil mogelijk een mislukte bestandsoverdracht afhandelen door het opnieuw te proberen met een andere server of poort. Naverwerking wordt aangeroepen voor zowel geslaagde als mislukte overdrachten, zodat u deze kunt gebruiken om aangepaste foutafhandeling en logica voor opnieuw proberen te implementeren.

Naverwerking maakt gebruik van de bestaande infrastructuur voor achtergrondtaken. U maakt een achtergrondtaak en koppelt deze aan uw overdrachten voordat u de overdrachten start. De overdrachten worden vervolgens op de achtergrond uitgevoerd en wanneer ze zijn voltooid, wordt uw achtergrondtaak aangeroepen om naverwerking uit te voeren.

Na verwerking wordt een nieuwe klasse BackgroundTransferCompletionGroup gebruikt. Deze klasse is vergelijkbaar met de bestaande BackgroundTransferGroup omdat u hiermee achtergrondoverdrachten kunt groeperen, maar BackgroundTransferCompletionGroup voegt de mogelijkheid toe om een achtergrondtaak aan te wijzen die moet worden uitgevoerd wanneer de overdracht is voltooid.

U start als volgt een achtergrondoverdracht met naverwerking.

1. Maak een BackgroundTransferCompletionGroup-object. Maak vervolgens een BackgroundTaskBuilder-object . Stel de Trigger-eigenschap van het builder-object in op het voltooiingsgroepobject en de TaskEntryPoint-eigenschap van het builder-object op het toegangspunt van de achtergrondtaak die moet worden uitgevoerd tijdens de voltooiing van de overdracht. Roep ten slotte de methode BackgroundTaskBuilder.Register aan om uw achtergrondtaak te registreren. Houd er rekening mee dat veel voltooiingsgroepen één ingangspunt voor achtergrondtaken kunnen delen, maar u kunt slechts één voltooiingsgroep per achtergrondtaakregistratie hebben.

var completionGroup = new BackgroundTransferCompletionGroup();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();

builder.Name = "MyDownloadProcessingTask";
builder.SetTrigger(completionGroup.Trigger);
builder.TaskEntryPoint = "Tasks.BackgroundDownloadProcessingTask";

BackgroundTaskRegistration downloadProcessingTask = builder.Register();

2. Vervolgens koppelt u achtergrondoverdrachten aan de voltooiingsgroep. Zodra alle overdrachten zijn gemaakt, schakelt u de voltooiingsgroep in.

BackgroundDownloader downloader = new BackgroundDownloader(completionGroup);
DownloadOperation download = downloader.CreateDownload(uri, file);
Task<DownloadOperation> startTask = download.StartAsync().AsTask();

// App still sees the normal completion path
startTask.ContinueWith(ForegroundCompletionHandler);

// Do not enable the CompletionGroup until after all downloads are created.
downloader.CompletionGroup.Enable();

3. De code in de achtergrondtaak extraheert de lijst met bewerkingen uit de triggerdetails en uw code kan vervolgens de details voor elke bewerking inspecteren en de juiste naverwerking uitvoeren voor elke bewerking.

public class BackgroundDownloadProcessingTask : IBackgroundTask
{
    public async void Run(IBackgroundTaskInstance taskInstance)
    {
    var details = (BackgroundTransferCompletionGroupTriggerDetails)taskInstance.TriggerDetails;
    IReadOnlyList<DownloadOperation> downloads = details.Downloads;

    // Do post-processing on each finished operation in the list of downloads
    }
}

De naverwerkingstaak is een gewone achtergrondtaak. Het maakt deel uit van de groep van alle achtergrondtaken en is onderworpen aan hetzelfde resourcebeheerbeleid als alle achtergrondtaken.

Houd er ook rekening mee dat nabewerking geen voorgrond-afhandelingsroutines vervangt. Als uw app een voorgrondvoltooiingshandler definieert en uw app wordt uitgevoerd wanneer de bestandsoverdracht is voltooid, worden zowel uw voorgrond-voltooiingshandler als de handler voor voltooiing op de achtergrond aangeroepen. De volgorde waarin voorgrond- en achtergrondtaken worden aangeroepen, is niet gegarandeerd. Als u beide definieert, moet u ervoor zorgen dat de twee taken goed werken en elkaar niet verstoren als ze gelijktijdig worden uitgevoerd.

Time-outs aanvragen

Er zijn twee primaire time-outscenario's voor verbindingen om rekening mee te houden:

• Bij het tot stand brengen van een nieuwe verbinding voor een overdracht wordt de verbindingsaanvraag afgebroken als deze niet binnen vijf minuten tot stand is gebracht.

• Nadat een verbinding tot stand is gebracht, wordt een HTTP-aanvraagbericht dat binnen twee minuten geen antwoord heeft ontvangen, afgebroken.

Notitie In beide scenario's, ervan uitgaande dat er een internetverbinding is, wordt met Achtergrondoverdracht een aanvraag maximaal drie keer automatisch opnieuw geprobeerd. In het geval dat er geen internetverbinding wordt gedetecteerd, wachten aanvullende aanvragen totdat dit het geval is.

Richtlijnen voor foutopsporing

Het stoppen van een foutopsporingssessie in Microsoft Visual Studio is vergelijkbaar met het sluiten van uw app; PUT-uploads worden onderbroken en POST-uploads worden beëindigd. Zelfs tijdens foutopsporing moet uw app de persistente uploads inventariseren en vervolgens opnieuw opstarten of annuleren. U kunt uw app bijvoorbeeld persistente uploadbewerkingen laten annuleren bij het opstarten van de app als er geen interesse is in eerdere bewerkingen voor die foutopsporingssessie.

Tijdens het inventariseren van downloads/uploads bij het opstarten van apps tijdens een foutopsporingssessie, kunt u ervoor zorgen dat uw app deze annuleert als er geen interesse is in eerdere bewerkingen voor die foutopsporingssessie. Houd er rekening mee dat als er Visual Studio-projectupdates zijn, zoals wijzigingen in het app-manifest, en de app wordt verwijderd en opnieuw wordt geïmplementeerd, GetCurrentUploadsAsync geen bewerkingen kan inventariseren die zijn gemaakt met behulp van de vorige app-implementatie.

Wanneer u Achtergrondoverdracht gebruikt tijdens de ontwikkeling, krijgt u mogelijk een situatie waarin de interne caches van actieve en voltooide overdrachtsbewerkingen niet meer synchroon kunnen zijn. Dit kan leiden tot het niet kunnen starten van nieuwe overdrachtsbewerkingen of het werken met bestaande bewerkingen en BackgroundTransferGroup-objecten . In sommige gevallen kan een poging om te communiceren met bestaande bewerkingen een crash veroorzaken. Dit resultaat kan optreden als de eigenschap TransferBehavior is ingesteld op Parallel. Dit probleem treedt alleen op in bepaalde scenario's tijdens de ontwikkeling en is niet van toepassing op eindgebruikers van uw app.

Vier scenario's waarbij Visual Studio wordt gebruikt, kunnen dit probleem veroorzaken.

• U maakt een nieuw project met dezelfde app-naam als een bestaand project, maar een andere taal (bijvoorbeeld van C++ tot C#).
• U wijzigt de doelarchitectuur (bijvoorbeeld van x86 in x64) in een bestaand project.
• U wijzigt de cultuur (bijvoorbeeld van neutraal naar en-US) in een bestaand project.
• U voegt een mogelijkheid toe aan of verwijdert u een mogelijkheid in het pakketmanifest (bijvoorbeeld enterprise authentication toevoegen) in een bestaand project.

Normaal app-onderhoud, inclusief manifestupdates die mogelijkheden toevoegen of verwijderen, activeren dit probleem niet bij implementaties van eindgebruikers van uw app. U kunt dit probleem omzeilen door alle versies van de app volledig te verwijderen en opnieuw te implementeren met de nieuwe taal, architectuur, cultuur of mogelijkheid. Dit kan via het startscherm of met behulp van PowerShell en de cmdlet Remove-AppxPackage .

Uitzonderingen in Windows.Networking.BackgroundTransfer

Er wordt een uitzondering gegenereerd wanneer een ongeldige tekenreeks voor een URI (Uniform Resource Identifier) wordt doorgegeven aan de constructor voor het Windows.Foundation.Uri-object .

.NET: Het type Windows.Foundation.Uri wordt weergegeven als System.Uri in C# en VB.

In C# en Visual Basic kan deze fout worden vermeden met behulp van de klasse System.Uri in de .NET 4.5 en een van de methoden System.Uri.TryCreate om de tekenreeks te testen die is ontvangen van de app-gebruiker voordat de URI wordt samengesteld.

In C++is er geen methode om een tekenreeks te parseren naar een URI. Als een app invoer krijgt van de gebruiker voor de Windows.Foundation.Uri-, moet de constructor zich in een try/catch-blok bevinden. Als er een uitzondering optreedt, kan de app de gebruiker op de hoogte stellen en een nieuwe hostnaam aanvragen.

De naamruimte Windows.Networking.backgroundTransfer heeft handige helpermethoden en maakt gebruik van opsommingen in de Windows.Networking.Sockets-naamruimte voor het afhandelen van fouten. Dit kan nuttig zijn om specifieke netwerkuitzonderingen anders af te handelen in uw app.

Er is een fout opgetreden in een asynchrone methode in de Windows.Networking.backgroundTransfer naamruimte, die als een HRESULT waarde wordt geretourneerd. De methode BackgroundTransferError.GetStatus wordt gebruikt om een netwerkfout van een achtergrondoverdrachtbewerking te converteren naar een opsommingswaarde webErrorStatus . De meeste webErrorStatus-opsommingswaarden komen overeen met een fout die wordt geretourneerd door de systeemeigen HTTP- of FTP-clientbewerking. Een app kan filteren op specifieke WebErrorStatus-opsommingswaarden om het gedrag van apps te wijzigen, afhankelijk van de oorzaak van de uitzondering.

Voor parametervalidatiefouten kan een app ook HRESULT van de uitzondering gebruiken voor meer gedetailleerde informatie over de fout die de uitzondering heeft veroorzaakt. Mogelijke HRESULT-waarden worden vermeld in het headerbestand Winerror.h . Voor de meeste parametervalidatiefouten wordt HRESULT geretourneerd als E_INVALIDARG .

Belangrijke API's

• Windows.Networking.BackgroundTransfer
• Windows.Foundation.Uri
• Windows.Networking.Sockets