Noções básicas de rede

Coisas que você deve fazer para qualquer aplicativo habilitado para rede.

Capacidades

Para usar a rede, você deve adicionar elementos de funcionalidade apropriados ao manifesto do aplicativo. Se nenhuma funcionalidade de rede for especificada no manifesto do aplicativo, seu aplicativo não terá nenhum recurso de rede e qualquer tentativa de conexão à rede falhará.

Veja a seguir os recursos de rede mais usados.

Há outras funcionalidades que podem ser necessárias para seu aplicativo, em determinadas circunstâncias.

Comunicando-se quando seu aplicativo não está em primeiro plano

O suporte ao aplicativo com tarefas em segundo plano contém informações gerais sobre como usar tarefas em segundo plano para trabalhar quando seu aplicativo não estiver em primeiro plano. Mais especificamente, o seu código deve executar etapas especiais para ser notificado quando ele não for o aplicativo em primeiro plano atual e quando os dados chegarem pela rede para ele. Você usou gatilhos de canal de controle para essa finalidade no Windows 8 e eles ainda têm suporte no Windows 10. Informações completas sobre como usar gatilhos de canal de controle estão disponíveis aqui. Uma nova tecnologia no Windows 10 fornece melhor funcionalidade com menor sobrecarga para alguns cenários, como soquetes de fluxo habilitados para push: o intermediário de soquete e os gatilhos de atividade de soquete.

Se seu aplicativo usar DatagramSocket, StreamSocket ou StreamSocketListener, seu aplicativo poderá transferir a propriedade de um soquete aberto para um agente de soquete fornecido pelo sistema e, em seguida, deixar o primeiro plano ou até mesmo terminar. Quando uma conexão é feita no soquete transferido ou o tráfego chega nesse soquete, o aplicativo ou sua tarefa em segundo plano designada são ativados. Se o aplicativo não estiver em execução, ele será iniciado. O agente de soquete notifica seu aplicativo usando um SocketActivityTrigger que o novo tráfego chegou. Seu aplicativo recupera o soquete do gerenciador de soquete e processa o tráfego no soquete. Isso significa que seu aplicativo consome muito menos recursos do sistema quando não está processando ativamente o tráfego de rede.

O corretor de soquete destina-se a substituir gatilhos de canal de controle onde for aplicável, pois fornece a mesma funcionalidade, mas com menos restrições e um uso de memória menor. O socket broker pode ser usado por apps que não são apps de tela de bloqueio e é usado da mesma maneira em telefones que em outros dispositivos. Os aplicativos não precisam ser executados quando o tráfego chega para serem ativados pelo agente de soquete. E o intermediário de soquetes oferece suporte à escuta em soquetes TCP, o que os Gatilhos de Canal de Controle não suportam.

Escolhendo um gatilho de rede

Há alguns cenários em que qualquer tipo de gatilho seria adequado. Ao escolher qual tipo de gatilho usar em seu aplicativo, considere os conselhos a seguir.

• Se você estiver usando IXMLHTTPRequest2, System.Net.Http.HttpClient ou System.Net.Http.HttpClientHandler, você deve usar ControlChannelTrigger.
• Se você estiver usando StreamSockets habilitados para push, poderá usar gatilhos de canal de controle, mas deve preferir SocketActivityTrigger. A última opção permite que o sistema libere a memória e reduza os requisitos de energia quando a conexão não estiver sendo usada ativamente.
• Se você quiser minimizar o volume de memória do seu aplicativo quando ele não estiver atendendo ativamente solicitações de rede, prefira SocketActivityTrigger quando possível.
• Se você quiser que seu aplicativo possa receber dados enquanto o sistema estiver no modo de espera conectado, use SocketActivityTrigger.

Para obter detalhes e exemplos de como usar o agente de soquete, consulte Comunicações de rede em segundo plano.

Conexões protegidas

A SSL (Secure Sockets Layer) e o TLS (Transport Layer Security) mais recentes são protocolos criptográficos projetados para fornecer autenticação e criptografia para comunicação de rede. Esses protocolos são projetados para evitar escutas e adulterações ao enviar e receber dados de rede. Esses protocolos usam um modelo cliente-servidor para as trocas de protocolo. Esses protocolos também usam certificados digitais e autoridades de certificação para verificar se o servidor é quem ele afirma ser.

