Transferências em segundo plano

Use a API de transferência em segundo plano para copiar arquivos de forma confiável pela rede. A API de transferência em segundo plano fornece recursos avançados de upload e download que são executados em segundo plano durante a suspensão do aplicativo e persistem além do encerramento do aplicativo. A API monitora o status da rede e suspende e retoma automaticamente as transferências quando a conectividade é perdida, e as transferências também têm reconhecimento de senso de dados e reconhecimento de senso de bateria, o que significa que a atividade de download se ajusta com base na conectividade atual e no status da bateria do dispositivo. A API é ideal para carregar e baixar arquivos grandes usando HTTP(S). O FTP também tem suporte, mas somente para downloads.

A Transferência em Segundo Plano é executada separadamente do aplicativo de chamada e foi projetada principalmente para operações de transferência de longo prazo para recursos como vídeo, música e imagens grandes. Para esses cenários, o uso da Transferência em Segundo Plano é essencial porque os downloads continuam a progredir mesmo quando o aplicativo é suspenso.

Se você estiver baixando pequenos recursos que provavelmente serão baixados rapidamente, deverá usar as APIs HttpClient em vez de Background Transfer.

Usando Windows.Networking.BackgroundTransfer

Como funciona o recurso de Transferência em Segundo Plano?

Quando um aplicativo usa a Transferência em Segundo Plano para iniciar uma transferência, a solicitação é configurada e inicializada usando objetos de classe BackgroundDownloader ou BackgroundUploader . Cada operação de transferência é tratada individualmente pelo sistema e separada do aplicativo de chamada. As informações de progresso estão disponíveis se você quiser dar status ao usuário na interface do usuário do aplicativo e seu aplicativo puder pausar, retomar, cancelar ou até mesmo ler os dados enquanto a transferência estiver ocorrendo. A maneira como as transferências são tratadas pelo sistema promove o uso inteligente de energia e evita problemas que podem surgir quando um aplicativo conectado encontra eventos como suspensão de aplicativo, terminação ou alterações repentinas de status de rede.

Quando um aplicativo é iniciado, ele deve chamar AttachAsync em todos os objetos DownloadOperation e UploadOperation existentes. Não fazer isso causará o vazamento de transferências já concluídas e, eventualmente, tornará inútil o uso do recurso de Transferência em Segundo Plano.

Executando solicitações de arquivo autenticadas com transferência em segundo plano

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

Como esse recurso se adapta a alterações de status de rede ou desligamentos inesperados?

O recurso transferência em segundo plano mantém uma experiência consistente para cada operação de transferência quando ocorrem alterações de status de rede, aproveitando de forma inteligente as informações de status de plano de dados da operadora e conectividade fornecidas pelo recurso conectividade . Para definir o comportamento de diferentes cenários de rede, um aplicativo define uma política de custo para cada operação usando valores definidos por BackgroundTransferCostPolicy.

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

Embora o recurso de Transferência em Segundo Plano tenha seus próprios mecanismos para lidar com alterações de status de rede, há outras considerações gerais de conectividade para aplicativos conectados à rede. Leia Aproveitar as informações de conexão de rede disponíveis para obter informações adicionais.

Nota Para aplicativos em execução em dispositivos móveis, há recursos que permitem que o usuário monitore e restrinja a quantidade de dados transferidos com base no tipo de conexão, status de roaming e no plano de dados do usuário. Por isso, as transferências em segundo plano podem ser pausadas no telefone mesmo quando o BackgroundTransferCostPolicy indica que a transferência deve continuar.

A tabela a seguir indica quando as transferências em segundo plano são permitidas no telefone para cada valor BackgroundTransferCostPolicy , considerando o estado atual do telefone. Você pode usar a classe ConnectionCost para determinar o estado atual do telefone.

Carregando arquivos

