A hálózatkezelés alapjai

Minden hálózati kompatibilis alkalmazás esetében el kell végeznie a szükséges műveleteket.

Képességek

A hálózatkezelés használatához hozzá kell adnia a megfelelő képességelemeket az alkalmazásjegyzékhez. Ha az alkalmazás jegyzékében nincs megadva hálózati képesség, az alkalmazás nem rendelkezik hálózati képességgel, és a hálózathoz való kapcsolódási kísérletek sikertelenek lesznek.

Az alábbiak a leggyakrabban használt hálózati képességek.

Képesség	Leírás
internetClient	Kimenő hozzáférést biztosít az internethez és a nyilvános helyeken lévő hálózatokhoz, például a repülőterekhez és a kávézókhoz. Az internetelérést igénylő legtöbb alkalmazásnak ezt a képességet kell használnia.
internetClientServer	Bejövő és kimenő hálózati hozzáférést biztosít az alkalmazásnak az internetről, valamint nyilvános helyeken, például repülőtereken és kávézókban lévő hálózatokhoz.
privateNetworkClientServer	Az alkalmazás bejövő és kimenő hálózati hozzáférését biztosítja a felhasználó megbízható pontjain, például otthon és munkahelyen.

Bizonyos körülmények között más képességekre is szükség lehet az alkalmazáshoz.

Képesség	Leírás
vállalati hitelesítés	Lehetővé teszi az alkalmazások számára, hogy tartományi hitelesítő adatokat igénylő hálózati erőforrásokhoz csatlakozzanak. Például egy olyan alkalmazás, amely adatokat kér le a Privát intraneten lévő SharePoint-kiszolgálókról. Ezzel a képességgel hitelesítő adataival elérheti a hitelesítő adatokat igénylő hálózaton lévő hálózati erőforrásokat. Egy ilyen képességgel rendelkező alkalmazás megszemélyesítheti Önt a hálózaton. Nincs szükség erre a képességre ahhoz, hogy az alkalmazás hitelesítő proxyn keresztül férhessen hozzá az internethez. További részletekért tekintse meg a Nagyvállalati képességforgatókönyv dokumentációját Korlátozott képességek.
közelség	A számítógép közvetlen közelében lévő eszközökkel való közelségi kommunikációhoz szükséges. Közeli közelség használható alkalmazás közeli eszközön való küldéséhez vagy az alkalmazáshoz való csatlakozáshoz. Ez a funkció lehetővé teszi, hogy az alkalmazás hozzáférjen a hálózathoz, hogy a közelben lévő eszközhöz csatlakozzon, és a felhasználó hozzájárult a meghívás elküldéséhez vagy a meghívás elfogadásához.
megosztottFelhasználóiTanúsítványok	Ez a funkció lehetővé teszi az alkalmazások számára a szoftver- és hardvertanúsítványok, például az intelligenskártya-tanúsítványok elérését. Ha a rendszer futásidőben hívja meg ezt a képességet, a felhasználónak végre kell hajtania a műveletet, például be kell szúrnia egy kártyát, vagy ki kell választania egy tanúsítványt. Ezzel a képességgel a szoftver- és hardvertanúsítványokat vagy intelligens kártyát használja az alkalmazás azonosításra. Ezt a képességet használhatja munkáltatója, bankja vagy kormányzati szolgálata azonosításra.

Kommunikáció, ha az alkalmazás nem az előtérben van

Az alkalmazás támogatása háttérfeladatokkal, általános információkat tartalmaz arról, hogy a háttérfeladatok milyen módon működnek, ha az alkalmazás nincs az előtérben. Pontosabban a kódnak speciális lépéseket kell tennie, hogy értesítést kapjon, ha nem az aktuális előtéralkalmazás, és az adatok a hálózaton keresztül érkeznek hozzá. Erre a célra a Control Channel-eseményindítókat használta a Windows 8-ban, és továbbra is támogatottak a Windows 10-ben. A Control Channel triggerek használatáról teljes körű információ itt érhető el. A Windows 10 egy új technológiája jobb funkcionalitást biztosít alacsonyabb erőforrásigénnyel bizonyos esetekben, például a push-engedélyezett stream-aljzatoknál: az aljzatközvetítő és az aljzattevékenységi indítók.