Criando conexões de soquete seguro

Um objeto StreamSocket pode ser configurado para usar SSL/TLS para comunicações entre o cliente e o servidor. Esse suporte para SSL/TLS é limitado ao uso do objeto StreamSocket como o cliente na negociação SSL/TLS. Você não pode usar SSL/TLS com o StreamSocket criado por um StreamSocketListener quando recebe comunicações de entrada, pois a negociação SSL/TLS como um servidor não é implementada pela classe StreamSocket.

Há duas maneiras de proteger uma conexão StreamSocket com SSL/TLS:

• ConnectAsync – Faça a conexão inicial com um serviço de rede e negocie imediatamente para usar SSL/TLS para todas as comunicações.
• UpgradeToSslAsync – Conecte-se inicialmente a um serviço de rede sem criptografia. O aplicativo pode enviar ou receber dados. Em seguida, atualize a conexão para usar SSL/TLS para todas as comunicações adicionais.

O SocketProtectionLevel especifica o nível de proteção de soquete desejado com o qual o aplicativo deseja estabelecer ou atualizar a conexão. No entanto, o nível de proteção eventual da conexão estabelecida é determinado em um processo de negociação entre ambos os pontos de extremidade da conexão. O resultado pode ser um nível de proteção menor do que o especificado, se o outro ponto de extremidade solicitar um nível inferior.

Depois que a operação assíncrona for concluída com êxito, você poderá recuperar o nível de proteção solicitado usado na chamada ConnectAsync ou UpgradeToSslAsync por meio da propriedade StreamSocketInformation.ProtectionLevel. No entanto, isso não reflete o nível de proteção real que a conexão está usando.

Usar ConnectAsync

O ConnectAsync pode ser usado para estabelecer a conexão inicial com um serviço de rede e, em seguida, negociar imediatamente para usar o SSL/TLS para todas as comunicações. Há dois métodos ConnectAsync que dão suporte à passagem de um parâmetro protectionLevel:

• ConnectAsync(EndpointPair, SocketProtectionLevel) – inicia uma operação assíncrona em um objeto StreamSocket para se conectar a um destino de rede remoto especificado como um objeto endpointPair e um SocketProtectionLevel.
• ConnectAsync(HostName, String, SocketProtectionLevel) – inicia uma operação assíncrona em um objeto StreamSocket para se conectar a um destino remoto especificado por um nome de host remoto, um nome de serviço remoto e um SocketProtectionLevel.

Se o parâmetro protectionLevel for definido como Windows.Networking.Sockets.SocketProtectionLevel.Ssl ao chamar qualquer um dos métodos ConnectAsync acima, o StreamSocket deverá ser estabelecido para utilizar SSL/TLS para criptografia. Esse valor requer criptografia e nunca permite que uma criptografia NULL seja usada.

A sequência normal a ser usada com um desses métodos ConnectAsync é a mesma.

• Criar um StreamSocket.
• Se for necessária uma opção avançada no socket, use a propriedade StreamSocket.Control para obter a instância StreamSocketControl associada a um objeto StreamSocket. Defina uma propriedade no StreamSocketControl.
• Chame um dos métodos ConnectAsync acima para iniciar uma operação para se conectar a um destino remoto e negociar imediatamente o uso do SSL/TLS.
• A força SSL realmente negociada usando ConnectAsync pode ser determinada obtendo a propriedade StreamSocketinformation.ProtectionLevel após a conclusão da operação assíncrona com êxito.

O exemplo a seguir cria um StreamSocket e tenta imediatamente estabelecer uma conexão com o serviço de rede e negociar o uso de SSL/TLS. Se a negociação for bem-sucedida, toda a comunicação de rede usando o StreamSocket entre o cliente, o servidor de rede será criptografado.

