Sdílet prostřednictvím

Základy sítí

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

Schopnosti

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.

Schopnost Popis
internetClient Poskytuje odchozí přístup k internetu a sítím na veřejných místech, jako jsou letiště a kavárna. Tuto funkci by měla používat většina aplikací, které vyžadují přístup k internetu.
internetClientServer Poskytuje aplikaci příchozí a odchozí síťový přístup z internetu a sítí na veřejných místech, jako jsou letiště a kavárny.
privateNetworkClientServer Poskytuje aplikaci příchozí a odchozí síťový přístup na důvěryhodných místech uživatele, jako je domov a práce.

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

Schopnost Popis
podnikovéOvěření Umožňuje aplikaci připojit se k síťovým prostředkům, které vyžadují přihlašovací údaje domény. Například aplikace, která načítá data ze sharepointových serverů v privátním intranetu. Pomocí této funkce můžete přihlašovací údaje použít pro přístup k síťovým prostředkům v síti, která vyžaduje přihlašovací údaje. Aplikace s touto schopností se může na síti vydávat za vás. Tuto funkci nepotřebujete, abyste aplikaci umožnili přístup k internetu přes ověřovací proxy server.

Další podrobnosti najdete v dokumentaci ke scénáři schopností Enterprise v omezené možnosti.
blízkost Vyžaduje se pro bezkontaktní komunikaci s zařízeními v těsné blízkosti počítače. Komunikace na krátkou vzdálenost může být použita k odesílání nebo připojení k aplikaci na blízkém zařízení.

Tato funkce umožňuje aplikaci přistupovat k síti, aby se připojila k zařízení v těsné blízkosti, přičemž uživatel souhlasí s odesláním pozvánky nebo přijetím pozvánky.
sdílenéUživatelskéCertifikáty Tato funkce umožňuje aplikaci přístup k softwarovým a hardwarovým certifikátům, jako jsou certifikáty čipových karet. Při vyvolání této funkce za běhu musí uživatel provést akci, například vložení karty nebo výběru certifikátu.

Díky této funkci se k identifikaci v aplikaci používají softwarové a hardwarové certifikáty nebo čipová karta. Tuto funkci může používat váš zaměstnavatel, banka nebo státní správa k identifikaci.

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

Podpora aplikace s úlohami na pozadí obsahuje obecné informace o používání úloh na pozadí k práci, pokud vaše aplikace není v popředí. Konkrétně musí váš kód provést speciální kroky, aby byl upozorněn, když není aktuální aplikací v popředí a data dorazí po síti. Pro tento účel jste ve Windows 8 použili triggery řídicího kanálu a ve Windows 10 jsou stále podporované. Úplné informace o používání spouštěčů ovládacích kanálů jsou k dispozici zde. Nová technologie ve Windows 10 poskytuje lepší funkčnost s nižší režijní zátěží v některých scénářích, jako jsou sokety streamu s podporou push oznámení: triggery aktivity soketu a zprostředkovatele soketu.

Pokud vaše aplikace používá datagramSocket, StreamSocketnebo StreamSocketListener, může vaše aplikace převést vlastnictví otevřeného soketu na zprostředkovatele soketu poskytovaného systémem a pak opustit popředí nebo dokonce ukončit. Když se na přeneseném soketu vytvoří připojení nebo na tento soket dorazí provoz, pak se aktivuje vaše aplikace nebo její určená úloha na pozadí. Pokud vaše aplikace není spuštěná, spustí se. Zprostředkovatel soketů pak vaši aplikaci upozorní pomocí SocketActivityTrigger, že dorazil nový provoz. Aplikace uvolní soket od zprostředkovatele soketu a zpracuje provoz na soketu. 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 soketů je určen k nahrazení aktivačních událostí ovládacího kanálu tam, kde je to možné, protože poskytuje stejné funkce, ale s menším omezením a menšími nároky na paměť. Zprostředkovatel soketů může používat aplikace, které nejsou aplikacemi zamykací obrazovky, a používá se stejně na telefonech jako na jiných zařízeních. Aplikace nemusí být spuštěné, když dorazí provoz, aby ho mohl aktivovat zprostředkovatel soketů. A zprostředkovatel soketů podporuje naslouchání na soketech TCP, což spouštěče řídicích kanálů 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.

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 streamovým soketem StreamSocket, který je vytvořen pomocí StreamSocketListener při příjmu příchozí komunikace, protože vyjednávání SSL/TLS jako server není implementováno třídou StreamSocket.

