Bakgrundsöverföringar

Använd API:et för bakgrundsöverföring för att kopiera filer på ett tillförlitligt sätt över nätverket. API:et för bakgrundsöverföring innehåller avancerade funktioner för uppladdning och nedladdning som körs i bakgrunden under appavstängningen och som kvarstår utöver appavslut. API:et övervakar nätverksstatus och pausar automatiskt och återupptar överföringar när anslutningen går förlorad, och överföringar är också Data Sense-medvetna och Battery Sense-medvetna, vilket innebär att nedladdningsaktiviteten justeras baserat på din aktuella anslutning och enhetens batteristatus. API:et är perfekt för att ladda upp och ladda ned stora filer med HTTP(S). FTP stöds också, men endast för nedladdningar.

Bakgrundsöverföring körs separat från den anropande appen och är främst utformad för långsiktiga överföringsåtgärder för resurser som video, musik och stora bilder. För dessa scenarier är det viktigt att använda bakgrundsöverföring eftersom nedladdningar fortsätter att fortsätta även när appen är pausad.

Om du laddar ned små resurser som sannolikt kommer att slutföras snabbt bör du använda HttpClient-API :er i stället för bakgrundsöverföring.

Använda Windows.Networking.BackgroundTransfer

Hur fungerar funktionen För bakgrundsöverföring?

När en app använder Bakgrundsöverföring för att initiera en överföring konfigureras och initieras begäran med hjälp av BackgroundDownloader - eller BackgroundUploader-klassobjekt . Varje överföringsåtgärd hanteras individuellt av systemet och separeras från den anropande appen. Förloppsinformation är tillgänglig om du vill ge status till användaren i appens användargränssnitt och appen kan pausa, återuppta, avbryta eller till och med läsa från data medan överföringen sker. Det sätt på vilket överföringar hanteras av systemet främjar smart energianvändning och förhindrar problem som kan uppstå när en ansluten app stöter på händelser som appavstängning, avslutning eller plötsliga ändringar i nätverksstatusen.

När ett program startas måste det anropa AttachAsync på alla befintliga DownloadOperation - och UploadOperation-objekt . Om du inte gör detta orsakas läckan av redan slutförda överföringar och kommer så småningom att göra din användning av funktionen Background Transfer värdelös.

Utföra autentiserade filbegäranden med bakgrundsöverföring

Background Transfer innehåller metoder som stöder grundläggande server- och proxyautentiseringsuppgifter, cookies och användning av anpassade HTTP-huvuden (via SetRequestHeader) för varje överföringsåtgärd.

Hur anpassas den här funktionen till ändringar i nätverksstatus eller oväntade avstängningar?

Funktionen Bakgrundsöverföring ger en konsekvent användarupplevelse för varje överföringsåtgärd när nätverksstatusen ändras, genom att intelligent utnyttja information om anslutningsstatus och operatörens dataplanstatus som tillhandahålls av funktionen Connectivity. För att definiera beteende för olika nätverksscenarier anger en app en kostnadsprincip för varje åtgärd med värden som definieras av BackgroundTransferCostPolicy.

Kostnadsprincipen som definierats för en åtgärd kan till exempel ange att åtgärden ska pausas automatiskt när enheten använder ett nätverk med datamängdsbegränsning. Överföringen återupptas sedan automatiskt (eller startas om) när en anslutning till ett "obegränsat" nätverk har upprättats. Mer information om hur nätverk definieras efter kostnad finns i NetworkCostType.

Funktionen Bakgrundsöverföring har egna mekanismer för att hantera ändringar i nätverksstatus, men det finns andra allmänna anslutningsöverväganden för nätverksanslutna appar. Läs Utnyttja tillgänglig information om nätverksanslutning för ytterligare information.

Observera För appar som körs på mobila enheter finns det funktioner som gör det möjligt för användaren att övervaka och begränsa mängden data som överförs baserat på typen av anslutning, roamingstatus och användarens dataplan. På grund av detta kan bakgrundsöverföringar pausas på telefonen även när BackgroundTransferCostPolicy anger att överföringen ska fortsätta.