Ao usar a Transferência em Segundo Plano, um carregamento é representado por uma UploadOperation, que expõe diversos métodos de controle usados para reiniciar ou cancelar a operação. Eventos de aplicativo (por exemplo, suspensão ou encerramento) e alterações de conectividade são tratados automaticamente pelo sistema por UploadOperation; os uploads continuarão durante os períodos de suspensão do aplicativo ou pausarão e persistirão além da terminação do aplicativo. Além disso, definir a propriedade CostPolicy indicará se seu aplicativo iniciará ou não uploads enquanto uma rede limitada estiver sendo usada para conectividade com a Internet.

Os exemplos a seguir orientarão você na criação e inicialização de um upload básico e como enumerar e reintroduzir operações persistidas de uma sessão de aplicativo anterior.

Carregando um único arquivo

A criação de um upload começa com BackgroundUploader. Essa classe é usada para fornecer os métodos que permitem que seu aplicativo configure o upload antes de criar a UploadOperation resultante. O exemplo a seguir mostra como fazer isso com os objetos Uri e StorageFile necessários.

Identificar o arquivo e o destino do upload

Antes de começarmos com a criação de uma UploadOperation, primeiro precisamos identificar o URI do local para o qual carregar e o arquivo que será carregado. No exemplo a seguir, o valor uriString é preenchido usando uma cadeia de caracteres da entrada da interface do usuário e o valor do arquivo usando o objeto StorageFile retornado 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

Na etapa anterior, os valores uriString e file são passados para uma instância do exemplo a seguir, UploadOp, na qual são usados para configurar e iniciar a nova operação de upload. Primeiro, uriString é analisado para criar o objeto Uri necessário.

Em seguida, as propriedades do StorageFile (arquivo) fornecido são usadas pelo BackgroundUploader para preencher o cabeçalho da solicitação e definir a propriedade SourceFile com o objeto StorageFile . O método SetRequestHeader é chamado para inserir o nome do arquivo, fornecido como uma cadeia de caracteres e a propriedade StorageFile.Name .

Por fim, 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);
        }
    };
}

Observe as chamadas de método assíncronas definidas usando promessas do JavaScript. Examinando uma linha do último exemplo:

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

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

Carregando vários arquivos

Identificar os arquivos e o destino do upload

Em um cenário que envolve vários arquivos transferidos com uma única UploadOperation, o processo começa como normalmente faz, fornecendo primeiro o URI de destino necessário e as informações de arquivo local. Semelhante ao exemplo na seção anterior, o URI é fornecido como uma cadeia de caracteres pelo usuário final e FileOpenPicker pode ser usado para fornecer a capacidade de indicar arquivos por meio da interface do usuário também. No entanto, nesse cenário, o aplicativo deve chamar o método PickMultipleFilesAsync para habilitar a seleção de vários arquivos por meio da interface do usuário.

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 a seguir usam código contido em um único método de exemplo, startMultipart, que foi chamado no final da última etapa. Para fins de instrução, o código no método que cria uma matriz de objetos BackgroundTransferContentPart foi dividido do código que cria o UploadOperation resultante.

Primeiro, a cadeia de caracteres de URI fornecida pelo usuário é inicializada como um Uri. Em seguida, a matriz de objetos IStorageFile (arquivos) passados para esse método é iterada, cada objeto é usado para criar um novo objeto BackgroundTransferContentPart que, em seguida, é colocado na matriz 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 de várias partes

Com nossa matriz contentParts preenchida com todos os objetos BackgroundTransferContentPart que representam cada IStorageFile para upload, estamos prontos para chamar CreateUploadAsync usando o Uri para indicar para onde a solicitação será enviada.

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

Reiniciando operações de upload interrompidas

Após a conclusão ou cancelamento de uma UploadOperation, todos os recursos do sistema associados são liberados. No entanto, se o aplicativo for encerrado antes que qualquer uma dessas coisas possa ocorrer, todas as operações ativas serão pausadas e os recursos associados a cada um permanecerão ocupados. Se essas operações não forem enumeradas e reintroduzidas na próxima sessão do aplicativo, elas não serão concluídas e continuarão ocupando recursos do dispositivo.