Ha az alkalmazás DatagramSocket, StreamSocketvagy StreamSocketListenerhasznál, akkor az alkalmazás átadhatja a nyitott szoftvercsatornák tulajdonjogát a rendszer által biztosított szoftvercsatorna-közvetítőnek, majd elhagyhatja az előteret, vagy akár leállhat. Ha kapcsolat jön létre az átvitt szoftvercsatornán, vagy a forgalom erre a szoftvercsatornára érkezik, a rendszer aktiválja az alkalmazást vagy annak kijelölt háttérfeladatát. Ha az alkalmazás nem fut, elindul. A socket közvetítő ezután a SocketActivityTrigger használatával értesíti az alkalmazást, hogy új forgalom érkezett. Az alkalmazás visszaszerzi a csatlakozót a socket közvetítőtől, és feldolgozza a csatlakozón lévő forgalmat. Ez azt jelenti, hogy az alkalmazás sokkal kevesebb rendszererőforrást használ fel, ha nem dolgoz fel aktívan hálózati forgalmat.

A socket közvetítő a Vezérlőcsatorna-eseményindítók lecserélésére szolgál, ahol alkalmazható, mivel ugyanazt a funkciót biztosítja, de kevesebb korlátozással és kisebb memóriaigénnyel. A szoftvercsatorna-közvetítőt olyan alkalmazások is használhatják, amelyek nem zárolják a képernyőalkalmazásokat, és ugyanúgy használják a telefonokon, mint más eszközökön. Az alkalmazásoknak nem kell futniuk, amikor a forgalom megérkezik ahhoz, hogy a socket közvetítő aktiválja őket. Az socket broker támogatja a TCP socketek figyelését, amelyet a vezérlőcsatorna-triggerek nem támogatnak.

Hálózati eseményindító kiválasztása

Vannak olyan forgatókönyvek, amikor bármelyik eseményindító megfelelő lenne. Ha kiválasztja, hogy milyen eseményindítót használjon az alkalmazásban, vegye figyelembe az alábbi tanácsokat.

• Ha Ön a IXMLHTTPRequest2, a System.Net.Http.HttpClient vagy a System.Net.Http.HttpClientHandlerhasználja, akkor a ControlChannelTriggerkell használnia.
• Ha leküldéses StreamSocketshasznál, használhat vezérlőcsatorna-eseményindítókat, viszont inkább a(z) SocketActivityTriggerpreferálja. Az utóbbi választás lehetővé teszi a rendszer számára, hogy felszabadítsa a memóriát, és csökkentse az energiaigényt, ha a kapcsolatot nem használják aktívan.
• Ha szeretné minimalizálni az alkalmazás memóriaigényét, ha az nem aktívan szervizeli a hálózati kéréseket, lehetőleg SocketActivityTrigger.
• Ha azt szeretné, hogy az alkalmazás képes legyen adatokat fogadni, amíg a rendszer csatlakoztatott készenléti módban van, használja SocketActivityTrigger.

A socket broker használatára vonatkozó részletekért és példákért lásd a háttérben zajló hálózati kommunikációrészt.

Biztonságos kapcsolatok

A Secure Sockets Layer (SSL) és a legújabb Transport Layer Security (TLS) titkosítási protokollok, amelyek a hálózati kommunikáció hitelesítését és titkosítását biztosítják. Ezek a protokollok úgy vannak kialakítva, hogy megakadályozzák a lehallgatást és a illetéktelen hozzáférést a hálózati adatok küldésekor és fogadásakor. Ezek a protokollok ügyfél-kiszolgáló modellt használnak a protokollcserékhez. Ezek a protokollok digitális tanúsítványokat és hitelesítésszolgáltatókat is használnak annak ellenőrzésére, hogy a kiszolgáló az, akinek állítja.

Biztonságos socketkapcsolatok létrehozása

A StreamSocket objektum úgy konfigurálható, hogy SSL/TLS protokollt használjon az ügyfél és a kiszolgáló közötti kommunikációhoz. Az SSL/TLS támogatása csak a StreamSocket objektumot használja ügyfélként az SSL-/TLS-egyeztetésben. Az SSL/TLS nem használható a StreamSocketListener által létrehozott StreamSocket a bejövő kommunikáció fogadásakor, mert az SSL/TLS-egyeztetést kiszolgálóként nem implementálja a StreamSocket osztály.

