Transferências em segundo plano

Usa a API de transferência em segundo plano para copiar ficheiros de forma fiável pela rede. A API de transferência em segundo plano oferece funcionalidades avançadas de upload e download que correm em segundo plano durante a suspensão da aplicação e persistem para além da terminação da aplicação. A API monitoriza o estado da rede e suspende e retoma automaticamente as transferências quando a conectividade é perdida. Além disso, as transferências são compatíveis com Data Sense e Bateria Sense, o que significa que a atividade de download se ajusta com base na sua conectividade atual e no estado da bateria do dispositivo. A API é ideal para carregar e descarregar ficheiros grandes usando HTTP(S). FTP também é suportado, mas apenas para downloads.

A Transferência em Segundo Plano funciona separadamente da aplicação de chamada e é principalmente concebida para operações de transferência a longo prazo para recursos como vídeo, música e imagens grandes. Nestes cenários, usar a Transferência em Segundo Plano é essencial porque os downloads continuam a progredir mesmo quando a aplicação está suspensa.

Se estiver a descarregar pequenos recursos cuja transferência provavelmente será concluída rapidamente, deve usar as APIs de HttpClient em vez da Transferência em Segundo Plano.

Utilizar Windows.Networking.BackgroundTransfer

Como funciona a funcionalidade de Transferência de Antecedentes?

Quando uma aplicação utiliza Transferência em Segundo plano para iniciar uma transferência, o pedido é configurado e inicializado usando objetos de classe BackgroundDownloader ou BackgroundUploader . Cada operação de transferência é tratada individualmente pelo sistema e separada da aplicação de chamada. A informação de progresso está disponível se quiser dar estado ao utilizador na interface da sua aplicação, e a aplicação pode pausar, retomar, cancelar ou até ler os dados enquanto a transferência está a decorrer. A forma como as transferências são geridas pelo sistema promove um consumo inteligente de energia e previne problemas que podem surgir quando uma aplicação ligada enfrenta eventos como suspensão da aplicação, terminação ou alterações súbitas no estado da rede.

Quando uma aplicação é lançada, deve chamar AttachAsync em todos os objetos DownloadOperation e UploadOperation existentes. Não fazer isto causará o vazamento de transferências já concluídas e, eventualmente, tornará inútil o uso da funcionalidade de Transferência em Segundo Plano.

Efetuar pedidos autenticados de ficheiros com transferência em segundo plano

A Transferência em Segundo Plano fornece métodos que suportam credenciais básicas de servidor e proxy, cookies e a utilização de cabeçalhos HTTP personalizados (via SetRequestHeader) para cada operação de transferência.

Como é que esta funcionalidade se adapta a alterações no estado da rede ou a desligamentos inesperados?

A funcionalidade de Transferência em Segundo Plano mantém uma experiência consistente para cada operação de transferência quando ocorrem alterações no estado da rede, aproveitando de forma inteligente a conectividade e a informação de estado do plano de dados do operador fornecida pela funcionalidade de Conectividade . Para definir comportamento para diferentes cenários de rede, uma aplicação define uma política de custos para cada operação usando valores definidos pelo BackgroundTransferCostPolicy.

Por exemplo, a política de custos definida para uma operação pode indicar que a operação deve ser pausada automaticamente quando o dispositivo utiliza uma rede medida. A transferência é então automaticamente retomada (ou reiniciada) quando uma ligação a uma rede "irrestrita" é estabelecida. Para mais informações sobre como as redes são definidas pelo custo, consulte NetworkCostType.

Embora a funcionalidade de Transferência em Segundo Plano tenha os seus próprios mecanismos para lidar com alterações de estado da rede, existem outras considerações gerais de conectividade para aplicações ligadas à rede. Leia Utilização das informações disponíveis sobre a ligação de rede para obter mais informações.

Nota Para aplicações a correr em dispositivos móveis, existem funcionalidades que permitem ao utilizador monitorizar e restringir a quantidade de dados transferidos com base no tipo de ligação, estado de roaming e plano de dados do utilizador. Por causa disso, as transferências em segundo plano podem ser pausadas ao telefone mesmo quando o BackgroundTransferCostPolicy indica que a transferência deve avançar.

