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.

Capabilities

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 Description
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 Description
enterpriseAuthentication 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 alkalmazás, amely adatokat kér le SharePoint privát intranetes 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 Korlátozott képességek nagyvállalati képességforgatókönyvének dokumentációját.
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.
sharedUserCertificates 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

A háttérfeladatok általános információkat nyújtanak a munkáról, ha az alkalmazás nem az előtérben van. Pontosabban a kódnak külön intézkedéseket kell tennie ahhoz, hogy értesítést kapjon, amikor nem éppen az aktuális előtérben lévő alkalmazás, és hálózati adatok érkeznek számára. A Windows támogatja az erre a célra szolgáló vezérlőcsatorna-eseményindítókat. További részletekért lásd: ControlChannelTrigger. Egy újabb technológia jobb funkcionalitást nyújt kisebb többletterheléssel bizonyos esetekben, például a leküldést támogató streamfoglalatok esetében: a foglalatközvetítő és a foglalattevékenység-eseményindítók.

Ha az alkalmazás DatagramSocketet, StreamSocketet vagy StreamSocketListenert haszná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őtérben, 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 socketközvetítő ezután a SocketActivityTrigger segítségével jelzi az alkalmazásnak, hogy új forgalom érkezett. Az alkalmazás visszaveszi a socketet a socketközvetítőtől, és feldolgozza a socket forgalmát. 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 szoftközvetítő a Control Channel-triggerek kiváltására szolgál ott, ahol használható, mert ugyanazt a funkcionalitást biztosítja, de kevesebb megkötéssel é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 ahhoz, hogy a foglalatközvetítő aktiválja őket, amikor forgalom érkezik. A socketközvetítő támogatja a TCP-socketeken való figyelést, amit a Control Channel 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.

A foglalatközvetítő használatával kapcsolatos részletekért és példákért lásd: Háttérbeli hálózati kommunikáció.

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 foglalatkapcsolatok létrehozása

Egy 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 objektum ügyfélként való használatára korlátozódik az SSL/TLS-egyeztetés során. Nem használhat SSL/TLS protokollt a StreamSocketListener által létrehozott StreamSockettel bejövő kommunikáció fogadásakor, mert az SSL/TLS-egyeztetés kiszolgálóként nem implementálható a StreamSocket osztály által.

A StreamSocket-kapcsolatot kétféleképpen lehet biztonságossá tenni SSL/TLS használatával:

  • 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 – Először csatlakozzon egy hálózati szolgáltatáshoz titkosítás nélkül. 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.

Az aszinkron művelet sikeres befejezése után a StreamSocketInformation.ProtectionLevel tulajdonságon keresztül lekérheti a ConnectAsync vagy az UpgradeToSslAsync hívásban használt védelmi szintet. Ez azonban nem tükrözi a kapcsolat tényleges védelmi szintjét.

Note

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

A ConnectAsync segítségével létrehozhatja a kezdeti kapcsolatot egy hálózati szolgáltatással, majd azonnal egyeztethet az SSL/TLS minden kommunikációhoz való használatához. Két ConnectAsync metódus támogatja a védelmi szint paraméter átadását:

Ha a protectionLevel paraméter értéke a fenti ConnectAsync metódusok bármelyikének meghívásakor Windows.Networking.Sockets.SocketProtectionLevel.Ssl értékre van állítva, a StreamSocket úgy jön létre, hogy titkosításhoz SSL/TLS-t használ. Ez az érték titkosítást igényel, és soha nem teszi lehetővé NULL titkosítás használatát.

Az ilyen ConnectAsync metódusok egyikével használható normál sorrend ugyanaz.

  • Hozzon létre egy StreamSocketet.
  • Ha speciális beállításra van szükség a socketen, a StreamSocket.Control tulajdonsággal lekérheti a StreamSocket objektumhoz társított StreamSocketControl példányt. Állítson be egy tulajdonságot a StreamSocketControlon.
  • 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 StreamSocketet , é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 hálózati kiszolgáló által használt StreamSocket használatával folytatott összes hálózati kommunikáció 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 = 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

Az UpgradeToSslAsync használata

Amikor a kód a UpgradeToSslAsync szolgáltatást használja, 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.

Az 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. Normál esetben a validationHostName ugyanaz a gazdagépnév lenne, amelyet az alkalmazás a kapcsolat kezdeti létrehozásához használt. Ha a protectionLevel paraméter értéke Windows.System.Socket.SocketProtectionLevel.Ssl értékre van állítva az UpgradeToSslAsync meghívásakor, a StreamSocketnek SSL/TLS-t kell használnia a titkosításhoz a socketen keresztüli további kommunikáció során. Ez az érték titkosítást igényel, és soha nem teszi lehetővé NULL titkosítás használatát.

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

  • Hozzon létre egy StreamSocketet.
  • Ha speciális beállításra van szükség a socketen, a StreamSocket.Control tulajdonsággal lekérheti a StreamSocket objektumhoz társított StreamSocketControl példányt. Állítson be egy tulajdonságot a StreamSocketControlon.
  • Ha bármilyen adatot titkosítatlanul kell elküldeni és fogadni, küldje el most.
  • Hívja meg az UpgradeToSslAsync metódust, hogy elindítsa a műveletet a kapcsolat SSL/TLS használatára való frissítéséhez.
  • Az 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 StreamSocketet, megpróbál kapcsolatot létesíteni a hálózati szolgáltatással, elküld néhány kezdeti adatot, majd egyezteti az SSL/TLS használatát. Ha a tárgyalás sikeres, az ügyfél és a hálózati kiszolgáló közötti StreamSocket használatával folytatott ö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 = 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;
        }
    });

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, ha a StreamWebSocket és a MessageWebSocket szolgáltatást használják egy Windows-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 szeretne arra, hogyan hozhat létre vagy hogyan frissíthet egy hálózati szolgáltatáshoz tartozó biztonságos socketkapcsolatra, olvassa el a következőt: A WebSocket-kapcsolatok TLS-/SSL használatával történő biztonságossá tétele.

A TLS/SSL-titkosítás mellett előfordulhat, hogy a kiszolgálónak sec-WebSocket-Protocol fejlécértéket kell megadnia a kezdeti kézfogás elvégzéséhez. Ez az érték, amelyet a StreamWebSocketInformation.Protocol és a MessageWebSocketInformation.Protocol tulajdonságok jelölnek, a kapcsolat protokollverzióját jelzi, és lehetővé teszi a kiszolgáló számára, hogy helyesen é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.

Authentication

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

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

A Windows. A 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 megadhat egy ügyféltanúsítványt a StreamSocket.Control objektumon (ezt a TLS kézfogás megkezdése előtt kell beállítani). Ha a kiszolgáló kéri az ügyféltanúsítványt, 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.

Amikor az univerzális Windows-alkalmazások kivételt okoznak, a kivételkezelő részletesebb információkat kaphat 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 HRESULT-értékként jelenik meg az Univerzális Windows-alkalmazásokban. A Winerror.h include fájl nagyon nagy listát tartalmaz a lehetséges HRESULT értékekről, amelyek hálózati hibákat tartalmaznak.

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 a 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.
  • Last updated on