A StreamSocket SSL-/TLS-kapcsolatának kétféleképpen lehet biztonságossá tenni:

• ConnectAsync – Hozzon létre kezdeti kapcsolatot egy hálózati szolgáltatással, és azonnal tárgyaljon az SSL/TLS minden kommunikációhoz való használatáról.
• UpgradeToSslAsync – Kezdetben titkosítás nélküli hálózati szolgáltatáshoz csatlakozhat. Az alkalmazás adatokat küldhet vagy fogadhat. Ezután frissítse a kapcsolatot az SSL/TLS használatára minden további kommunikációhoz.

A SocketProtectionLevel megadja azt a kívánt szoftvercsatorna-védelmi szintet, amellyel az alkalmazás létre szeretné hozni vagy frissíteni szeretné a kapcsolatot. A létrehozott kapcsolat végső védelmi szintjét azonban a kapcsolat mindkét végpontja közötti egyeztetési folyamat határozza meg. Az eredmény alacsonyabb védelmi szint lehet, mint a megadott, ha a másik végpont alacsonyabb szintet kér.

Miután az aszinkron művelet sikeresen befejeződött, lekérheti a ConnectAsync vagy UpgradeToSslAsync híváshoz használt védelmi szintet a StreamSocketinformation.ProtectionLevel tulajdonságon keresztül. Ez azonban nem tükrözi a kapcsolat tényleges védelmi szintjét.

Megjegyzés:

A kód nem függhet implicit módon egy adott védelmi szint használatától, vagy attól a feltételezéstől, hogy alapértelmezés szerint egy adott biztonsági szintet használnak. A biztonsági környezet folyamatosan változik, a protokollok és az alapértelmezett védelmi szintek pedig idővel változnak, hogy elkerülhető legyen az ismert gyengeségekkel rendelkező protokollok használata. Az alapértelmezett beállítások az egyes gépkonfigurációktól, illetve a telepített szoftverektől és az alkalmazott javításoktól függően változhatnak. Ha az alkalmazás egy adott biztonsági szinttől függ, akkor explicit módon meg kell adnia ezt a szintet, majd ellenőriznie kell, hogy valóban használatban van-e a létrehozott kapcsolaton.

A ConnectAsync használata

ConnectAsync használható a hálózati szolgáltatással való kezdeti kapcsolat létrehozásához, majd azonnal egyeztethet az SSL/TLS minden kommunikációhoz való használatáról. Két ConnectAsync metódus támogatja a protectionLevel paraméter átadását:

• ConnectAsync(EndpointPair, SocketProtectionLevel) – Aszinkron műveletet indít el egy StreamSocket objektumon, amely egy EndpointPair objektumként és SocketProtectionLevelként megadott távoli hálózati célhoz csatlakozik.
• ConnectAsync(HostName, String, SocketProtectionLevel) – Aszinkron műveletet indít el egy StreamSocket objektumon, hogy távoli állomásnév, távoli szolgáltatásnév és SocketProtectionLeveláltal megadott távoli célhoz csatlakozzon.

Ha a protectionLevel paraméter a Windows.Networking.Sockets.SocketProtectionLevel.Ssl értékre van állítva a fent említett ConnectAsync metódusok meghívásakor, akkor a StreamSocket létrehozásának biztosítania kell az SSL/TLS szerinti titkosítást. Ez az érték titkosítást igényel, és soha nem teszi lehetővé NULL titkosítás használatát.

Az alábbi ConnectAsync metódusok egyikével használható normál sorozat ugyanaz.

• Hozzon létre egy StreamSocket.
• Ha haladó beállításra van szükség a csatlakozón, használja a StreamSocket.Control tulajdonságot az StreamSocketControl példány lekéréséhez egy StreamSocket objektumhoz. Állítson be egy tulajdonságot a StreamSocketControl.
• A fenti ConnectAsync metódusok egyikének meghívásával elindíthat egy műveletet egy távoli célhoz való csatlakozáshoz, és azonnal egyeztetheti az SSL/TLS használatát.
• A ConnectAsync használatával ténylegesen egyeztetett SSL-erősség a StreamSocketinformation.ProtectionLevel tulajdonság lekérésével határozható meg, miután az aszinkron művelet sikeresen befejeződött.