A tabela seguinte indica quando transferências em segundo plano são permitidas no telemóvel para cada valor da BackgroundTransferCostPolicy , dado o estado atual do telefone. Pode usar a classe ConnectionCost para determinar o estado atual do telemóvel.

Upload de arquivos

Ao usar a Transferência em Segundo Plano, um carregamento é representado por uma UploadOperation que expõe vários métodos de controlo para reiniciar ou cancelar a operação. Os eventos da aplicação (por exemplo, suspensão ou terminação) e as alterações de conectividade são tratados automaticamente pelo sistema para cada UploadOperation; os carregamentos continuarão durante os períodos de suspensão da aplicação ou serão colocados em pausa e persistirão após a terminação da aplicação. Além disso, definir a propriedade CustPolicy indicará se a sua aplicação começará a carregar enquanto uma rede com medição estiver a ser usada para a conectividade à Internet.

Os exemplos seguintes irão guiá-lo pela criação e inicialização de um carregamento básico e por como enumerar e reintroduzir operações que persistiram de uma sessão anterior da aplicação.

Carregar um único ficheiro

A criação de um upload começa com o BackgroundUploader. Esta classe é usada para fornecer os métodos que permitem à sua aplicação configurar o upload antes de criar o UploadOperation resultante. O exemplo seguinte mostra como fazer isto com os objetos Uri e StorageFile necessários.

Identifique o ficheiro e o destino para o upload

Antes de podermos começar com a criação de um UploadOperation, precisamos primeiro de identificar o URI da localização para onde fazer upload e o ficheiro que será carregado. No exemplo seguinte, o valor uriString é preenchido usando uma string da entrada UI, e o valor do ficheiro usando o objeto StorageFile é devolvido por uma operação PickSingleFileAsync .

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

Criar e inicializar a operação de upload

No passo anterior, o uriString e os valores do ficheiro são passados para uma instância do nosso próximo exemplo, UploadOp, onde são usados para configurar e iniciar a nova operação de upload. Primeiro, o uriString é analisado para criar o objeto Uri necessário.

De seguida, as propriedades do StorageFile fornecido (ficheiro) são usadas pelo BackgroundUploader para preencher o cabeçalho do pedido e definir a propriedade SourceFile com o objeto StorageFile . O método SetRequestHeader é então chamado para inserir o nome do ficheiro, fornecido como uma string, e a propriedade StorageFile.Name .

Finalmente, o BackgroundUploader cria o 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);
        }
    };
}

Repare nas chamadas assíncronas de método definidas com promessas em JavaScript. Olhando para uma linha do último exemplo:

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

A chamada ao método assíncrono é seguida por uma then instrução que indica os métodos, definidos pela aplicação, que são chamados quando um resultado da chamada ao método assíncrono é retornado. Para mais informações sobre este padrão de programação, consulte Programação assíncrona em JavaScript usando promessas.

Carregar múltiplos ficheiros

Identifique os ficheiros e o destino para o upload

Num cenário que envolve vários ficheiros transferidos com uma só UploadOperation, o processo começa, como habitualmente, por fornecer primeiro o URI de destino necessário e as informações dos ficheiros locais. Semelhante ao exemplo da secção anterior, o URI é fornecido como uma cadeia pelo utilizador final e o FileOpenPicker pode ser usado para fornecer a capacidade de indicar ficheiros através da interface do utilizador. No entanto, neste cenário, a aplicação deve chamar o método PickMultipleFilesAsync para permitir a seleção de múltiplos ficheiros através da interface.

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

Criar objetos para os parâmetros fornecidos

Os dois exemplos seguintes usam código contido num único método de exemplo, startMultipart, que foi chamado no final do último passo. Para efeitos de instrução, o código no método que cria um array de objetos BackgroundTransferContentPart foi separado do código que cria a UploadOperation resultante.

Primeiro, a cadeia de URI fornecida pelo utilizador é inicializada como um Uri. De seguida, o array de objetos IStorageFile (ficheiros) passado a este método é percorrido, e cada objeto é utilizado para criar um novo objeto BackgroundTransferContentPart, que é depois colocado no array 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);
            });

Criar e inicializar a operação de upload em várias partes

Com o nosso contentParts array preenchido com todos os objetos BackgroundTransferContentPart que representam cada IStorageFile para upload, estamos prontos para chamar o CreateUploadAsync usando o Uri para indicar onde o pedido será enviado.

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