1. Antes de definir a função que enumera operações persistentes, precisamos criar uma matriz que contenha os objetos UploadOperation que ela retornará:

   var uploadOperations = [];
   

2. Em seguida, definimos a função que enumera operações persistentes e as armazena em nossa matriz. Observe que o método load, chamado para reatribuir callbacks ao UploadOperation, caso persista após o encerramento do aplicativo, está na classe UploadOp definida mais adiante nesta seçã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);
           }
       }
   };
   

Baixando arquivos

Ao usar a Transferência em Segundo Plano, cada download existe como uma DownloadOperation que expõe vários métodos de controle usados para pausar, retomar, reiniciar e cancelar a operação. Eventos de aplicativo (por exemplo, suspensão ou término) e alterações de conectividade são tratados automaticamente pelo sistema por DownloadOperation; os downloads continuarão durante os períodos de suspensão do aplicativo ou pausarão e persistirão além da terminação do aplicativo. Para cenários de rede móvel, definir a propriedade CostPolicy indicará se o seu aplicativo iniciará ou continuará downloads enquanto uma rede tarifada estiver sendo usada para conexão com a Internet.

Se você estiver baixando pequenos recursos que provavelmente serão baixados rapidamente, deverá usar as APIs HttpClient em vez de Background Transfer.

Os exemplos a seguir orientarão você na criação e inicialização de um download básico e como enumerar e reintroduzir operações persistidas de uma sessão de aplicativo anterior.

Configurar e iniciar um download de arquivo de transferência em segundo plano

O exemplo a seguir demonstra como cadeias de caracteres que representam um URI e um nome de arquivo podem ser usadas para criar um objeto Uri e o StorageFile que conterá o arquivo solicitado. Neste exemplo, o novo arquivo é colocado automaticamente em um local predefinido. Como alternativa, FileSavePicker pode ser usado para permitir que os usuários indiquem onde salvar o arquivo no dispositivo. Observe que o método load, chamado para reatribuir callbacks à DownloadOperation, caso ela persista após o encerramento do aplicativo, está definido na classe DownloadOp posteriormente nesta seçã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 de método assíncronas definidas usando promessas JavaScript. Examinando a linha 17 do exemplo de código anterior:

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

A chamada do método assíncrono é seguida por uma instrução então que indica métodos, definidos pelo aplicativo, que são chamados quando um resultado da chamada do método assíncrono é retornado. Para obter mais informações sobre esse padrão de programação, consulte programação assíncrona em JavaScript usando promessas.

Adicionando métodos de controle de operação adicionais

O nível de controle pode ser aumentado implementando métodos de DownloadOperation adicionais. Por exemplo, adicionar o código a seguir ao exemplo acima introduzirá a capacidade 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);
    }
};

Enumerando operações persistentes na inicialização

Após a conclusão ou cancelamento de uma DownloadOperation, todos os recursos do sistema associados são liberados. No entanto, se o aplicativo for encerrado antes de qualquer um desses eventos ocorrer, os downloads pausarão e persistirão em segundo plano. Os exemplos a seguir demonstram como introduzir novamente os downloads persistentes em uma nova sessão de aplicativo.

1. Antes de definir a função que enumera operações persistentes, precisamos criar uma matriz que contenha os objetos DownloadOperation que ela retornará:

   var downloadOps = [];
   

2. Em seguida, definimos a função que enumera operações persistentes e as armazena em nossa matriz. Observe que o método load, chamado para reatribuir callbacks de uma DownloadOperation persistida, está no exemplo DownloadOp que definimos mais adiante nesta seçã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 você pode usar a lista preenchida para reiniciar operações pendentes.

Pós-processamento