using Windows.Networking;
using Windows.Networking.Sockets;

    // Define some variables and set values
    StreamSocket clientSocket = new StreamSocket();
     
    HostName serverHost = new HostName("www.contoso.com");
    string serverServiceName = "https";
    
    // For simplicity, the sample omits implementation of the
    // NotifyUser method used to display status and error messages 
    
    // Try to connect to contoso using HTTPS (port 443)
    try {

        // Call ConnectAsync method with SSL
        await clientSocket.ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel.Ssl);

        NotifyUser("Connected");
    }
    catch (Exception exception) {
        // If this is an unknown status it means that the error is fatal and retry will likely fail.
        if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
            throw;
        }
        
        NotifyUser("Connect failed with error: " + exception.Message);
        // Could retry the connection, but for this simple example
        // just close the socket.
        
        clientSocket.Dispose();
        clientSocket = null; 
    }
           
    // Add code to send and receive data using the clientSocket
    // and then close the clientSocket

#include <winrt/Windows.Networking.Sockets.h>

using namespace winrt;
...
    // Define some variables, and set values.
    Windows::Networking::Sockets::StreamSocket clientSocket;

    Windows::Networking::HostName serverHost{ L"www.contoso.com" };
    winrt::hstring serverServiceName{ L"https" };

    // For simplicity, the sample omits implementation of the
    // NotifyUser method used to display status and error messages.

    // Try to connect to the server using HTTPS and SSL (port 443).
    try
    {
        co_await clientSocket.ConnectAsync(serverHost, serverServiceName, Windows::Networking::Sockets::SocketProtectionLevel::Tls12);
        NotifyUser(L"Connected");
    }
    catch (winrt::hresult_error const& exception)
    {
        NotifyUser(L"Connect failed with error: " + exception.message());
        clientSocket = nullptr;
    }
    // Add code to send and receive data using the clientSocket,
    // then set the clientSocket to nullptr when done to close it.

using Windows::Networking;
using Windows::Networking::Sockets;

    // Define some variables and set values
    StreamSocket^ clientSocket = new ref StreamSocket();
 
    HostName^ serverHost = new ref HostName("www.contoso.com");
    String serverServiceName = "https";

    // For simplicity, the sample omits implementation of the
    // NotifyUser method used to display status and error messages 

    // Try to connect to the server using HTTPS and SSL (port 443)
    task<void>(clientSocket->ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel::SSL)).then([this] (task<void> previousTask) {
        try
        {
            // Try getting all exceptions from the continuation chain above this point.
            previousTask.Get();
            NotifyUser("Connected");
        }
        catch (Exception^ exception)
        {
            NotifyUser("Connect failed with error: " + exception->Message);
            
            clientSocket.Close();
            clientSocket = null;
        }
    });
    // Add code to send and receive data using the clientSocket
    // Then close the clientSocket when done

Use o UpgradeToSslAsync

Quando seu código usa UpgradeToSslAsync, ele primeiro estabelece uma conexão com um serviço de rede sem criptografia. O aplicativo pode enviar ou receber alguns dados e, em seguida, atualizar a conexão para usar SSL/TLS para todas as comunicações adicionais.

O método UpgradeToSslAsync usa dois parâmetros. O parâmetro protectionLevel indica o nível de proteção desejado. O parâmetro validationHostName é o nome do host do destino de rede remota que é usado para validação ao atualizar para SSL. Normalmente, o validationHostName seria o mesmo nome de host que o aplicativo usou para inicialmente estabelecer a conexão. Se o parâmetro protectionLevel estiver definido como Windows.System.Socket.SocketProtectionLevel.Ssl ao chamar UpgradeToSslAsync, o StreamSocket deverá usar o SSL/TLS para criptografia em comunicações adicionais pelo soquete. Esse valor requer criptografia e nunca permite que uma criptografia NULL seja usada.

A sequência normal a ser usada com o método UpgradeToSslAsync é a seguinte:

• Criar um StreamSocket.
• Se for necessária uma opção avançada no socket, use a propriedade StreamSocket.Control para obter a instância StreamSocketControl associada a um objeto StreamSocket. Defina uma propriedade no StreamSocketControl.
• Se algum dado precisar ser enviado e recebido não criptografado, envie-os agora.
• Chame o método UpgradeToSslAsync para iniciar uma operação para atualizar a conexão para usar SSL/TLS.
• A força SSL realmente negociada usando UpgradeToSslAsync pode ser determinada obtendo a propriedade StreamSocketinformation.ProtectionLevel após a conclusão da operação assíncrona com êxito.