Följande tabell anger när bakgrundsöverföringar tillåts på telefonen för varje BackgroundTransferCostPolicy-värde , med tanke på telefonens aktuella tillstånd. Du kan använda klassen ConnectionCost för att fastställa telefonens aktuella tillstånd.

Ladda upp filer

När du använder Bakgrundsöverföring finns en uppladdning som en UploadOperation som exponerar ett antal kontrollmetoder som används för att starta om eller avbryta åtgärden. Apphändelser (till exempel avstängning eller avslutning) och anslutningsändringar hanteras automatiskt av systemet per UploadOperation; uppladdningar fortsätter under appavstängningsperioder eller pausar och bevaras utöver appavslut. Dessutom anger du, om du ställer in egenskapen CostPolicy, om din app startar uppladdningar medan ett nätverk med datamätning används för Internetanslutning eller inte.

I följande exempel går vi igenom skapandet och initieringen av en grundläggande uppladdning och hur du räknar upp och återinför åtgärder som sparats från en tidigare appsession.

Ladda upp en enda fil

Skapandet av en uppladdning börjar med BackgroundUploader. Den här klassen används för att tillhandahålla de metoder som gör det möjligt för din app att konfigurera uppladdningen innan den resulterande UploadOperation skapas. I följande exempel visas hur du gör detta med nödvändiga URI- och StorageFile-objekt.

Identifiera filen och målet för uppladdningen

Innan vi kan börja med att skapa en UploadOperation måste vi först identifiera URI:n för platsen som ska laddas upp till och filen som ska laddas upp. I följande exempel fylls värdet uriString med hjälp av en sträng från UI-indata och filvärdet med hjälp av StorageFile-objektet som returneras av en PickSingleFileAsync-åtgärd .

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

Skapa och initiera uppladdningsåtgärden

I föregående steg skickas uriString - och filvärdena till en instans av nästa exempel, UploadOp, där de används för att konfigurera och starta den nya uppladdningsåtgärden. Först parsas uriString för att skapa det nödvändiga URI-objektet .

Därefter används egenskaperna för den angivna StorageFile (filen) av BackgroundUploader för att fylla i begärandehuvudet och ange egenskapen SourceFile med StorageFile-objektet . Metoden SetRequestHeader anropas sedan för att infoga filnamnet, som anges som en sträng, och egenskapen StorageFile.Name .

Slutligen skapar BackgroundUploaderUploadOperation (uppladdning).

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

Observera de asynkrona metodanrop som definierats med hjälp av JavaScript-promises. Titta på en rad från det senaste exemplet:

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

Anropet av asynkron metod följs av en then instruktion som anger metoder som definieras av appen och som anropas när ett resultat från asynkront metodanrop returneras. Mer information om det här programmeringsmönstret finns i Asynkron programmering i JavaScript med hjälp av löften.

Ladda upp flera filer

Identifiera filerna och målet för uppladdningen

I ett scenario med flera filer som överförs med en enda UploadOperation börjar processen som den brukar göra genom att först tillhandahålla nödvändig mål-URI och lokal filinformation. På samma sätt som i exemplet i föregående avsnitt tillhandahålls URI:n som en sträng av slutanvändaren och FileOpenPicker kan användas för att ge möjlighet att ange filer via användargränssnittet också. I det här scenariot bör appen dock i stället anropa metoden PickMultipleFilesAsync för att aktivera valet av flera filer via användargränssnittet.

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

Skapa objekt för de angivna parametrarna

I de följande två exemplen används kod som finns i en enda exempelmetod, startMultipart, som anropades i slutet av det sista steget. I instruktionssyfte har koden i metoden som skapar en matris med BackgroundTransferContentPart-objekt delats upp från koden som skapar den resulterande UploadOperation.

Först initieras URI-strängen som tillhandahålls av användaren som en URI. Därefter itereras matrisen med IStorageFile-objekt (filer) som skickas till den här metoden. Varje objekt används för att skapa ett nytt BackgroundTransferContentPart-objekt som sedan placeras i matrisen contentParts .

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

Skapa och initiera uppladdningsåtgärden i flera delar

Med vår contentParts-matris ifylld med alla BackgroundTransferContentPart-objekt som representerar varje IStorageFile för uppladdning är vi redo att anropa CreateUploadAsync med hjälp av URI:n för att ange var begäran ska skickas.

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

