Základy sítí

Věci, které musíte udělat pro libovolnou aplikaci s podporou sítě.

Capabilities

Abyste mohli používat sítě, musíte do manifestu aplikace přidat příslušné prvky schopností. Pokud se v manifestu vaší aplikace nezadá žádná síťová funkce, nebude mít aplikace žádné síťové možnosti a všechny pokusy o připojení k síti selžou.

Následují nejčastěji používané síťové funkce.

Za určitých okolností můžou být pro vaši aplikaci potřeba další možnosti.

Komunikace, když vaše aplikace není v popředí

Úlohy na pozadí poskytují obecné informace o práci, když vaše aplikace není v popředí. Konkrétně musí váš kód podniknout zvláštní kroky, aby byl upozorněn, když není aktuálně aplikací na popředí a po síti pro něj dorazí data. Triggery řídicích kanálů jsou podporovány v Windows pro tento účel. Podrobnosti najdete v tématu ControlChannelTrigger. Novější technologie poskytuje v některých scénářích lepší funkčnost s nižší režií, například pro streamové sokety s podporou push oznámení: zprostředkovatel soketů a aktivační události soketů.

Pokud vaše aplikace používá DatagramSocket, StreamSocket nebo StreamSocketListener, může vaše aplikace přenést vlastnictví otevřeného soketu na zprostředkovatele soketu poskytovaného systémem a pak opustit popředí nebo dokonce ukončit. Když je na přeneseném socketu navázáno připojení nebo na tento socket dorazí provoz, aktivuje se vaše aplikace nebo jí přiřazená úloha na pozadí. Pokud vaše aplikace není spuštěná, spustí se. Zprostředkovatel soketů pak vaši aplikaci upozorní pomocí SocketActivityTriggeru , že dorazí nový provoz. Aplikace převezme soket zpět od správce soketů a zpracovává komunikaci přes tento soket. To znamená, že vaše aplikace spotřebovává mnohem méně systémových prostředků, když aktivně nezpracovává síťový provoz.

Zprostředkovatel socketů je určen k nahrazení triggerů řídicího kanálu tam, kde je použitelný, protože poskytuje stejnou funkcionalitu, ale s menšími omezeními a menšími nároky na paměť. Zprostředkovatel socketů mohou používat aplikace, které nejsou aplikacemi pro zamykací obrazovku, a na telefonech se používá stejným způsobem jako na jiných zařízeních. Aplikace nemusí být spuštěné v okamžiku, kdy dorazí síťový provoz, aby je mohl aktivovat socket broker. A zprostředkovatel socketů podporuje naslouchání na TCP socketech, což Control Channel Triggers nepodporují.

Volba síťového triggeru

Existují některé scénáře, kdy by byl vhodný některý druh triggeru. Při výběru typu triggeru, který se má ve vaší aplikaci použít, zvažte následující rady.

• Pokud používáte IXMLHTTPRequest2, System.Net.Http.HttpClient nebo System.Net.Http.HttpClientHandler, musíte použít ControlChannelTrigger.
• Pokud používáte StreamSockets s povolenými nabízenými oznámeními, můžete použít triggery řídicího kanálu, ale měli byste dát přednost SocketActivityTrigger. Druhá volba umožňuje systému uvolnit paměť a snížit požadavky na napájení, když se připojení aktivně nepoužívá.
• Pokud chcete minimalizovat paměťové nároky své aplikace v době, kdy aktivně nezpracovává síťové požadavky, používejte, pokud je to možné, SocketActivityTrigger.
• Pokud chcete, aby vaše aplikace mohla přijímat data, když je systém v pohotovostním režimu s připojením, použijte SocketActivityTrigger.

Podrobnosti a příklady použití zprostředkovatele soketů naleznete v tématu Síťová komunikace na pozadí.

Zabezpečená připojení

Protokoly TLS (Secure Sockets Layer) a novější protokoly TLS (Transport Layer Security) jsou kryptografické protokoly navržené tak, aby poskytovaly ověřování a šifrování síťové komunikace. Tyto protokoly jsou navržené tak, aby zabránily odposlouchávání a manipulaci při odesílání a přijímání síťových dat. Tyto protokoly používají model klientského serveru pro výměnu protokolů. Tyto protokoly také používají digitální certifikáty a certifikační autority k ověření, že server je tím, za koho se deklaruje.

Vytváření zabezpečených připojení soketů

Objekt StreamSocket lze nakonfigurovat tak, aby pro komunikaci mezi klientem a serverem používal protokol SSL/TLS. Tato podpora protokolu SSL/TLS je omezená na použití objektu StreamSocket jako klienta v vyjednávání SSL/TLS. Protokol SSL/TLS nelze použít se socketem StreamSocket vytvořeným objektem StreamSocketListener při příjmu příchozí komunikace, protože třída StreamSocket neimplementuje vyjednávání SSL/TLS na straně serveru.

Připojení StreamSocket pomocí protokolu SSL/TLS můžete zabezpečit dvěma způsoby:

