Háttérben történő átvitelek

A háttérátviteli API használatával megbízhatóan másolhat fájlokat a hálózaton keresztül. A háttérátviteli API fejlett feltöltési és letöltési funkciókat biztosít, amelyek az alkalmazás felfüggesztése során futnak a háttérben, és az alkalmazás leállása után is megmaradnak. Az API figyeli a hálózati állapotot, és automatikusan felfüggeszti és folytatja az átvitelt, amikor megszakad a kapcsolat, és az átvitel adatérzékkel és akkumulátorérzékkel is rendelkezik, ami azt jelenti, hogy a letöltési tevékenység az aktuális kapcsolat és az eszköz akkumulátorának állapota alapján módosul. Az API ideális nagy fájlok HTTP(s) használatával történő feltöltéséhez és letöltéséhez. Az FTP is támogatott, de csak letöltésekhez.

Note

Az Windows.Networking.BackgroundTransfer API-k Windows-futtatókörnyezet (WinRT) API-k, amelyek a WinUI 3 (Windows App SDK) asztali alkalmazásokban és az UWP-alkalmazásokban működnek. A háttérátvitelekhez csomagazonosításra van szükség; A csomagolatlan alkalmazások nem tudják használni ezt az API-t.

A háttérátvitel a hívó alkalmazástól külön fut, és elsősorban olyan erőforrások hosszú távú átvitelére szolgál, mint a videó, a zene és a nagyméretű képek. Ezekben a forgatókönyvekben a Háttérátvitel használata elengedhetetlen, mivel a letöltések akkor is folytatódnak, ha az alkalmazás fel van függesztve.

Ha olyan kis erőforrásokat tölt le, amelyek valószínűleg gyorsan befejeződnek, a Háttérátvitel helyett HttpClient API-kat kell használnia.

A Windows.Networking.BackgroundTransfer használata

Hogyan működik a Háttérátvitel funkció?

Amikor egy alkalmazás háttérátvitelt használ az átvitel indításához, a kérés a BackgroundDownloader vagy a BackgroundUploader osztályobjektumokkal van konfigurálva és inicializálva. Minden átviteli műveletet külön kezel a rendszer, és elkülöníti a hívó alkalmazástól. A folyamatinformációk akkor érhetők el, ha állapotot szeretne adni a felhasználónak az alkalmazás felhasználói felületén, és az alkalmazás szüneteltetheti, folytathatja, megszakíthatja vagy akár beolvashatja az adatokat az átvitel során. Az átvitelek rendszer általi kezelésének módja elősegíti az intelligens energiahasználatot, és megakadályozza azokat a problémákat, amelyek akkor merülhetnek fel, amikor egy csatlakoztatott alkalmazás olyan eseményeket tapasztal, mint az alkalmazás felfüggesztése, leállítása vagy a hálózati állapot hirtelen változása.

Note

Az alkalmazásonkénti erőforráskorlátok miatt egy alkalmazásnak egy adott időpontban nem szabad 200-nál több átvitelt (DownloadOperations + UploadOperations) használnia. Ha túllépi ezt a korlátot, az alkalmazás átviteli üzenetsorát helyreállíthatatlan állapotban hagyhatja.

Amikor egy alkalmazás elindul, az AttachAsync-et kell meghívnia az összes meglévő DownloadOperation és UploadOperation objektumon. Ha ezt nem teszi meg, az a már befejezett átvitelek kiszivárgását okozza, és végül használhatatlanná teszi a Háttérátvitel funkció használatát.

Hitelesített fájlkérelmek végrehajtása háttérátvitellel

A háttérátvitel olyan módszereket biztosít, amelyek támogatják az alapszintű kiszolgáló- és proxy-hitelesítő adatokat, a cookie-kat, valamint az egyéni HTTP-fejlécek használatát ( a SetRequestHeader használatával) az egyes átviteli műveletekhez.

Hogyan alkalmazkodik ez a funkció a hálózati állapot változásaihoz vagy váratlan leállásokhoz?

A Háttérátvitel funkció konzisztens felhasználói élményt biztosít minden átviteli művelethez a hálózati állapotváltozások esetén a kapcsolati és a szolgáltatói adattervek kapcsolati funkció által biztosított állapotadatainak intelligens felhasználásával. A különböző hálózati forgatókönyvek viselkedésének meghatározásához az alkalmazás minden művelethez beállít egy költségszabályzatot a BackgroundTransferCostPolicy által meghatározott értékek használatával.