O exemplo a seguir cria um StreamSocket, tenta estabelecer uma conexão com o serviço de rede, envia alguns dados iniciais e negocia o uso de SSL/TLS. Se a negociação for bem-sucedida, toda a comunicação de rede usando o StreamSocket entre o cliente e o servidor de rede será criptografada.

using Windows.Networking;
using Windows.Networking.Sockets;
using Windows.Storage.Streams;

    // Define some variables and set values
    StreamSocket clientSocket = new StreamSocket();
 
    HostName serverHost = new HostName("www.contoso.com");
    string serverServiceName = "http";

    // For simplicity, the sample omits implementation of the
    // NotifyUser method used to display status and error messages 

    // Try to connect to contoso using HTTP (port 80)
    try {
        // Call ConnectAsync method with a plain socket
        await clientSocket.ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel.PlainSocket);

        NotifyUser("Connected");

    }
    catch (Exception exception) {
        // If this is an unknown status it means that the error is fatal and retry will likely fail.
        if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
            throw;
        }

        NotifyUser("Connect failed with error: " + exception.Message, NotifyType.ErrorMessage);
        // Could retry the connection, but for this simple example
        // just close the socket.

        clientSocket.Dispose();
        clientSocket = null; 
        return;
    }

    // Now try to send some data
    DataWriter writer = new DataWriter(clientSocket.OutputStream);
    string hello = "Hello, World! ☺ ";
    Int32 len = (int) writer.MeasureString(hello); // Gets the UTF-8 string length.
    writer.WriteInt32(len);
    writer.WriteString(hello);
    NotifyUser("Client: sending hello");

    try {
        // Call StoreAsync method to store the hello message
        await writer.StoreAsync();

        NotifyUser("Client: sent data");

        writer.DetachStream(); // Detach stream, if not, DataWriter destructor will close it.
    }
    catch (Exception exception) {
        NotifyUser("Store failed with error: " + exception.Message);
        // Could retry the store, but for this simple example
            // just close the socket.

            clientSocket.Dispose();
            clientSocket = null; 
            return;
    }

    // Now upgrade the client to use SSL
    try {
        // Try to upgrade to SSL
        await clientSocket.UpgradeToSslAsync(SocketProtectionLevel.Ssl, serverHost);

        NotifyUser("Client: upgrade to SSL completed");
           
        // Add code to send and receive data 
        // The close clientSocket when done
    }
    catch (Exception exception) {
        // If this is an unknown status it means that the error is fatal and retry will likely fail.
        if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
            throw;
        }

        NotifyUser("Upgrade to SSL failed with error: " + exception.Message);

        clientSocket.Dispose();
        clientSocket = null; 
        return;
    }

#include <winrt/Windows.Networking.Sockets.h>
#include <winrt/Windows.Storage.Streams.h>