Reiniciar operações de upload interrompidas

Após a conclusão ou o cancelamento de uma UploadOperation, todos os recursos de sistema associados são libertados. No entanto, se a sua aplicação for terminada antes de qualquer uma destas operações acontecer, quaisquer operações ativas são pausadas e os recursos associados a cada uma permanecem ocupados. Se estas operações não forem enumeradas e reintroduzidas na próxima sessão da aplicação, não serão concluídas e continuarão a ocupar recursos do dispositivo.

1. Antes de definir a função que enumera as operações persistentes, precisamos de criar um array que contenha os objetos UploadOperation que este irá devolver:

   var uploadOperations = [];
   

2. De seguida, definimos a função que enumera as operações persistentes e as armazena no nosso array. Note que o método load chamado para reatribuir callbacks ao UploadOperation, caso persista até à terminação da aplicação, está na classe UploadOp que definimos mais adiante nesta secção.

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

A descarregar ficheiros

Ao usar Transferência em Segundo Plano, cada download existe como uma DownloadOperation que expõe vários métodos de controlo usados para pausar, retomar, reiniciar e cancelar a operação. Eventos da aplicação (por exemplo, suspensão ou terminação) e alterações de conectividade são tratados automaticamente pelo sistema por DownloadOperation; as transferências continuarão durante os períodos de suspensão da aplicação ou serão colocadas em pausa e persistirão para além da terminação da aplicação. Para cenários de rede móvel, definir a propriedade CostPolicy indicará se a sua aplicação irá iniciar ou continuar a descarregar enquanto uma rede com medição estiver a ser usada para a conectividade à Internet.

Se estiver a descarregar pequenos recursos cuja transferência deverá ser concluída rapidamente, deve usar as APIs de HttpClient em vez da Transferência em Segundo Plano.

Os exemplos seguintes irão guiá-lo pela criação e inicialização de um download básico, e por como enumerar e reintroduzir operações que persistiram de uma sessão anterior da aplicação.

Configure e inicie um download de ficheiro de transferência em segundo plano

O exemplo seguinte demonstra como strings que representam um URI e um nome de ficheiro podem ser usadas para criar um objeto Uri e o StorageFile que conterá o ficheiro solicitado. Neste exemplo, o novo ficheiro é automaticamente colocado numa localização pré-definida. Alternativamente, o FileSavePicker pode ser usado para permitir que os utilizadores indiquem onde guardar o ficheiro no dispositivo. Note que o método load chamado para reatribuir callbacks ao DownloadOperation, caso persista até à terminação da aplicação, está na classe DownloadOp definida mais adiante nesta secção.

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

Observe as chamadas assíncronas de métodos definidas com promessas em JavaScript. Olhando para a linha 17 do exemplo anterior do código:

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

A chamada assíncrona do método é seguida por uma instrução «then» que especifica os métodos, definidos pela aplicação, que são chamados quando é devolvido um resultado da chamada assíncrona do método. Para mais informações sobre este padrão de programação, consulte Programação assíncrona em JavaScript usando promessas.

Adição de métodos adicionais de controlo operacional

O nível de controlo pode ser aumentado através da implementação de métodos adicionais de DownloadOperation . Por exemplo, adicionar o código seguinte ao exemplo acima introduzirá a possibilidade de cancelar o download.

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

Listagem das operações persistidas no arranque

Após a conclusão ou cancelamento de um DownloadOperation, quaisquer recursos do sistema associados são libertados. No entanto, se a sua aplicação for terminada antes de qualquer um destes eventos ocorrer, os downloads irão pausar e persistir em segundo plano. Os exemplos seguintes demonstram como reintroduzir downloads persistentes numa nova sessão de aplicação.

1. Antes de definir a função que enumera as operações persistentes, precisamos de criar um array que contenha os objetos DownloadOperation que irá devolver:

   var downloadOps = [];
   

2. De seguida, definimos a função que enumera as operações persistentes e as armazena no nosso array. Note que o método load chamado para reatribuir callbacks para uma DownloadOperation persistente está no exemplo DownloadOp que definimos mais adiante nesta secção.

   // 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. Agora pode usar a lista preenchida para reiniciar operações pendentes.

Pós-processamento