A művelethez definiált költségszabályzat például azt jelezheti, hogy a műveletet automatikusan fel kell függeszteni, amikor az eszköz forgalmi díjas hálózatot használ. Az átvitel ezután automatikusan folytatódik (vagy újraindul), ha egy "korlátlan" hálózathoz létesített kapcsolat létrejött. A hálózatok költség szerinti definiálásáról további információt a NetworkCostType című témakörben talál.

Bár a háttérátviteli szolgáltatás saját mechanizmusokkal rendelkezik a hálózati állapotváltozások kezelésére, a hálózathoz csatlakoztatott alkalmazások esetében más általános csatlakozási szempontok is vannak. Használja a Windows. Networking.Connectivity API-k a kapcsolat állapotának és költségadatainak figyeléséhez.

Note

Mobileszközökön futó alkalmazások esetén vannak olyan funkciók, amelyek lehetővé teszik a felhasználó számára, hogy a kapcsolat típusa, a roaming állapota és a felhasználó adatcsomagja alapján monitorozza és korlátozza az átvitt adatok mennyiségét. Emiatt a háttérátvitelek akkor is szüneteltethetők a telefonon, ha a BackgroundTransferCostPolicy azt jelzi, hogy az átvitelnek folytatódnia kell.

Az alábbi táblázat azt jelzi, hogy mikor engedélyezett a háttérátvitel a telefonon az egyes BackgroundTransferCostPolicy értékekhez a telefon aktuális állapotának függvényében. A ConnectionCost osztály használatával meghatározhatja a telefon aktuális állapotát.

Eszköz állapota KorlátlanUl Default Mindig
Wi-Fi-hez csatlakoztatva Allow Allow Allow
Forgalomkorlátos kapcsolat, nem barangol, adatkorlát alatt, várhatóan a korlát alatt marad Deny Allow Allow
Forgalomkorlátos kapcsolat, nem barangolási hálózaton, az adatkorláton belül, várhatóan túllépi a korlátot Deny Deny Allow
Forgalmi díjas kapcsolat, roaming, adatkorlát alatt Deny Deny Allow
Forgalomkorlátos kapcsolat, adatforgalmi korlát felett. Ez az állapot csak akkor fordul elő, ha a felhasználó engedélyezi a "Háttéradatok korlátozása az Adatérzék felhasználói felületén. Deny Deny Deny

Fájlok feltöltése

A háttérátvitel használatakor a feltöltés feltöltési műveletként létezik, amely számos, a művelet újraindításához vagy megszakításához használt vezérlési módszert tesz elérhetővé. Az alkalmazáseseményeket (például felfüggesztést vagy leállítást) és a kapcsolat változásait a rendszer automatikusan kezeli UploadOperation-ként; a feltöltések az alkalmazás felfüggesztési időszakában folytatódnak, vagy az alkalmazás leállítása után is megmaradnak. A CostPolicy tulajdonság beállítása azt is jelzi, hogy az alkalmazás megkezdi-e a feltöltéseket, miközben forgalmi díjas hálózatot használ az internetkapcsolathoz.

Az alábbi példák végigvezetik egy alapszintű feltöltés létrehozásán és inicializálásán, valamint az előző alkalmazás munkamenetből származó műveletek számbavételének és újbóli bevezetésének módján.

Egyetlen fájl feltöltése

A feltöltés létrehozása a BackgroundUploaderrel kezdődik. Ez az osztály biztosítja azokat a metódusokat, amelyekkel az alkalmazás konfigurálhatja a feltöltést az eredményül kapott UploadOperation létrehozása előtt. Az alábbi példa bemutatja, hogyan teheti ezt meg a szükséges Uri - és StorageFile-objektumokkal .

A feltöltéshez használt fájl és cél azonosítása

Mielőtt elkezdhetnénk az UploadOperation létrehozását, először azonosítani kell a feltölteni kívánt hely URI-ját és a feltöltendő fájlt. Az alábbi példában az uriString értéket egy felhasználói felületi bemenetből származó sztringgel tölti ki a rendszer, a fájl értékét pedig a PickSingleFileAsync művelet által visszaadott StorageFile objektummal.

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

A feltöltési művelet létrehozása és inicializálása

Az előző lépésben az uriString és a fájlértékek a következő példa, az UploadOp egy példányának lesznek átadva, ahol az új feltöltési művelet konfigurálásához és elindításához használhatók. Először az uriString a szükséges Uri-objektum létrehozásához lesz elemezve.