using namespace winrt;
using namespace Windows::Storage::Streams;
...
    // Define some variables, and set values.
    Windows::Networking::Sockets::StreamSocket clientSocket;

    Windows::Networking::HostName serverHost{ L"www.contoso.com" };
    winrt::hstring serverServiceName{ L"https" };

    // For simplicity, the sample omits implementation of the
    // NotifyUser method used to display status and error messages. 

    // Try to connect to the server using HTTP (port 80).
    try
    {
        co_await clientSocket.ConnectAsync(serverHost, serverServiceName, Windows::Networking::Sockets::SocketProtectionLevel::PlainSocket);
        NotifyUser(L"Connected");
    }
    catch (winrt::hresult_error const& exception)
    {
        NotifyUser(L"Connect failed with error: " + exception.message());
        clientSocket = nullptr;
    }

    // Now, try to send some data.
    DataWriter writer{ clientSocket.OutputStream() };
    winrt::hstring hello{ L"Hello, World! ☺ " };
    uint32_t len{ writer.MeasureString(hello) }; // Gets the size of the string, in bytes.
    writer.WriteInt32(len);
    writer.WriteString(hello);
    NotifyUser(L"Client: sending hello");

    try
    {
        co_await writer.StoreAsync();
        NotifyUser(L"Client: sent hello");

        writer.DetachStream(); // Detach the stream when you want to continue using it; otherwise, the DataWriter destructor closes it.
    }
    catch (winrt::hresult_error const& exception)
    {
        NotifyUser(L"Store failed with error: " + exception.message());
        // We could retry the store operation. But, for this simple example, just close the socket by setting it to nullptr.
        clientSocket = nullptr;
        co_return;
    }

    // Now, upgrade the client to use SSL.
    try
    {
        co_await clientSocket.UpgradeToSslAsync(Windows::Networking::Sockets::SocketProtectionLevel::Tls12, serverHost);
        NotifyUser(L"Client: upgrade to SSL completed");

        // Add code to send and receive data using the clientSocket,
        // then set the clientSocket to nullptr when done to close it.
    }
    catch (winrt::hresult_error const& exception)
    {
        // If this is an unknown status, then the error is fatal and retry will likely fail.
        Windows::Networking::Sockets::SocketErrorStatus socketErrorStatus{ Windows::Networking::Sockets::SocketError::GetStatus(exception.to_abi()) };
        if (socketErrorStatus == Windows::Networking::Sockets::SocketErrorStatus::Unknown)
        {
            throw;
        }

        NotifyUser(L"Upgrade to SSL failed with error: " + exception.message());
        // We could retry the store operation. But for this simple example, just close the socket by setting it to nullptr.
        clientSocket = nullptr;
        co_return;
    }

using Windows::Networking;
using Windows::Networking::Sockets;
using Windows::Storage::Streams;

    // Define some variables and set values
    StreamSocket^ clientSocket = new ref StreamSocket();
 
    Hostname^ serverHost = new ref HostName("www.contoso.com");
    String serverServiceName = "http";

    // For simplicity, the sample omits implementation of the
    // NotifyUser method used to display status and error messages 

    // Try to connect to contoso using HTTP (port 80)
    task<void>(clientSocket->ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel::PlainSocket)).then([this] (task<void> previousTask) {
        try
        {
            // Try getting all exceptions from the continuation chain above this point.
            previousTask.Get();
            NotifyUser("Connected");
        }
        catch (Exception^ exception)
        {
            NotifyUser("Connect failed with error: " + exception->Message);
 
            clientSocket->Close();
            clientSocket = null;
        }
    });
       
    // Now try to send some data
    DataWriter^ writer = new ref DataWriter(clientSocket.OutputStream);
    String hello = "Hello, World! ☺ ";
    Int32 len = (int) writer->MeasureString(hello); // Gets the UTF-8 string length.
    writer->writeInt32(len);
    writer->writeString(hello);
    NotifyUser("Client: sending hello");

    task<void>(writer->StoreAsync()).then([this] (task<void> previousTask) {
        try {
            // Try getting all exceptions from the continuation chain above this point.
            previousTask.Get();

            NotifyUser("Client: sent hello");

            writer->DetachStream(); // Detach stream, if not, DataWriter destructor will close it.
       }
       catch (Exception^ exception) {
               NotifyUser("Store failed with error: " + exception->Message);
               // Could retry the store, but for this simple example
               // just close the socket.
 
               clientSocket->Close();
               clientSocket = null;
               return
       }
    });

    // Now upgrade the client to use SSL
    task<void>(clientSocket->UpgradeToSslAsync(clientSocket.SocketProtectionLevel.Ssl, serverHost)).then([this] (task<void> previousTask) {
        try {
            // Try getting all exceptions from the continuation chain above this point.
            previousTask.Get();

           NotifyUser("Client: upgrade to SSL completed");
           
           // Add code to send and receive data 
           // Then close clientSocket when done
        }
        catch (Exception^ exception) {
            // If this is an unknown status it means that the error is fatal and retry will likely fail.
            if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
                throw;
            }

            NotifyUser("Upgrade to SSL failed with error: " + exception.Message);

            clientSocket->Close();
            clientSocket = null; 
            return;
        }
    });

Criando conexões WebSocket seguras