• ConnectAsync – Nastavte počáteční připojení k síťové službě a vyjednávejte okamžitě pro veškerou komunikaci protokol SSL/TLS.
• UpgradeToSslAsync – Nejprve se připojte k síťové službě bez šifrování. Aplikace může odesílat nebo přijímat data. Potom upgradujte připojení tak, aby pro veškerou další komunikaci používalo protokol SSL/TLS.

SocketProtectionLevel určuje požadovanou úroveň ochrany soketů, se kterou chce aplikace navázat nebo upgradovat připojení. Konečná úroveň ochrany vytvořeného připojení se ale určuje v procesu vyjednávání mezi oběma koncovými body připojení. Výsledek může být nižší než zadaná úroveň ochrany, pokud druhý koncový bod požaduje nižší úroveň.

Po úspěšném dokončení asynchronní operace můžete prostřednictvím vlastnosti StreamSocketInformation.ProtectionLevel získat požadovanou úroveň ochrany použitou při volání ConnectAsync nebo UpgradeToSslAsync. To ale neodráží skutečnou úroveň ochrany, která připojení používá.

Použití ConnectAsync

ConnectAsync se dá použít k navázání počátečního připojení k síťové službě a okamžitě vyjednat použití protokolu SSL/TLS pro veškerou komunikaci. Existují dvě metody ConnectAsync , které podporují předávání parametru protectionLevel :

• ConnectAsync(EndpointPair, SocketProtectionLevel) – spustí asynchronní operaci u objektu StreamSocket pro připojení ke vzdálenému cíli sítě určenému jako objekt EndpointPair a SocketProtectionLevel.
• ConnectAsync(HostName, String, SocketProtectionLevel) – spustí asynchronní operaci objektu StreamSocket pro připojení ke vzdálenému cíli určenému vzdáleným názvem hostitele, názvem vzdálené služby a socketProtectionLevel.

Pokud je parametr protectionLevel při volání některé z výše uvedených metod ConnectAsync nastaven na Windows.Networking.Sockets.SocketProtectionLevel.Ssl, připojení StreamSocket bude navázáno s použitím protokolu SSL/TLS k šifrování. Tato hodnota vyžaduje šifrování a nikdy neumožňuje použití šifry NULL.

Normální posloupnost, která se má použít s jednou z těchto metod ConnectAsync , je stejná.

• Vytvořte streamSocket.
• Pokud je potřeba pokročilé nastavení soketu, použijte vlastnost StreamSocket.Control k získání instance StreamSocketControl přidružené k objektu StreamSocket. Nastavte vlastnost na StreamSocketControl.
• Voláním jedné z výše uvedených metod ConnectAsync spusťte operaci pro připojení ke vzdálenému cíli a okamžitě vyjednávejte použití protokolu SSL/TLS.
• Síla PROTOKOLU SSL ve skutečnosti vyjednaná pomocí ConnectAsync může být určena získáním StreamSocketInformation.ProtectionLevel vlastnost po úspěšném dokončení asynchronní operace.

Následující příklad vytvoří StreamSocket a pokusí se navázat připojení k síťové službě a okamžitě vyjednat použití PROTOKOLU SSL/TLS. Pokud je vyjednávání úspěšné, veškerá síťová komunikace mezi klientem a síťovým serverem využívající StreamSocket bude zašifrována.

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 = ref new StreamSocket();
 
    HostName^ serverHost = ref 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 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

Použijte UpgradeToSslAsync

Když váš kód používá UpgradeToSslAsync, nejprve vytvoří připojení k síťové službě bez šifrování. Aplikace může odesílat nebo přijímat nějaká data a pak upgradovat připojení tak, aby používalo protokol SSL/TLS pro veškerou další komunikaci.

Metoda UpgradeToSslAsync přebírá dva parametry. Parametr protectionLevel označuje požadovanou úroveň ochrany. Parametr validationHostName je název hostitele cíle vzdálené sítě, který se používá k ověření při upgradu na SSL. Za normálních okolností by název validationHostName byl stejný název hostitele, který aplikace použila k počátečnímu navázání připojení. Pokud je parametr protectionLevel nastaven na Windows. System.Socket.SocketProtectionLevel.Ssl při volání UpgradeToSslAsync musí streamSocket používat protokol SSL/TLS pro šifrování při další komunikaci přes soket. Tato hodnota vyžaduje šifrování a nikdy neumožňuje použití šifry NULL.

Normální posloupnost, která se má použít s metodou UpgradeToSslAsync , je následující:

• Vytvořte streamSocket.
• Pokud je potřeba pokročilé nastavení soketu, použijte vlastnost StreamSocket.Control k získání instance StreamSocketControl přidružené k objektu StreamSocket. Nastavte vlastnost na StreamSocketControl.
• Pokud je potřeba odeslat a přijímat nešifrovaná data, odešlete je teď.
• Voláním metody UpgradeToSslAsync spusťte operaci pro upgrade připojení tak, aby používalo protokol SSL/TLS.
• Sílu SSL, která byla skutečně vyjednána pomocí UpgradeToSslAsync, lze určit získáním vlastnosti StreamSocketInformation.ProtectionLevel po úspěšném dokončení asynchronní operace.