Ezután a BackgroundUploader a megadott StorageFile (fájl) tulajdonságait használja a kérelem fejlécének feltöltéséhez és a SourceFile tulajdonság StorageFile objektummal való beállításához. Ezután a SetRequestHeader metódus meghívásával beszúrhatja a sztringként megadott fájlnevet és a StorageFile.Name tulajdonságot.

Végül a BackgroundUploader létrehozza az UploadOperation (feltöltés) elemet.

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

Figyelje meg a JavaScript-ígéretekkel definiált aszinkron metódushívásokat. Az utolsó példa sorát tekintve:

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

Az aszinkron metódushívást egy then utasítás követi, amely az alkalmazás által definiált metódusokat jelzi, amelyeket az aszinkron metódushívás eredményének visszaadásakor hívunk meg. További információ erről a programozási mintáról: Aszinkron programozás JavaScriptben ígéretek használatával.

Több fájl feltöltése

A feltöltéshez szükséges fájlok és célhely azonosítása

Az egyetlen UploadOperation használatával átvitt több fájlt tartalmazó forgatókönyvben a folyamat úgy kezdődik, ahogy általában, először meg kell adnia a cél URI-t és a helyi fájladatokat. Az előző szakaszban bemutatott példához hasonlóan az URI-t a végfelhasználó sztringként biztosítja, a FileOpenPicker pedig lehetővé teszi a fájlok felhasználói felületen keresztüli jelzését is. Ebben a forgatókönyvben azonban az alkalmazásnak inkább a PickMultipleFilesAsync metódust kell meghívnia, hogy lehetővé tegye több fájl kiválasztását a felhasználói felületen keresztül.

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

Objektumok létrehozása a megadott paraméterekhez

A következő két példa a startMultipart nevű egyetlen példametódusban található kódot használja, amelyet az utolsó lépés végén hívtak meg. Szemléltetés céljából a BackgroundTransferContentPart objektumokból álló tömböt létrehozó metódusban lévő kódot különválasztottuk attól a kódtól, amely a létrejövő UploadOperationt hozza létre.

Először a felhasználó által megadott URI-sztring inicializálva lesz URI-ként. Ezután végigiterálnak a metódusnak átadott IStorageFile objektumokból álló (files) tömbön, és minden objektum felhasználásával létrehoznak egy új BackgroundTransferContentPart objektumot, amelyet ezután a contentParts tömbbe helyeznek.

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

A többrészes feltöltési művelet létrehozása és inicializálása

Mivel a contentParts-tömb az összes, feltöltésre szánt IStorageFile-t képviselő BackgroundTransferContentPart objektummal van feltöltve, készen állunk a CreateUploadAsync meghívására az Uri használatával, hogy jelezzük a kérés elküldésének helyét.

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

Megszakított feltöltési műveletek újraindítása

Az UploadOperation befejezésekor vagy lemondásakor a rendszer minden társított erőforrást felszabadít. Ha azonban az alkalmazás a fenti műveletek bármelyike előtt leáll, az aktív műveletek szüneteltetve lesznek, és az egyes erőforrások foglaltak maradnak. Ha ezeket a műveleteket nem számba veszi, és a következő alkalmazás-munkamenetben újra bevezeti őket, azok nem fejeződnek be, és továbbra is lefoglalják az eszközerőforrásokat.

  1. A tartós műveleteket számba adó függvény definiálása előtt létre kell hoznunk egy tömböt, amely tartalmazza a visszaadott UploadOperation-objektumokat :

    var uploadOperations = [];

  2. Ezután definiáljuk a függvényt, amely számba vegye a tárolt műveleteket, és tárolja őket a tömbünkben. Vegye figyelembe, hogy a callbackek UploadOperation objektumhoz való újbóli hozzárendelésére meghívott load metódus — ha az alkalmazás leállítása után is megmarad — az ebben a szakaszban később definiált UploadOp osztályban található.

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

Fájlok letöltése

A háttérátvitel használatakor minden letöltés letöltési műveletként létezik, amely számos, a művelet szüneteltetéséhez, folytatásához, újraindításához és megszakításához használt vezérlőmetszetet tesz elérhetővé. Az alkalmazáseseményeket (például felfüggesztést vagy leállítást) és a kapcsolat változásait a rendszer automatikusan kezeli a Letöltésműveletenként; a letöltések az alkalmazás felfüggesztési időszakában folytatódnak, vagy az alkalmazás leállítása után is szünetelnek és megmaradnak. Mobilhálózati forgatókönyvek esetén a CostPolicy tulajdonság beállítása azt jelzi, hogy az alkalmazás megkezdi vagy folytatja-e a letöltéseket, miközben forgalmi díjas hálózatot használ az internetkapcsolathoz.