Um novo recurso no Windows 10 é a capacidade de executar o código do aplicativo na conclusão de uma transferência em segundo plano mesmo quando o aplicativo não estiver em execução. Por exemplo, talvez seu aplicativo queira atualizar uma lista de filmes disponíveis depois que um filme terminar de baixar, em vez de fazer com que seu aplicativo examine novos filmes sempre que ele for iniciado. Ou talvez seu aplicativo queira lidar com uma transferência de arquivo com falha ao tentar novamente usando um servidor ou porta diferente. O pós-processamento é executado tanto para transferências bem-sucedidas quanto para transferências malsucedidas, portanto você pode usá-lo para implementar lógica personalizada de tratamento de erros e de nova tentativa.

O pós-processamento usa a infraestrutura de tarefa em segundo plano existente. Crie uma tarefa em segundo plano e associe-a às suas transferências antes de iniciar as transferências. As transferências são executadas em segundo plano e, quando concluídas, sua tarefa em segundo plano é chamada para executar o pós-processamento.

O pós-processamento usa uma nova classe, BackgroundTransferCompletionGroup. Essa classe é semelhante ao BackgroundTransferGroup existente, pois permite agrupar transferências em segundo plano, mas BackgroundTransferCompletionGroup adiciona a capacidade de designar uma tarefa em segundo plano a ser executada quando a transferência for concluída.

Você inicia uma transferência em segundo plano com pós-processamento da seguinte maneira.

1. Crie um objeto BackgroundTransferCompletionGroup . Em seguida, crie um objeto BackgroundTaskBuilder . Defina a propriedade Trigger do objeto construtor como o objeto de grupo de conclusão e a propriedade TaskEntryPoint do construtor como 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 registrar sua tarefa em segundo plano. Observe que muitos grupos de conclusão podem compartilhar um ponto de entrada para a tarefa em segundo plano, mas você pode ter apenas um grupo de conclusão por registro de 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. Em seguida, você associa transferências em segundo plano ao grupo de conclusão. Depois que todas as transferências forem criadas, habilite o grupo de conclusã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 dos detalhes do acionador, e seu código pode então inspecionar os detalhes de cada operação e realizar o pós-processamento adequado para cada uma delas.

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 pós-processamento é uma tarefa regular em segundo plano. Ele faz parte do pool de todas as tarefas em segundo plano e está sujeito à mesma política de gerenciamento de recursos que todas as tarefas em segundo plano.

Além disso, observe que o pós-processamento não substitui os manipuladores de conclusão executados em primeiro plano. Se o aplicativo definir um manipulador de conclusão em primeiro plano e seu aplicativo estiver em execução quando a transferência de arquivo for concluída, o manipulador de conclusão em primeiro plano e o manipulador de conclusão em segundo plano serão chamados. A ordem na qual as tarefas em primeiro plano e em segundo plano são chamadas não é garantida. Se você definir ambas, deverá garantir que as duas tarefas funcionarão corretamente e não interferirão umas nas outras se elas estiverem sendo executadas simultaneamente.

Tempos limite de solicitação

Há dois cenários de tempo limite de conexão principais a serem considerados:

• Ao estabelecer uma nova conexão para uma transferência, a solicitação de conexão será anulada se não for estabelecida dentro de cinco minutos.

• Depois que uma conexão for estabelecida, uma mensagem de solicitação HTTP que não recebeu uma resposta dentro de dois minutos será anulada.

Nota Em qualquer cenário, supondo que haja conectividade com a Internet, a Transferência em Segundo Plano tentará novamente uma solicitação até três vezes automaticamente. Caso a conectividade com a Internet não seja detectada, solicitações adicionais aguardarão até que ela seja.

Diretrizes de depuração

Interromper uma sessão de depuração no Microsoft Visual Studio é comparável ao fechamento do aplicativo; Os uploads PUT são pausados e os uploads POST são encerrados. Mesmo durante a depuração, seu aplicativo deve listar e, em seguida, reiniciar ou cancelar todos os uploads persistentes. Por exemplo, você pode fazer com que seu aplicativo cancele operações de upload persistentes enumeradas na inicialização do aplicativo se não houver interesse em operações anteriores para essa sessão de depuração.