Az alábbi példa létrehoz egy StreamSocket, és megpróbál kapcsolatot létesíteni a hálózati szolgáltatással, és azonnal tárgyalni az SSL/TLS használatára. Ha a tárgyalás sikeres, a StreamSocketet használó összes hálózati kommunikáció az ügyfél között, a hálózati kiszolgáló titkosítva lesz.

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

Az UpgradeToSslAsync használata

Amikor a kód UpgradeToSslAsynchasznál, először titkosítás nélkül létesít kapcsolatot egy hálózati szolgáltatással. Az alkalmazás adatokat küldhet vagy fogadhat, majd frissítheti a kapcsolatot az SSL/TLS használatára minden további kommunikációhoz.

A UpgradeToSslAsync metódus két paramétert használ. A protectionLevel paraméter a kívánt védelmi szintet jelzi. A validationHostName paraméter annak a távoli hálózati célhelynek a gazdagépneve, amelyet az SSL-re való frissítéskor az ellenőrzéshez használnak. Az validationHostName általában ugyanaz a gazdagépnév lesz, mint amelyet az alkalmazás használt a kapcsolat kezdeti létrehozásához. Ha a protectionLevel paraméter a Windows.System.Socket.SocketProtectionLevel.Ssl értékre van állítva UpgradeToSslAsynchívásakor, a StreamSocket az SSL/TLS protokollt kell használnia a szoftvercsatornán keresztüli további kommunikáció titkosításához. Ez az érték titkosítást igényel, és soha nem teszi lehetővé NULL titkosítás használatát.

A UpgradeToSslAsync metódussal használható normál sorrend a következő:

• Hozzon létre egy StreamSocket.
• Ha haladó beállításra van szükség a csatlakozón, használja a StreamSocket.Control tulajdonságot az StreamSocketControl példány lekéréséhez egy StreamSocket objektumhoz. Állítson be egy tulajdonságot a StreamSocketControl.
• Ha bármilyen adatot titkosítatlanul kell elküldeni és fogadni, küldje el most.
• A UpgradeToSslAsync metódus meghívásával elindíthat egy műveletet a kapcsolat SSL/TLS használatára való frissítéséhez.
• A UpgradeToSslAsync használatával ténylegesen egyeztetett SSL-erősség a StreamSocketinformation.ProtectionLevel tulajdonság lekérésével határozható meg, miután az aszinkron művelet sikeresen befejeződött.

Az alábbi példa létrehoz egy StreamSocket, megpróbál kapcsolatot létesíteni a hálózati szolgáltatással, kezdeti adatokat küld, majd egyeztetést folytat az SSL/TLS használatára. Ha a tárgyalás sikeres, az ügyfél és a hálózati kiszolgáló közötti StreamSocket használó összes hálózati kommunikáció titkosítva lesz.

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

Biztonságos WebSocket-kapcsolatok létrehozása

A hagyományos szoftvercsatornás kapcsolatokhoz hasonlóan a WebSocket-kapcsolatok is titkosíthatók a Transport Layer Security (TLS)/Secure Sockets Layer (SSL) használatával a StreamWebSocket és MessageWebSocket funkcióival egy UWP-alkalmazáshoz. A legtöbb esetben biztonságos WebSocket-kapcsolatot szeretne használni. Ez növeli a kapcsolat sikerességét, mivel számos proxy elutasítja a titkosítatlan WebSocket-kapcsolatokat.

Ha példákat keres arra, hogyan hozhat létre vagy frissíthet biztonságos socket kapcsolatot egy hálózati szolgáltatáshoz, lásd: Hogyan tegyük biztonságossá a WebSocket-kapcsolatokat TLS/SSL használatával.

A TLS/SSL-titkosítás mellett a kiszolgálónak szüksége lehet egy Sec-WebSocket-Protocol fejlécértékre a kezdeti kézfogás elvégzéséhez. Ez az érték, amelyet a StreamWebSocketInformation.Protocol és MessageWebSocketInformation.Protocol tulajdonságok jelölnek, a kapcsolat protokollverzióját jelzi, és lehetővé teszi, hogy a kiszolgáló megfelelően értelmezze a nyitó kézfogást és a később kicserélt adatokat. Ha a kiszolgáló nem tudja biztonságosan értelmezni a bejövő adatokat, a protokolladatok használatával bármikor bezárható a kapcsolat.