Ha olyan kis erőforrásokat tölt le, amelyek valószínűleg gyorsan befejeződnek, a Háttérátvitel helyett HttpClient API-kat kell használnia.

Az alábbi példák végigvezetik az alapszintű letöltések létrehozásán és inicializálásán, valamint az előző alkalmazás munkamenetből származó műveletek számbavételének és újbóli bevezetésének módján.

Háttérátviteli fájl letöltésének konfigurálása és indítása

Az alábbi példa bemutatja, hogyan használhatók az URI-t és a fájlnevet képviselő sztringek egy Uri-objektum és a kért fájlt tartalmazó StorageFile létrehozásához. Ebben a példában az új fájl automatikusan egy előre meghatározott helyre kerül. Másik lehetőségként a FileSavePicker használatával a felhasználók jelezhetik, hogy hová kell menteni a fájlt az eszközön. Vegye figyelembe, hogy a visszahívási függvények DownloadOperation objektumhoz való újbóli hozzárendelésére szolgáló, load nevű metódus — ha az alkalmazás leállítása után is fennmarad — az ebben a szakaszban később definiált DownloadOp osztályban található.

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

Figyelje meg a JavaScript-ígéretekkel definiált aszinkron metódushívásokat. Az előző példakód 17. sorát tekintve:

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

Az aszinkron metódushívást egy akkori utasítás követi, amely az alkalmazás által definiált metódusokat jelzi, amelyeket az aszinkron metódushívás eredményének visszaadásakor hívunk meg. További információ erről a programozási mintáról: Aszinkron programozás JavaScriptben ígéretek használatával.

További műveletvezérlési módszerek hozzáadása

Az ellenőrzés szintje további DownloadOperation-módszerek alkalmazásával növelhető. Ha például hozzáadja a következő kódot a fenti példához, lehetővé válik a letöltés megszakítása.

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

A megőrzött műveletek számbavétele az indításkor

A DownloadOperation befejezésekor vagy lemondásakor a rendszer minden társított erőforrást felszabadít. Ha azonban az alkalmazás leáll, mielőtt bármelyik esemény bekövetkezne, a letöltések szünetelnek, és a háttérben maradnak. Az alábbi példák bemutatják, hogyan lehet újra bevezetni a tartós letöltéseket egy új alkalmazás-munkamenetbe.

  1. A tartós műveleteket számba adó függvény definiálása előtt létre kell hoznunk egy tömböt, amely tartalmazza a visszaadott DownloadOperation-objektumokat :

    var downloadOps = [];

  2. Ezután definiáljuk a függvényt, amely számba vegye a tárolt műveleteket, és tárolja őket a tömbünkben. Vegye figyelembe, hogy a perzisztált DownloadOperation visszahívásainak újbóli hozzárendelésére szolgáló load metódust az ebben a szakaszban később definiált DownloadOp példában definiáljuk.

    // 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. Most már a feltöltött listával újraindíthatja a függőben lévő műveleteket.

Utófeldolgozás

A Windows 10 új funkciója az alkalmazáskód futtatásának lehetősége a háttérátvitel befejezésekor még akkor is, ha az alkalmazás nem fut. Előfordulhat például, hogy az alkalmazás frissíteni szeretné az elérhető filmek listáját a film letöltése után, ahelyett, hogy az alkalmazás minden indításkor új filmeket keresne. Vagy előfordulhat, hogy az alkalmazás egy másik kiszolgálóval vagy porttal próbálkozva szeretné kezelni a sikertelen fájlátvitelt. A rendszer meghívja az utófeldolgozást a sikeres és a sikertelen átvitelekhez is, így egyéni hibakezelési és újrapróbálkozásos logika implementálható vele.

A postprocessing a meglévő háttérfeladat-infrastruktúrát használja. Az átvitelek megkezdése előtt létre kell hoznia egy háttérfeladatot, és társítania kell azt az átvitelekkel. Az átvitelek ezután a háttérben lesznek végrehajtva, és amikor befejeződnek, a rendszer meghívja a háttérfeladatot az utófeldolgozás végrehajtására.