Uma nova funcionalidade no Windows 10 é a capacidade de executar código da aplicação após a conclusão de uma transferência em segundo plano, mesmo quando a aplicação não está a correr. Por exemplo, a sua aplicação pode querer atualizar uma lista de filmes disponíveis depois de um filme terminar de ser descarregado, em vez de fazer a sua aplicação analisar novos filmes sempre que começa. Ou a tua aplicação pode querer tratar de uma falha na transferência de ficheiros tentando novamente usando outro servidor ou porta. O pós-processamento é executado tanto para transferências bem-sucedidas como para transferências sem êxito, pelo que o pode usar para implementar lógica personalizada de tratamento de erros e de novas tentativas.

O pós-processamento utiliza a infraestrutura de tarefas em segundo plano existente. Crias uma tarefa em segundo plano e associa-a às tuas transferências antes de começares as transferências. As transferências são então executadas em segundo plano e, quando estão concluídas, a sua tarefa em segundo plano é chamada para realizar o pós-processamento.

O pós-processamento utiliza uma nova classe, BackgroundTransferCompletionGroup. Esta classe é semelhante ao BackgroundTransferGroup existente no sentido em que permite agrupar transferências em segundo plano, mas o BackgroundTransferCompletionGroup adiciona a capacidade de designar uma tarefa em segundo plano a ser executada quando a transferência estiver concluída.

Inicia uma transferência em segundo plano com processamento posterior da seguinte forma.

1. Crie um objeto BackgroundTransferCompletionGroup . Depois, cria um objeto BackgroundTaskBuilder . Defina a propriedade Trigger do objeto construtor para o objeto do grupo de completão, e a propriedade TaskEntryPoint do construtor para o ponto de entrada da tarefa em segundo plano que deve ser executada na conclusão da transferência. Por fim, chame o método BackgroundTaskBuilder.Register para registar a sua tarefa em segundo plano. Tenha em atenção que muitos grupos de conclusão podem partilhar um único ponto de entrada de uma tarefa em segundo plano, mas só pode ter um grupo de conclusão por registo de uma tarefa em segundo plano.

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

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

BackgroundTaskRegistration downloadProcessingTask = builder.Register();

2. De seguida, associas as transferências de antecedentes ao grupo de conclusão. Depois de todas as transferências forem criadas, ative o grupo de completação.

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. O código na tarefa em segundo plano extrai a lista de operações a partir dos detalhes do trigger, e o seu código pode então inspecionar os detalhes de cada operação e realizar o pós-processamento adequado para cada operação.

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

A tarefa de pós-processamento é uma tarefa normal em segundo plano. Faz parte do conjunto de todas as tarefas em segundo plano e está sujeito à mesma política de gestão de recursos que todas as tarefas em segundo plano.

Além disso, tenha em atenção que o pós-processamento não substitui as rotinas de conclusão de primeiro plano. Se a sua aplicação definir um gestor de conclusão em primeiro plano, e a sua aplicação estiver a correr quando a transferência de ficheiros terminar, então tanto o seu gestor de conclusão em primeiro plano como o seu gestor de conclusão em segundo plano serão chamados. A ordem em que as tarefas em primeiro plano e em segundo plano são chamadas não é garantida. Se definires ambos, deves garantir que as duas tarefas funcionem corretamente e não interfiram uma com a outra se estiverem em execução em simultâneo.

Tempo limite de solicitação

Existem dois cenários principais de timeout de ligação a considerar:

• Ao estabelecer uma nova ligação para uma transferência, o pedido de ligação é abortado se não for estabelecido dentro de cinco minutos.

• Depois de estabelecida uma ligação, uma mensagem de pedido HTTP que não recebeu resposta em dois minutos é abortada.

Nota Em qualquer dos cenários, assumindo que existe conectividade à Internet, a Transferência em Segundo Plano tentará um pedido até três vezes automaticamente. Caso não seja detetada conectividade à Internet, os pedidos adicionais ficarão em espera até que esta seja detetada.

Orientações de depuração

Parar uma sessão de depuração em Microsoft Visual Studio é comparável a fechar a sua aplicação; Os uploads PUT são pausados e os uploads POST terminados. Mesmo durante a depuração, a tua aplicação deve enumerar e depois reiniciar ou cancelar quaisquer uploads persistentes. Por exemplo, pode fazer com que a sua aplicação cancele as operações de upload persistentes enumeradas no arranque da aplicação se não houver interesse em operações anteriores para essa sessão de depuração.