Assim como as conexões de soquete tradicionais, as conexões WebSocket também podem ser criptografadas com TLS (Transport Layer Security)/Secure Sockets Layer (SSL) ao usar os recursos StreamWebSocket e MessageWebSocket para um aplicativo UWP. Na maioria dos casos, você desejará usar uma conexão WebSocket segura. Isso aumentará as chances de que sua conexão seja bem-sucedida, pois muitos proxies rejeitarão conexões WebSocket não criptografadas.

Para obter exemplos de como criar ou atualizar uma conexão de soquete seguro para um serviço de rede, consulte Como proteger conexões WebSocket com TLS/SSL.

Além da criptografia TLS/SSL, um servidor pode exigir um valor de cabeçalho Sec-WebSocket-Protocol para concluir o handshake inicial. Esse valor, representado pelas propriedades StreamWebSocketInformation.Protocol e MessageWebSocketInformation.Protocol , indica a versão do protocolo da conexão e permite que o servidor interprete corretamente o handshake de abertura e os dados que serão trocados posteriormente. Usando essas informações de protocolo, se em algum momento o servidor não puder interpretar os dados de entrada de maneira segura, a conexão poderá ser fechada.

Se a solicitação inicial do cliente não contiver esse valor ou fornecer um valor que não corresponda ao esperado pelo servidor, o valor esperado será enviado do servidor para o cliente no erro de handshake do WebSocket.

Autenticação

Como fornecer credenciais de autenticação ao se conectar pela rede.

Fornecendo um certificado de cliente com a classe StreamSocket

A classe Windows.Networking.Sockets.StreamSocket dá suporte ao uso de SSL/TLS para autenticar o servidor com o qual o aplicativo está conversando. Em determinados casos, o aplicativo também precisa se autenticar no servidor usando um certificado de cliente TLS. No Windows 10, você pode fornecer um certificado de cliente no objeto StreamSocket.Control (isso deve ser definido antes do handshake do TLS ser iniciado). Se o servidor solicitar o certificado do cliente, o Windows responderá com o certificado fornecido.

Aqui está um snippet de código mostrando como implementar isso:

var socket = new StreamSocket();
Windows.Security.Cryptography.Certificates.Certificate certificate = await GetClientCert();
socket.Control.ClientCertificate = certificate;
await socket.ConnectAsync(destination, SocketProtectionLevel.Tls12);

Fornecendo credenciais de autenticação para um serviço Web

As APIs de rede que permitem que os aplicativos interajam com serviços Web seguros fornecem seus próprios métodos para inicializar um cliente ou definir um cabeçalho de solicitação com credenciais de autenticação de servidor e proxy. Cada método é definido com um objeto PasswordCredential que indica um nome de usuário, uma senha e o recurso para o qual essas credenciais são usadas. A tabela a seguir fornece um mapeamento dessas APIs:

Manipulando exceções de rede

Na maioria das áreas de programação, uma exceção indica um problema ou falha significativo, causado por alguma falha no programa. Na programação de rede, há uma fonte adicional para exceções: a própria rede e a natureza das comunicações de rede. As comunicações de rede são inerentemente não confiáveis e propensas a falhas inesperadas. Para cada uma das maneiras pelas quais seu aplicativo usa a rede, você deve manter algumas informações de estado; e o código do aplicativo deve lidar com exceções de rede atualizando essas informações de estado e iniciando a lógica apropriada para que seu aplicativo restabeleça ou tente novamente falhas de comunicação.

Quando aplicativos Universais do Windows lançam uma exceção, o manipulador de exceções pode recuperar informações mais detalhadas sobre a causa da exceção para entender melhor a falha e tomar as decisões apropriadas.

Cada projeção de linguagem dá suporte a um método para acessar essas informações mais detalhadas. Uma exceção é projetada como um valor HRESULT em aplicativos do Windows Universal. O arquivo de inclusão Winerror.h contém uma lista muito grande de possíveis valores HRESULT que inclui erros de rede.

As APIs de rede dão suporte a métodos diferentes para recuperar essas informações detalhadas sobre a causa de uma exceção.

• Algumas APIs fornecem um método auxiliar que converte o valor HRESULT da exceção em um valor de enumeração.
• Outras APIs fornecem um método para recuperar o valor HRESULT real.

Tópicos relacionados

• Melhorias na API de Rede no Windows 10