A feldolgozás utáni feldolgozás egy új osztályt, a BackgroundTransferCompletionGroup-ot használja. Ez az osztály hasonló a meglévő BackgroundTransferGroup osztályhoz, mivel lehetővé teszi a háttérátvitelek csoportosítását, de a BackgroundTransferCompletionGroup lehetővé teszi, hogy kijelöljön egy háttérfeladatot, amelyet az átvitel befejezésekor futtatni szeretne.

A háttérátvitelt utófeldolgozással a következőképpen kezdeményezheti.

  1. Hozzon létre egy BackgroundTransferCompletionGroup objektumot. Ezután hozzon létre egy BackgroundTaskBuilder objektumot. Állítsa a szerkesztőobjektum Trigger tulajdonságát a befejezési csoport objektumára, a szerkesztő TaskEntryPoint tulajdonságát pedig annak a háttérfeladatnak a belépési pontjára, amelyet az átvitel befejezésekor végre kell hajtani. Végül hívja meg a BackgroundTaskBuilder.Register metódust a háttérfeladat regisztrálásához. Vegye figyelembe, hogy több befejezési csoport is használhatja ugyanazt a háttérfeladat belépési pontját, azonban háttérfeladat-regisztrációnként csak egy befejezési csoport adható meg.
var completionGroup = new BackgroundTransferCompletionGroup();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();

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

BackgroundTaskRegistration downloadProcessingTask = builder.Register();
  1. Ezután a háttérátviteleket a befejezési csoporttal társítja. Az összes átvitel létrehozása után engedélyezze a befejezési csoportot.
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();
  1. A háttérfeladatban lévő kód kinyeri a műveletek listáját az eseményindító részleteiből, és a kód ezután megvizsgálhatja az egyes műveletek részleteit, és elvégezheti az egyes műveletek megfelelő utófeldolgozását.
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
    }
}

Az utófeldolgozási tevékenység egy normál háttérfeladat. Ez az összes háttérfeladat készletének része, és ugyanaz az erőforrás-kezelési szabályzat vonatkozik rá, mint az összes háttérfeladatra.

Azt is vegye figyelembe, hogy az utófeldolgozás nem helyettesíti az előtérkiegészítés-kezelőket. Ha az alkalmazás előtér-befejezési kezelőt határoz meg, és az alkalmazás a fájlátvitel befejezésekor fut, akkor a rendszer meghívja az előtérben lévő befejezési kezelőt és a háttérkiegészítés-kezelőt is. Az előtér- és háttérfeladatok meghívásának sorrendje nem garantált. Ha mindkettőt definiálja, győződjön meg arról, hogy a két tevékenység megfelelően működik, és nem zavarja egymást, ha párhuzamosan futnak.

Kérelem időtúllépései

Két elsődleges kapcsolat időtúllépési forgatókönyvet kell figyelembe venni:

  • Ha új kapcsolatot hoz létre egy átvitelhez, a kapcsolatkérés megszakad, ha öt percen belül nem jön létre.

  • A kapcsolat létrejötte után a rendszer megszakítja azt a HTTP-kérési üzenetet, amely két percen belül nem kapott választ.

Megjegyzés Mindkét esetben, feltételezve, hogy van internetkapcsolat, a háttérátvitel automatikusan háromszor újrapróbálkozza a kérést. Ha a rendszer nem észlel internetkapcsolatot, a további kérések addig várakoznak, amíg azt nem észleli.

Hibakeresési útmutató

A hibakeresési munkamenet leállítása Microsoft Visual Studio hasonló az alkalmazás bezárásához; A PUT feltöltések szüneteltetve vannak, és a POST feltöltések leállnak. A hibakeresés során is az alkalmazásnak számba kell helyeznie, majd újra kell indítania vagy le kell mondania az esetlegesen megmaradó feltöltéseket. Előfordulhat például, hogy az alkalmazás megszakítja a számbavételes, tartós feltöltési műveleteket az alkalmazás indításakor, ha nem érdeklik a hibakeresési munkamenet korábbi műveletei.

Miközben egy hibakeresési munkamenet során az alkalmazás indításakor a letöltések/feltöltések számbavétele folyamatban van, az alkalmazás megszakíthatja őket, ha a hibakeresési munkamenet korábbi műveletei nem érdeklik. Vegye figyelembe, hogy ha Visual Studio projektfrissítések, például az alkalmazásjegyzék módosításai, és az alkalmazás eltávolítása és újratelepítése történik, a GetCurrentUploadsAsync nem tudja számba venni az előző alkalmazástelepítéssel létrehozott műveleteket.