Ha az ügyfél kezdeti kérése vagy nem tartalmazza ezt az értéket, vagy olyan értéket ad meg, amely nem egyezik meg a kiszolgáló által várt értékkel, a rendszer a várt értéket a WebSocket kézfogási hiba miatt küldi el a kiszolgálóról az ügyfélnek.

Hitelesítés

Hitelesítő adatok megadása hálózati csatlakozáskor.

Ügyféltanúsítvány biztosítása a StreamSocket-osztállyal

A Windows.Networking.Sockets.StreamSocket osztály támogatja az SSL/TLS használatát annak a kiszolgálónak a hitelesítéséhez, amiről az alkalmazás beszél. Bizonyos esetekben az alkalmazásnak TLS-ügyféltanúsítvány használatával is hitelesítenie kell magát a kiszolgálón. A Windows 10-ben ügyféltanúsítványt adhat meg a StreamSocket.Control objektumon (ezt a TLS kézfogás megkezdése előtt be kell állítani). Ha a kiszolgáló az ügyféltanúsítványt kéri, a Windows a megadott tanúsítvánnyal válaszol.

Íme egy kódrészlet, amely bemutatja, hogyan implementálhatja ezt:

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

Hitelesítési hitelesítő adatok megadása egy webszolgáltatás számára

Azok a hálózati API-k, amelyek lehetővé teszik az alkalmazások számára a biztonságos webszolgáltatásokkal való interakciót, saját metódusokat biztosítanak az ügyfél inicializálásához, vagy egy kérés fejlécének beállításához kiszolgáló- és proxyhitelesítési hitelesítő adatokkal. Minden metódus egy PasswordCredential objektummal van beállítva, amely egy felhasználónevet, jelszót és azt az erőforrást jelöli, amelyhez ezeket a hitelesítő adatokat használják. Az alábbi táblázat az alábbi API-k leképezését tartalmazza:

WebSockets	MessageWebSocketControl.ServerCredential
	MessageWebSocketControl.ProxyCredential
	StreamWebSocketControl.ServerCredential
	StreamWebSocketControl.ProxyCredential
háttérátvitel	BackgroundDownloader.ServerCredential
	BackgroundDownloader.ProxyCredential
	BackgroundUploader.ServerCredential
	BackgroundUploader.ProxyCredential
Szindikáció	SyndicationClient(PasswordCredential)
	SyndicationClient.ServerCredential
	SyndicationClient.ProxyCredential
AtomPub	AtomPubClient(PasswordCredential)
	AtomPubClient.ServerCredential
	AtomPubClient.ProxyCredential

Hálózati kivételek kezelése

A programozás legtöbb területén a kivétel jelentős problémát vagy hibát jelez, amelyet a program valamilyen hibája okoz. A hálózati programozásban a kivételeknek további forrása van: maga a hálózat és a hálózati kommunikáció jellege. A hálózati kommunikáció eredendően megbízhatatlan, és váratlan meghibásodásra hajlamos. Az alkalmazás által a hálózatkezelés minden egyes módja esetén fenn kell tartania bizonyos állapotinformációkat; és az alkalmazás kódjának kezelnie kell a hálózati kivételeket az állapotinformációk frissítésével, valamint az alkalmazás megfelelő logikájának elindításával a kommunikációs hibák újbóli létrehozásához vagy újrapróbálkozásához.

Ha az univerzális Windows-alkalmazások kivételt okoznak, a kivételkezelő részletesebb információkat tud lekérni a kivétel okáról a hiba jobb megértése és a megfelelő döntések meghozatala érdekében.

Minden nyelvi kivetítés támogatja a részletesebb információk elérésére vonatkozó módszert. A kivétel megjelenik HRESULT értékként univerzális Windows-alkalmazásokban. A Winerror.h beépített fájl nagyon nagy listát tartalmaz a lehetséges HRESULT értékekről, amelyek között hálózati hibák is szerepelnek.

A hálózati API-k különböző módszereket támogatnak a kivétel okával kapcsolatos részletes információk lekéréséhez.

• Egyes API-k olyan segédmetódust biztosítanak, amely a kivételből származó HRESULT értéket enumerálási értékké alakítja.
• Más API-k a tényleges HRESULT érték lekérésére szolgálnak.

Kapcsolódó témakörök

• Hálózati API fejlesztései a Windows 10