Ao enumerar downloads/uploads ao iniciar o aplicativo durante uma sessão de depuração, você pode fazer com que o aplicativo os cancele caso não haja interesse nas operações anteriores dessa sessão de depuração. Observe que, se houver atualizações de projeto Visual Studio, como alterações no manifesto do aplicativo, e o aplicativo estiver desinstalado e implantado novamente, GetCurrentUploadsAsync não poderá enumerar as operações criadas usando a implantação anterior do aplicativo.

Ao usar a Transferência em Segundo Plano durante o desenvolvimento, você pode entrar em uma situação em que os caches internos de operações de transferência ativas e concluídas podem sair da sincronização. Isso pode resultar na incapacidade de iniciar novas operações de transferência ou interagir com operações existentes e objetos BackgroundTransferGroup . Em alguns casos, a tentativa de interagir com as operações existentes pode desencadear uma falha. Esse resultado poderá ocorrer se a propriedade TransferBehavior estiver definida como Parallel. Esse problema ocorre apenas em determinados cenários durante o desenvolvimento e não é aplicável aos usuários finais do seu aplicativo.

Quatro cenários usando Visual Studio podem causar esse problema.

• Você cria um novo projeto com o mesmo nome de aplicativo de um projeto existente, mas uma linguagem diferente (de C++ a C#, por exemplo).
• Você altera a arquitetura de destino (de x86 para x64, por exemplo) em um projeto existente.
• Você altera a cultura (de neutra para en-US, por exemplo) em um projeto existente.
• Adicione ou remova uma funcionalidade no manifesto do pacote (adicionando a Autenticação Empresarial, por exemplo) em um projeto existente.

A manutenção regular do aplicativo, incluindo atualizações de manifesto que adicionam ou removem recursos, não desencadeia esse problema em implantações para usuários finais do seu aplicativo. Para contornar esse problema, desinstale completamente todas as versões do aplicativo e implante novamente com a nova linguagem, arquitetura, cultura ou funcionalidade. Isso pode ser feito por meio da tela Inicial ou usando o PowerShell e o cmdlet Remove-AppxPackage .

Exceções em Windows.Networking.BackgroundTransfer

Uma exceção é gerada quando uma cadeia de caracteres inválida para um URI (Uniform Resource Identifier) é passada para o construtor do Windows. Objeto Foundation.Uri.

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

Em C# e Visual Basic, esse 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 de caracteres recebida do usuário do aplicativo antes que o URI seja construído.

No C++, não há nenhum método para tentar analisar uma cadeia de caracteres para um URI. Se um aplicativo receber uma entrada do usuário para o Windows.Foundation.Uri, o construtor deverá ficar dentro de um bloco try/catch. Se uma exceção for gerada, o aplicativo poderá notificar o usuário e solicitar um novo nome de host.

O namespace Windows.Networking.backgroundTransfer tem métodos auxiliares práticos e usa enumerações no namespace Windows.Networking.Sockets para lidar com erros. Isso pode ser útil para lidar com exceções de rede específicas de forma diferente em seu aplicativo.

Um erro encontrado em um método assíncrono no namespace Windows.Networking.backgroundTransfer é retornado como 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 retornado pela operação de cliente HTTP ou FTP nativa. Um aplicativo pode filtrar valores de enumeração WebErrorStatus específicos para modificar o comportamento do aplicativo, dependendo da causa da exceção.

Para erros de validação de parâmetro, um aplicativo também pode usar o HRESULT da exceção para saber mais informações detalhadas sobre o erro que causou a exceção. Possíveis valores HRESULT são listados no arquivo de cabeçalho Winerror.h . Para a maioria dos erros de validação de parâmetro, o HRESULT retornado é E_INVALIDARG.

APIs importantes

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