Následující příklad vytvoří StreamSocket, pokusí se navázat připojení k síťové službě, odešle některá počáteční data a pak vyjedná použití PROTOKOLU SSL/TLS. Pokud je vyjednávání úspěšné, zašifruje se veškerá síťová komunikace pomocí streamSocketu mezi klientem a síťovým serverem.

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 = ref new StreamSocket();
 
    HostName^ serverHost = ref 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)
    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 = ref 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");

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

Vytváření zabezpečených připojení WebSocket

Stejně jako tradiční připojení soketů se připojení WebSocket dají také šifrovat pomocí protokolu TLS (Transport Layer Security)/SSL (Secure Sockets Layer) při použití funkcí StreamWebSocket a MessageWebSocket pro aplikaci Windows. Ve většině případů budete chtít použít zabezpečené připojení WebSocket. Tím se zvýší pravděpodobnost úspěšného připojení, protože mnoho proxy serverů odmítne nešifrovaná připojení WebSocket.

Příklady vytvoření nebo upgradu zabezpečeného připojení soketu k síťové službě najdete v tématu Postup zabezpečení připojení WebSocket pomocí protokolu TLS/SSL.

Kromě šifrování TLS/SSL může server k dokončení počáteční metody handshake vyžadovat hodnotu hlavičky Sec-WebSocket-Protocol . Tato hodnota reprezentovaná vlastnostmi StreamWebSocketInformation.Protocol a MessageWebSocketInformation.Protocol označuje verzi protokolu připojení a umožňuje serveru správně interpretovat otevírání handshake a data, která se následně vyměňují. Na základě těchto informací protokolu lze spojení ukončit, pokud server v kterémkoli okamžiku nedokáže bezpečně interpretovat příchozí data.

Pokud počáteční požadavek z klienta tuto hodnotu neobsahuje nebo poskytuje hodnotu, která neodpovídá očekávání serveru, je očekávaná hodnota odeslaná ze serveru klientovi při chybě handshake protokolu WebSocket.

Authentication

Jak zadat přihlašovací údaje pro ověřování při připojování přes síť.

Poskytnutí klientského certifikátu s třídou StreamSocket

Třída Windows.Networking.Sockets.StreamSocket podporuje použití protokolu SSL/TLS k ověření serveru, se kterým aplikace komunikuje. V některých případech se aplikace musí také ověřit na serveru pomocí klientského certifikátu TLS. V Windows 10 můžete v objektu StreamSocket.Control zadat klientský certifikát (musí být nastaven před spuštěním metody handshake protokolu TLS). Pokud server požádá o klientský certifikát, Windows odpoví zadaným certifikátem.

Tady je fragment kódu, který ukazuje, jak tento kód implementovat:

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

Poskytnutí přihlašovacích údajů pro ověřování webové službě

Síťová rozhraní API, která aplikacím umožňují pracovat se zabezpečenými webovými službami, poskytují vlastní metody inicializace klienta nebo nastavení hlavičky požadavku pomocí přihlašovacích údajů serveru a proxy serveru. Každá metoda je nastavena pomocí PasswordCredential objekt, který označuje uživatelské jméno, heslo a prostředek, pro který se tyto přihlašovací údaje používají. Následující tabulka obsahuje mapování těchto rozhraní API:

Zpracování výjimek sítě

Ve většině oblastí programování výjimka značí významný problém nebo selhání způsobené určitou chybou v programu. V programování sítě existuje další zdroj výjimek: samotná síť a povaha síťové komunikace. Síťová komunikace je ze své podstaty nespolehlivé a náchylné k neočekávanému selhání. Pro každý způsob, jakým vaše aplikace využívá síťovou komunikaci, musíte udržovat určité stavové informace; kód aplikace pak musí zpracovávat síťové výjimky tak, aby tyto stavové informace aktualizoval a spouštěl odpovídající logiku, která aplikaci umožní znovu navázat komunikaci nebo zopakovat pokus po selhání komunikace.

Když univerzální Windows aplikace vyvolá výjimku, může obslužná rutina výjimky načíst podrobnější informace o příčině výjimky, aby lépe porozuměla selhání a udělala vhodná rozhodnutí.

Každá projekce jazyka podporuje metodu pro přístup k podrobnějším informacím. Výjimka se v aplikacích pro Universal Windows promítá jako hodnota HRESULT. Hlavičkový soubor Winerror.h obsahuje velmi rozsáhlý seznam možných hodnot HRESULT, který zahrnuje i síťové chyby.

Síťová rozhraní API podporují různé metody načítání těchto podrobných informací o příčině výjimky.

• Některá rozhraní API poskytují pomocnou metodu, která převede hodnotu HRESULT z výjimky na hodnotu výčtu.
• Jiná rozhraní API poskytují metodu pro načtení skutečné hodnoty HRESULT .