Ao enumerar downloads/uploads no arranque da aplicação durante uma sessão de debug, pode pedir para a sua aplicação cancelá-los se não houver interesse em operações anteriores dessa sessão. Note que, se houver atualizações do projeto Visual Studio, como alterações ao manifesto da aplicação, e a aplicação for desinstalada e reimplantada, o GetCurrentUploadsAsync não pode enumerar as operações criadas com a implementação anterior da aplicação.

Ao utilizar a Transferência em Segundo Plano durante o desenvolvimento, poderá deparar-se com uma situação em que as memórias cache internas das operações de transferência ativas e concluídas ficam dessincronizadas. Isto pode impedir o início de novas operações de transferência ou a interação com operações existentes e com objetos BackgroundTransferGroup. Em alguns casos, tentar interagir com operações existentes pode desencadear um crash. Este resultado pode ocorrer se a propriedade TransferBehavior for definida como Paralelo. Este problema ocorre apenas em certos cenários durante o desenvolvimento e não se aplica aos utilizadores finais da sua aplicação.

Quatro cenários usando o Visual Studio podem causar este problema.

• Cria-se um novo projeto com o mesmo nome de aplicação de um projeto existente, mas com uma linguagem diferente (de C++ para C#, por exemplo).
• Mudas a arquitetura de destino (de x86 para x64, por exemplo) num projeto existente.
• Mudas a cultura (de neutro para en-US, por exemplo) num projeto existente.
• Adiciona-se ou remove uma funcionalidade no manifesto do pacote (adicionando a Autenticação Empresarial, por exemplo) num projeto existente.

A manutenção regular da aplicação, incluindo atualizações do manifesto que adicionam ou removem capacidades, não provoca este problema nas implementações da sua aplicação para utilizadores finais. Para contornar este problema, desinstale completamente todas as versões da aplicação e volte a implementar com a nova linguagem, arquitetura, cultura ou funcionalidade. Isto pode ser feito através do ecrã Iniciar ou usando o PowerShell e o cmdlet Remove-AppxPaquete .

Exceções em Windows.Networking.BackgroundTransfer

É lançada uma exceção quando é passada uma cadeia de caracteres inválida para um Identificador Uniforme de Recursos (URI) ao construtor do objeto Windows.Foundation.Uri.

.NET: O tipo Windows.Foundation.Uri aparece como System.Uri em C# e VB.

Em C# e Visual Basic, este erro pode ser evitado usando a classe System.Uri no .NET 4.5 e um dos métodos System.Uri.TryCreate para testar a cadeia recebida do utilizador da aplicação antes da construção do URI.

Em C++, não existe método para tentar analisar uma string para um URI. Se uma aplicação receber do utilizador uma entrada para o Windows.Foundation.Uri, o construtor deve estar dentro de um bloco try/catch. Se for lançada uma exceção, a aplicação pode notificar o utilizador e solicitar um novo nome de host.

O espaço de nomes Windows.Networking.backgroundTransfer inclui métodos auxiliares práticos e utiliza enumerações no espaço de nomes Windows.Networking.Sockets para processar erros. Isto pode ser útil para gerir exceções específicas de rede de forma diferente na sua aplicação.

Um erro encontrado num método assíncrono no espaço de nomes Windows.Networking.backgroundTransfer é devolvido sob a forma de um valor HRESULT. O método BackgroundTransferError.GetStatus é usado para converter um erro de rede de uma operação de transferência em segundo plano para um valor de enumeração WebErrorStatus . A maioria dos valores de enumeração WebErrorStatus corresponde a um erro devolvido pela operação nativa do cliente HTTP ou FTP. Uma aplicação pode filtrar valores específicos de enumeração WebErrorStatus para modificar o comportamento da aplicação consoante a causa da exceção.

Para erros de validação de parâmetros, uma aplicação pode também usar o HRESULT da exceção para obter informações mais detalhadas sobre o erro que causou a exceção. Os possíveis valores HRESULT estão listados no ficheiro de cabeçalho Winerror.h . Para a maioria dos erros de validação de parâmetros, o HRESULT devolvido é E_INVALIDARG.

APIs importantes

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