Ha a fejlesztés során háttérátvitelt használ, előfordulhat, hogy az aktív és befejezett átviteli műveletek belső gyorsítótárai nem lesznek szinkronizálva. Ez azt eredményezheti, hogy nem lehet új átviteli műveleteket elindítani, vagy nem lehet kezelni a meglévő műveleteket és a BackgroundTransferGroup objektumokat. Bizonyos esetekben a meglévő műveletekkel való interakció megkísérlése összeomlást okozhat. Ez az eredmény akkor fordulhat elő, ha a TransferBehavior tulajdonság párhuzamos értékre van állítva. Ez a probléma csak bizonyos esetekben fordul elő a fejlesztés során, és nem alkalmazható az alkalmazás végfelhasználóira.

A Visual Studio használó négy forgatókönyv okozhatja ezt a problémát.

  • Hozzon létre egy új projektet ugyanazzal az alkalmazásnévvel, mint egy meglévő projekt, de egy másik nyelvet (például C++-tól C#-ra).
  • Egy meglévő projekt célarchitektúráját (például x86-ról x64-re) módosíthatja.
  • A kultúrát (például a semlegesről a en-US) egy meglévő projektben módosíthatja.
  • Hozzáadhat vagy eltávolíthat egy képességet a csomagjegyzékben (például vállalati hitelesítés hozzáadása) egy meglévő projektben.

A rendszeres alkalmazás-karbantartás, beleértve a képességeket hozzáadó vagy eltávolító manifesztumfrissítéseket is, nem váltja ki ezt a problémát az alkalmazás végfelhasználói telepítéseiben. A probléma megoldásához távolítsa el teljesen az alkalmazás összes verzióját, és telepítse újra az új nyelv, architektúra, kultúra vagy képesség használatával. Ezt a kezdőképernyőn vagy a PowerShell és a Remove-AppxPackage parancsmag használatával teheti meg.

A Windows.Networking.BackgroundTransfer kivételei

A rendszer kivételt ad, ha érvénytelen egységes erőforrás-azonosító (URI) karakterláncot adnak át a Windows.Foundation.Uri objektum konstruktorának.

.NET: A Windows. A Foundation.Uri típus System.Uri formátumban jelenik meg c# és VB nyelven.

C# és Visual Basic esetén ez a hiba elkerülhető a System.Uri osztály használatával a .NET 4.5-ös és a System.Uri.TryCreate metódusok egyikével, hogy tesztelje az alkalmazás felhasználójától kapott sztringet az URI létrehozása előtt.

A C++-ban nincs olyan metódus, amellyel meg lehetne próbálni egy karakterláncot URI-ként értelmezni. Ha egy alkalmazás a felhasználótól kapott bemenetet használja a Windows.Foundation.Uri számára, a konstruktort try/catch blokkba kell helyezni. Kivétel esetén az alkalmazás értesítheti a felhasználót, és új állomásnevet kérhet.

A Windows.Networking.backgroundTransfer névtér hasznos segédmetódusokat tartalmaz, és a hibák kezeléséhez a Windows.Networking.Sockets névtérben található felsorolásokat használja. Ez hasznos lehet az alkalmazás bizonyos hálózati kivételeinek eltérő kezelésére.

A Windows.Networking.backgroundTransfer névtér egy aszinkron metódusában fellépő hiba HRESULT értékként kerül visszaadásra. A BackgroundTransferError.GetStatus metódussal hálózati hibát konvertálhat háttérátviteli műveletből WebErrorStatus enumerálási értékké. A WebErrorStatus enumerálási értékeinek többsége a natív HTTP- vagy FTP-ügyfélművelet által visszaadott hibának felel meg. Az alkalmazások szűrhetnek bizonyos WebErrorStatus enumerálási értékekre, hogy a kivétel okától függően módosíthassák az alkalmazás viselkedését.

Paraméterérvényesítési hibák esetén az alkalmazás a kivételből származó HRESULT használatával is részletesebb információkat tudhat meg a kivételt okozó hibáról. A lehetséges HRESULT értékek a Winerror.h fejlécfájlban vannak felsorolva. A legtöbb paraméterérvényesítési hiba esetén a visszaadott HRESULT értéke E_INVALIDARG.

Fontos API-k

  • Last updated on