Starta om avbrutna uppladdningsåtgärder

När en UploadOperation har slutförts eller avbrutits släpps eventuella associerade systemresurser. Men om din app avslutas innan någon av dessa saker kan inträffa pausas alla aktiva åtgärder och resurserna som är associerade med var och en förblir upptagna. Om dessa åtgärder inte räknas upp och introduceras på nytt till nästa appsession slutförs de inte och fortsätter att uppta enhetsresurser.

1. Innan vi definierar den funktion som räknar upp beständiga åtgärder måste vi skapa en matris som innehåller UploadOperation-objekten som returneras:

   var uploadOperations = [];
   

2. Därefter definierar vi den funktion som räknar upp beständiga åtgärder och lagrar dem i vår matris. Observera att den inläsningsmetod som anropas för att återtilldela återanrop till UploadOperation, om den bevaras via appavslut, finns i klassen UploadOp som vi definierar senare i det här avsnittet.

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

Ladda ned filer

När du använder Bakgrundsöverföring finns varje nedladdning som en DownloadOperation som exponerar ett antal kontrollmetoder som används för att pausa, återuppta, starta om och avbryta åtgärden. Apphändelser (till exempel avstängning eller avslutning) och anslutningsändringar hanteras automatiskt av systemet per DownloadOperation; nedladdningar fortsätter under appavstängningsperioder eller pausar och bevaras utöver appavslut. För scenarier med mobilnätverk anger inställningen av egenskapen CostPolicy om din app ska påbörja eller fortsätta nedladdningar medan ett nätverk med dataförbrukning används för Internetanslutning.

Om du laddar ned små resurser som sannolikt kommer att slutföras snabbt bör du använda HttpClient-API :er i stället för bakgrundsöverföring.

I följande exempel går vi igenom skapande och initiering av en grundläggande nedladdning och hur du räknar upp och återinför åtgärder som sparats från en tidigare appsession.

Konfigurera och starta en nedladdning av en fil för bakgrundsöverföring

I följande exempel visas hur strängar som representerar en URI och ett filnamn kan användas för att skapa ett URI-objekt och den StorageFile som ska innehålla den begärda filen. I det här exemplet placeras den nya filen automatiskt på en fördefinierad plats. Alternativt kan FileSavePicker användas för att tillåta användare att ange var filen ska sparas på enheten. Observera att metoden load, som anropas för att omregistrera återanrop för DownloadOperation om den kvarstår efter att appen avslutas, finns i klassen DownloadOp, som definieras senare i det här avsnittet.

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

Observera de asynkrona metodanropen som definieras med hjälp av JavaScript-promises. Titta på rad 17 från föregående kodexempel:

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

Anropet av asynkron metod följs av en instruktion som anger metoder, definierade av appen, som anropas när ett resultat från asynkront metodanrop returneras. Mer information om det här programmeringsmönstret finns i Asynkron programmering i JavaScript med hjälp av löften.

Lägga till ytterligare metoder för åtgärdskontroll

Kontrollnivån kan ökas genom att implementera ytterligare DownloadOperation-metoder . Om du till exempel lägger till följande kod i exemplet ovan kan du avbryta nedladdningen.

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

Räkna upp beständiga åtgärder vid start

När en DownloadOperation har slutförts eller avbrutits släpps eventuella associerade systemresurser. Men om din app avslutas innan någon av dessa händelser inträffar pausas nedladdningarna och sparas i bakgrunden. Följande exempel visar hur du åter introducerar beständiga nedladdningar i en ny appsession.

1. Innan vi definierar funktionen som räknar upp beständiga åtgärder måste vi skapa en matris som innehåller DownloadOperation-objekten som returneras:

   var downloadOps = [];
   

2. Därefter definierar vi den funktion som räknar upp beständiga åtgärder och lagrar dem i vår matris. Observera att metoden load, som anropas för att tilldela återanrop på nytt för en beständig DownloadOperation, definieras i DownloadOp-exemplet senare i det här avsnittet.

   // 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. Du kan nu använda den ifyllda listan för att starta om väntande åtgärder.