Existují dva způsoby zabezpečení připojení StreamSocket pomocí protokolu SSL/TLS:

  • ConnectAsync – Proveďte počáteční připojení k síťové službě a vyjednávejte okamžitě použití protokolu SSL/TLS pro veškerou komunikaci.
  • UpgradeToSslAsync – připojte se zpočátku 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 získat požadovanou úroveň ochrany, která byla použita v volání ConnectAsync nebo UpgradeToSslAsync, prostřednictvím vlastnosti StreamSocketinformation.ProtectionLevel. To ale neodráží skutečnou úroveň ochrany, která připojení používá.

Poznámka:

Váš kód by neměl implicitně záviset na použití konkrétní úrovně ochrany nebo na předpokladu, že se daná úroveň zabezpečení používá ve výchozím nastavení. Zabezpečení se neustále mění a protokoly a výchozí úrovně ochrany se v průběhu času mění, aby se zabránilo použití protokolů se známými slabými stránkami. Výchozí hodnoty se mohou lišit v závislosti na konfiguraci jednotlivých počítačů nebo na tom, který software je nainstalovaný a které opravy byly použity. Pokud vaše aplikace závisí na použití konkrétní úrovně zabezpečení, musíte tuto úroveň explicitně zadat a pak zkontrolovat, jestli se skutečně používá na vytvořeném připojení.

Použití ConnectAsync

ConnectAsync je možné 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:

Pokud je parametr protectionLevel nastaven na Windows.Networking.Sockets.SocketProtectionLevel.Ssl při volání kterékoli z výše uvedených metod ConnectAsync, StreamSocket musí být navázán pro použití šifrování pomocí protokolu SSL/TLS. 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á.

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 pomocí 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 = 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

Použijte UpgradeToSslAsync

Pokud 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 používá 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. Obvykle validationHostName by 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žít protokol SSL/TLS pro šifrování prostřednictvím soketu. 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í:

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é, veškerá síťová komunikace pomocí StreamSocket mezi klientem a síťovým serverem se zašifruje.

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

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

Stejně jako tradiční připojení soketů je možné připojení WebSocket šifrovat také pomocí protokolu TLS (Transport Layer Security) nebo SSL (Secure Sockets Layer) při použití streamWebSocket a MessageWebSocket funkcí pro aplikaci UPW. 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ího handshake vyžadovat hodnotu hlavičky Sec-WebSocket-Protocol. Tato hodnota reprezentovaná vlastnostmi StreamWebSocketInformation.Protocol a MessageWebSocketInformation.Protocol vlastnosti, označuje verzi protokolu připojení a umožňuje serveru správně interpretovat otevírání metody handshake a data, která se následně vyměňují. Pomocí těchto informací z protokolu lze připojení kdykoli ukončit, pokud server nemůže interpretovat příchozí data bezpečným způsobem.

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.

Autentizace

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ý aplikace mluví. V některých případech se aplikace musí také ověřit na serveru pomocí klientského certifikátu TLS. Ve Windows 10 můžete zadat klientský certifikát na objektu StreamSocket.Control (musí být nastaven před spuštěním metody handshake protokolu TLS). Pokud server požádá o klientský certifikát, systém 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í objektu PasswordCredential, který zahrnuje uživatelské jméno, heslo a zdroj, pro který se tyto přihlašovací údaje používají. Následující tabulka obsahuje mapování těchto rozhraní API:

Webové sokety MessageWebSocketControl.ServerCredential
MessageWebSocketControl.ProxyCredential
StreamWebSocketControl.ServerCredential
StreamWebSocketControl.ProxyCredential
Přenos na pozadí BackgroundDownloader.ServerCredential
StahovačNaPozadí.ProxyCredential
BackgroundUploader.ServerCredential
BackgroundUploader.ProxyCredential
syndikace SyndicationClient(PasswordCredential)
SyndicationClient.ServerCredential
SyndicationClient.ProxyCredential
AtomPub AtomPubClient(PasswordCredential)
AtomPubClient.ServerCredential
AtomPubClient.ProxyCredential

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ý ze způsobů, jak vaše aplikace využívá síť, musíte udržovat stavové informace. Kód aplikace musí zpracovávat výjimky sítě tak, že aktualizuje stavové informace a zahájí odpovídající logiku, aby vaše aplikace znovu navázala komunikaci nebo opakovala pokusy při selhání komunikace.

Když univerzální aplikace pro Windows 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 prezentuje jako hodnota HRESULT v univerzálních aplikacích systému Windows. Soubor Winerror.h obsahuje velmi velký seznam možných hodnot HRESULT, které zahrnují chyby sítě.

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.