Efterbearbetning

En ny funktion i Windows 10 är möjligheten att köra programkod när en bakgrundsöverföring har slutförts även när appen inte körs. Din app kanske till exempel vill uppdatera en lista över tillgängliga filmer när en film har laddats ned, i stället för att låta appen söka efter nya filmer varje gång den startas. Eller så kanske din app vill hantera en misslyckad filöverföring genom att försöka igen med en annan server eller port. Efterbearbetning anropas för både lyckade och misslyckade överföringar, så du kan använda den för att implementera anpassad felhantering och försöka logik igen.

Efterbearbetning använder den befintliga infrastrukturen för bakgrundsaktiviteter. Du skapar en bakgrundsaktivitet och associerar den med dina överföringar innan du startar överföringarna. Överföringarna körs sedan i bakgrunden och när de är klara anropas bakgrundsaktiviteten för att utföra efterbearbetning.

Efterbearbetningen använder en ny klass, BackgroundTransferCompletionGroup. Den här klassen liknar den befintliga BackgroundTransferGroup eftersom du kan gruppera bakgrundsöverföringar tillsammans, men BackgroundTransferCompletionGroup lägger till möjligheten att ange en bakgrundsaktivitet som ska köras när överföringen är klar.

Du initierar en bakgrundsöverföring med efterbearbetning enligt följande.

1. Skapa ett BackgroundTransferCompletionGroup-objekt . Skapa sedan ett BackgroundTaskBuilder-objekt . Ange egenskapen Trigger för builder-objektet till slutförandegruppobjektet och egenskapen TaskEntryPoint för byggaren till startpunkten för bakgrundsaktiviteten som ska köras när överföringen har slutförts. Anropa slutligen metoden BackgroundTaskBuilder.Register för att registrera bakgrundsaktiviteten. Observera att många slutförandegrupper kan dela en startpunkt för en bakgrundsaktivitet, men du kan bara ha en slutförandegrupp per registrering av bakgrundsaktivitet.

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

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

BackgroundTaskRegistration downloadProcessingTask = builder.Register();

2. Sedan associerar du bakgrundsöverföringar med slutförandegruppen. När alla överföringar har skapats aktiverar du slutförandegruppen.

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. Koden i bakgrundsaktiviteten extraherar listan över åtgärder från utlösarinformationen, och koden kan sedan granska informationen för varje åtgärd och utföra lämplig efterbearbetning för varje åtgärd.

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

Efterbearbetningsaktiviteten är en vanlig bakgrundsaktivitet. Den ingår i poolen med alla bakgrundsaktiviteter och omfattas av samma resurshanteringsprincip som alla bakgrundsaktiviteter.

Observera också att efterbearbetning inte ersätter slutförandehanterarna i förgrunden. Om din app definierar en förgrundsavslutshanterare och appen körs när filöverföringen är klar anropas både förgrundshanteraren och hanteraren för bakgrundsavslut. Den ordning i vilken förgrunds- och bakgrundsaktiviteter anropas garanteras inte. Om du definierar båda bör du se till att de två uppgifterna fungerar korrekt och inte stör varandra om de körs samtidigt.

Tidsgränser för begäranden

Det finns två huvudsakliga scenarier för tidsgränser för anslutningar att beakta:

• När du upprättar en ny anslutning för en överföring avbryts anslutningsbegäran om den inte upprättas inom fem minuter.

• När en anslutning har upprättats avbryts ett HTTP-begärandemeddelande som inte har tagit emot ett svar inom två minuter.

Observera I båda scenariot, förutsatt att det finns Internetanslutning, försöker Background Transfer igen en begäran upp till tre gånger automatiskt. Om Internetanslutningen inte identifieras väntar ytterligare begäranden tills den är det.

Felsökningsvägledning

Att stoppa en felsökningssession i Microsoft Visual Studio kan jämföras med att stänga appen. PUT-uppladdningar pausas och POST-uppladdningar avslutas. Även vid felsökning bör appen räkna upp och sedan starta om eller avbryta eventuella kvarstående uppladdningar. Du kan till exempel låta appen avbryta uppräknade kvarstående uppladdningsåtgärder vid appstart om det inte finns något intresse för tidigare åtgärder för felsökningssessionen.

När du räknar upp nedladdningar/uppladdningar vid appstart under en felsökningssession kan du låta appen avbryta dem om det inte finns något intresse för tidigare åtgärder för felsökningssessionen. Observera att om det finns Visual Studio projektuppdateringar, till exempel ändringar i appmanifestet, och appen avinstalleras och distribueras igen, kan GetCurrentUploadsAsync inte räkna upp åtgärder som skapats med hjälp av den tidigare appdistributionen.

När du använder Bakgrundsöverföring under utveckling kan du hamna i en situation där de interna cacheminnena för aktiva och slutförda överföringsåtgärder kan bli osynkroniserade. Detta kan leda till att det inte går att starta nya överföringsåtgärder eller interagera med befintliga åtgärder och BackgroundTransferGroup-objekt . I vissa fall kan försök att interagera med befintliga åtgärder utlösa en krasch. Det här resultatet kan inträffa om egenskapen TransferBehavior är inställd på Parallell. Det här problemet uppstår endast i vissa scenarier under utvecklingen och gäller inte för slutanvändare av din app.

Fyra scenarier med Visual Studio kan orsaka det här problemet.

• Du skapar ett nytt projekt med samma appnamn som ett befintligt projekt, men ett annat språk (från C++ till C#, till exempel).
• Du ändrar målarkitekturen (från till exempel x86 till x64) i ett befintligt projekt.
• Du ändrar kulturen (från neutral till en-US, till exempel) i ett befintligt projekt.
• Du lägger till eller tar bort en funktion i paketmanifestet (t.ex. enterprise-autentisering) i ett befintligt projekt.

Regelbunden appservice, inklusive manifestuppdateringar som lägger till eller tar bort funktioner, utlöser inte det här problemet vid slutanvändardistributioner av din app. Du kan lösa det här problemet genom att helt avinstallera alla versioner av appen och distribuera om med det nya språket, arkitekturen, kulturen eller funktionen. Detta kan göras via startskärmen eller med hjälp av PowerShell och cmdleten Remove-AppxPackage .

Undantag i Windows.Networking.BackgroundTransfer

Ett undantag utlöses när en ogiltig sträng för en URI (Uniform Resource Identifier) skickas till konstruktorn för Windows. Foundation.Uri-objekt.

.NET: Typen Windows.Foundation.Uri visas som System.Uri i C# och VB.

I C# och Visual Basic kan du undvika det här felet genom att använda klassen System.Uri i .NET 4.5 och någon av metoderna System.Uri.TryCreate för att testa strängen som tas emot från appanvändaren innan URI:n konstrueras.

I C++ finns det ingen metod för att försöka parsa en sträng till en URI. Om en app får indata från användaren för Windows. Foundation.Uri, konstruktorn ska vara i ett try/catch-block. Om ett undantag utlöses kan appen meddela användaren och begära ett nytt värdnamn.

Windows. Networking.backgroundTransfer-namnområdet har praktiska hjälpmetoder och använder uppräkningar i Windows. Networking.Sockets-namnrymd för hantering av fel. Detta kan vara användbart för att hantera specifika nätverksfel på olika sätt i din app.

Ett fel påträffades på en asynkron metod i Windows. Networking.backgroundTransfer-namnområdet returneras som ett HRESULT-värde. Metoden BackgroundTransferError.GetStatus används för att konvertera ett nätverksfel från en bakgrundsöverföring till ett WebErrorStatus-uppräkningsvärde . De flesta av WebErrorStatus-uppräkningsvärdena motsvarar ett fel som returneras av den interna HTTP- eller FTP-klientåtgärden. En app kan filtrera efter specifika WebErrorStatus-uppräkningsvärden för att ändra appbeteendet beroende på orsaken till undantaget.

För parameterverifieringsfel kan en app också använda HRESULT från undantaget för att lära sig mer detaljerad information om felet som orsakade undantaget. Möjliga HRESULT-värden visas i winerror.h-huvudfilen . Vid de flesta fel vid parametervalidering returneras HRESULT-värdet E_INVALIDARG.

Viktiga API:er

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