Bagikan melalui

Dasar-dasar jaringan

  • Artikel

Hal-hal yang harus Anda lakukan untuk aplikasi berkemampuan jaringan apa pun.

Kemampuan

Untuk menggunakan jaringan, Anda harus menambahkan elemen kemampuan yang sesuai ke manifes aplikasi Anda. Jika tidak ada kemampuan jaringan yang ditentukan dalam manifes aplikasi Anda, aplikasi Anda tidak akan memiliki kemampuan jaringan, dan upaya apa pun untuk terhubung ke jaringan akan gagal.

Berikut ini adalah kemampuan jaringan yang paling banyak digunakan.

Kemampuan Deskripsi
internetClient Menyediakan akses keluar ke Internet dan jaringan di tempat umum, seperti bandara dan kedai kopi. Sebagian besar aplikasi yang memerlukan akses Internet harus menggunakan kemampuan ini.
internetClientServer Memberi aplikasi akses jaringan masuk dan keluar dari Internet dan jaringan di tempat umum seperti bandara dan kedai kopi.
privateNetworkClientServer Memberi aplikasi akses jaringan masuk dan keluar di tempat tepercaya pengguna, seperti rumah dan tempat kerja.

Ada kemampuan lain yang mungkin diperlukan untuk aplikasi Anda, dalam keadaan tertentu.

Kemampuan Deskripsi
enterpriseAuthentication Memungkinkan aplikasi tersambung ke sumber daya jaringan yang memerlukan kredensial domain. Misalnya, aplikasi yang mengambil data dari server SharePoint di Intranet privat. Dengan kemampuan ini, kredensial Anda dapat digunakan untuk mengakses sumber daya jaringan di jaringan yang memerlukan kredensial. Aplikasi dengan kemampuan ini dapat meniru Anda di jaringan. Anda tidak memerlukan kemampuan ini untuk memungkinkan aplikasi Anda mengakses Internet melalui proksi autentikasi.

Untuk detail selengkapnya, lihat dokumentasi untuk skenario Kemampuan perusahaan dalam Kemampuan terbatas.
kedekatan Diperlukan untuk komunikasi kedekatan bidang dekat dengan perangkat yang berdekatan dengan komputer. Kedekatan di dekat bidang dapat digunakan untuk mengirim atau menyambungkan dengan aplikasi pada perangkat terdekat.

Kemampuan ini memungkinkan aplikasi mengakses jaringan untuk terhubung ke perangkat dalam jarak dekat, dengan persetujuan pengguna untuk mengirim undangan atau menerima undangan.
sharedUserCertificates Kemampuan ini memungkinkan aplikasi untuk mengakses sertifikat perangkat lunak dan perangkat keras, seperti sertifikat kartu pintar. Ketika kemampuan ini dipanggil pada runtime, pengguna harus mengambil tindakan, seperti memasukkan kartu atau memilih sertifikat.

Dengan kemampuan ini, sertifikat perangkat lunak dan perangkat keras Anda atau kartu pintar digunakan untuk identifikasi di aplikasi. Kemampuan ini dapat digunakan oleh majikan, bank, atau layanan pemerintah Anda untuk identifikasi.

Berkomunikasi saat aplikasi Anda tidak berada di latar depan

Dukung aplikasi Anda dengan tugas latar belakang berisi informasi umum tentang menggunakan tugas latar belakang untuk melakukan pekerjaan saat aplikasi Anda tidak berada di latar depan. Lebih khusus lagi, kode Anda harus mengambil langkah khusus untuk diberi tahu ketika bukan aplikasi latar depan dan data saat ini yang tiba melalui jaringan untuk itu. Anda menggunakan Pemicu Saluran Kontrol untuk tujuan ini di Windows 8, dan masih didukung di Windows 10. Informasi lengkap tentang menggunakan Pemicu Saluran Kontrol tersedia di sini. Teknologi baru di Windows 10 menyediakan fungsionalitas yang lebih baik dengan overhead yang lebih rendah untuk beberapa skenario, seperti soket aliran yang diaktifkan push: broker soket dan pemicu aktivitas soket.

Jika aplikasi Anda menggunakan DatagramSocket, StreamSocket, atau StreamSocketListener, aplikasi Anda dapat mentransfer kepemilikan soket terbuka ke broker soket yang disediakan oleh sistem, lalu meninggalkan latar depan, atau bahkan mengakhiri. Saat koneksi dibuat pada soket yang ditransfer, atau lalu lintas tiba di soket tersebut, aplikasi Anda atau tugas latar belakang yang ditunjuk diaktifkan. Jika aplikasi Anda tidak berjalan, aplikasi dimulai. Broker soket kemudian memberi tahu aplikasi Anda menggunakan SocketActivityTrigger bahwa lalu lintas baru telah tiba. Aplikasi Anda merebut kembali soket dari broker soket dan memproses lalu lintas pada soket. Ini berarti bahwa aplikasi Anda menggunakan sumber daya sistem yang jauh lebih sedikit ketika tidak secara aktif memproses lalu lintas jaringan.

Broker soket dimaksudkan untuk menggantiKan Pemicu Saluran Kontrol jika berlaku, karena menyediakan fungsionalitas yang sama, tetapi dengan pembatasan yang lebih sedikit dan jejak memori yang lebih kecil. Broker soket dapat digunakan oleh aplikasi yang tidak mengunci aplikasi layar, dan digunakan dengan cara yang sama pada ponsel seperti pada perangkat lain. Aplikasi tidak perlu berjalan ketika lalu lintas tiba untuk diaktifkan oleh broker soket. Dan broker soket mendukung mendengarkan soket TCP, yang tidak didukung Oleh Pemicu Saluran Kontrol.

Memilih pemicu jaringan

Ada beberapa skenario di mana salah satu jenis pemicu akan cocok. Saat Anda memilih jenis pemicu mana yang akan digunakan di aplikasi Anda, pertimbangkan saran berikut.

Untuk detail dan contoh cara menggunakan broker soket, lihat Komunikasi jaringan di latar belakang.

Koneksi aman

Secure Sockets Layer (SSL) dan Transport Layer Security (TLS) yang lebih baru adalah protokol kriptografi yang dirancang untuk menyediakan autentikasi dan enkripsi untuk komunikasi jaringan. Protokol ini dirancang untuk mencegah penyadapan dan perubahan saat mengirim dan menerima data jaringan. Protokol ini menggunakan model server klien untuk pertukaran protokol. Protokol ini juga menggunakan sertifikat digital dan otoritas sertifikat untuk memverifikasi bahwa server adalah siapa yang diklaimnya.

Membuat koneksi soket yang aman

Objek StreamSocket dapat dikonfigurasi untuk menggunakan SSL/TLS untuk komunikasi antara klien dan server. Dukungan untuk SSL/TLS ini terbatas pada penggunaan objek StreamSocket sebagai klien dalam negosiasi SSL/TLS. Anda tidak dapat menggunakan SSL/TLS dengan StreamSocket yang dibuat oleh StreamSocketListener saat komunikasi masuk diterima, karena negosiasi SSL/TLS sebagai server tidak diterapkan oleh kelas StreamSocket.

Ada dua cara untuk mengamankan koneksi StreamSocket dengan SSL/TLS:

  • ConnectAsync - Buat koneksi awal ke layanan jaringan dan negosiasi segera untuk menggunakan SSL/TLS untuk semua komunikasi.
  • UpgradeToSslAsync - Sambungkan awalnya ke layanan jaringan tanpa enkripsi. Aplikasi dapat mengirim atau menerima data. Kemudian, tingkatkan koneksi untuk menggunakan SSL/TLS untuk semua komunikasi lebih lanjut.

SocketProtectionLevel menentukan tingkat perlindungan soket yang diinginkan yang ingin dibuat atau ditingkatkan koneksinya. Namun, tingkat perlindungan akhir dari koneksi yang dibuat ditentukan dalam proses negosiasi antara kedua titik akhir koneksi. Hasilnya bisa menjadi tingkat perlindungan yang lebih rendah dari yang Anda tentukan, jika titik akhir lainnya meminta tingkat yang lebih rendah.

Setelah operasi asinkron berhasil diselesaikan, Anda dapat mengambil tingkat perlindungan yang diminta yang digunakan dalam panggilan ConnectAsync atau UpgradeToSslAsync melalui properti StreamSocketinformation.ProtectionLevel. Namun, ini tidak mencerminkan tingkat perlindungan aktual yang digunakan koneksi.

Catatan

Kode Anda tidak boleh secara implisit bergantung pada penggunaan tingkat perlindungan tertentu, atau pada asumsi bahwa tingkat keamanan tertentu digunakan secara default. Lanskap keamanan berubah terus-menerus, dan protokol dan tingkat perlindungan default berubah dari waktu ke waktu untuk menghindari penggunaan protokol dengan kelemahan yang diketahui. Default dapat bervariasi tergantung pada konfigurasi komputer individual, atau perangkat lunak mana yang diinstal dan patch mana yang telah diterapkan. Jika aplikasi Anda bergantung pada penggunaan tingkat keamanan tertentu, maka Anda harus secara eksplisit menentukan tingkat tersebut lalu memeriksa untuk memastikan bahwa aplikasi tersebut benar-benar digunakan pada koneksi yang dibuat.

Menggunakan ConnectAsync

ConnectAsync dapat digunakan untuk membuat koneksi awal dengan layanan jaringan dan kemudian segera bernegosiasi untuk menggunakan SSL/TLS untuk semua komunikasi. Ada dua metode ConnectAsync yang mendukung melewati parameter protectionLevel :

Jika parameter protectionLevel diatur ke Windows.Networking.Sockets.SocketProtectionLevel.Ssl saat memanggil salah satu metode ConnectAsync di atas, StreamSocket harus dibuat untuk menggunakan SSL/TLS untuk enkripsi. Nilai ini memerlukan enkripsi dan tidak pernah mengizinkan cipher NULL digunakan.

Urutan normal yang digunakan dengan salah satu metode ConnectAsync ini sama.

Contoh berikut membuat StreamSocket dan mencoba membuat koneksi ke layanan jaringan dan segera bernegosiasi untuk menggunakan SSL/TLS. Jika negosiasi berhasil, semua komunikasi jaringan menggunakan StreamSocket antara klien, server jaringan akan dienkripsi.

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

Menggunakan UpgradeToSslAsync

Saat kode Anda menggunakan UpgradeToSslAsync, kode pertama-tama membuat koneksi ke layanan jaringan tanpa enkripsi. Aplikasi ini dapat mengirim atau menerima beberapa data, lalu meningkatkan koneksi untuk menggunakan SSL/TLS untuk semua komunikasi lebih lanjut.

Metode UpgradeToSslAsync mengambil dua parameter. Parameter protectionLevel menunjukkan tingkat perlindungan yang diinginkan. Parameter validationHostName adalah nama host tujuan jaringan jarak jauh yang digunakan untuk validasi saat meningkatkan ke SSL. Biasanya validationHostName akan menjadi nama host yang sama dengan yang digunakan aplikasi untuk awalnya membuat koneksi. Jika parameter protectionLevel diatur ke Windows.System.Socket.SocketProtectionLevel.Ssl saat memanggil UpgradeToSslAsync, StreamSocket harus menggunakan SSL/TLS untuk enkripsi pada komunikasi lebih lanjut melalui soket. Nilai ini memerlukan enkripsi dan tidak pernah mengizinkan cipher NULL digunakan.

Urutan normal yang digunakan dengan metode UpgradeToSslAsync adalah sebagai berikut:

Contoh berikut membuat StreamSocket, mencoba membuat koneksi ke layanan jaringan, mengirim beberapa data awal, lalu bernegosiasi untuk menggunakan SSL/TLS. Jika negosiasi berhasil, semua komunikasi jaringan menggunakan StreamSocket antara klien dan server jaringan akan dienkripsi.

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

Membuat koneksi WebSocket yang aman

Seperti koneksi soket tradisional, koneksi WebSocket juga dapat dienkripsi dengan Keamanan Lapisan Transportasi (TLS)/Secure Sockets Layer (SSL) saat menggunakan fitur StreamWebSocket dan MessageWebSocket untuk aplikasi UWP. Dalam kebanyakan kasus, Anda mungkin ingin menggunakan koneksi WebSocket yang aman. Ini akan meningkatkan kemungkinan koneksi Anda akan berhasil, karena banyak proksi akan menolak koneksi WebSocket yang tidak terenkripsi.

Untuk contoh cara membuat, atau meningkatkan ke, koneksi soket aman ke layanan jaringan, lihat Cara mengamankan koneksi WebSocket dengan TLS/SSL.

Selain enkripsi TLS/SSL, server mungkin memerlukan nilai header Sec-WebSocket-Protocol untuk menyelesaikan jabat tangan awal. Nilai ini, diwakili oleh properti StreamWebSocketInformation.Protocol dan MessageWebSocketInformation.Protocol, menunjukkan versi protokol koneksi dan memungkinkan server menginterpretasikan jabat tangan pembuka dengan benar dan data yang dipertukarkan setelahnya. Menggunakan informasi protokol ini, jika pada titik mana pun jika server tidak dapat menginterpretasikan data masuk dengan cara yang aman koneksi dapat ditutup.

Jika permintaan awal dari klien tidak berisi nilai ini, atau memberikan nilai yang tidak cocok dengan apa yang diharapkan server, nilai yang diharapkan dikirim dari server ke klien pada kesalahan jabat tangan WebSocket.

Autentikasi

Cara memberikan kredensial autentikasi saat menyambungkan melalui jaringan.

Menyediakan sertifikat klien dengan kelas StreamSocket

Kelas Windows.Networking.Sockets.StreamSocket mendukung penggunaan SSL/TLS untuk mengautentikasi server yang dibicarakan aplikasi. Dalam kasus tertentu, aplikasi juga perlu mengautentikasi dirinya sendiri ke server menggunakan sertifikat klien TLS. Di Windows 10, Anda dapat memberikan sertifikat klien pada objek StreamSocket.Control (ini harus diatur sebelum jabat tangan TLS dimulai). Jika server meminta sertifikat klien, Windows akan merespons dengan sertifikat yang disediakan.

Berikut adalah cuplikan kode yang menunjukkan cara mengimplementasikan ini:

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

Memberikan kredensial autentikasi ke layanan web

API jaringan yang memungkinkan aplikasi berinteraksi dengan layanan web aman masing-masing menyediakan metode mereka sendiri untuk menginisialisasi klien atau mengatur header permintaan dengan server dan kredensial autentikasi proksi. Setiap metode diatur dengan objek PasswordCredential yang menunjukkan nama pengguna, kata sandi, dan sumber daya tempat kredensial ini digunakan. Tabel berikut ini menyediakan pemetaan API ini:

WebSocket MessageWebSocketControl.ServerCredential
MessageWebSocketControl.ProxyCredential
StreamWebSocketControl.ServerCredential
StreamWebSocketControl.ProxyCredential
Transfer Latar Belakang BackgroundDownloader.ServerCredential
BackgroundDownloader.ProxyCredential
BackgroundUploader.ServerCredential
BackgroundUploader.ProxyCredential
Sindikasi SyndicationClient(PasswordCredential)
SyndicationClient.ServerCredential
SyndicationClient.ProxyCredential
AtomPub AtomPubClient(PasswordCredential)
AtomPubClient.ServerCredential
AtomPubClient.ProxyCredential

Menangani pengecualian jaringan

Di sebagian besar area pemrograman, pengecualian menunjukkan masalah atau kegagalan yang signifikan, yang disebabkan oleh beberapa kelemahan dalam program. Dalam pemrograman jaringan, ada sumber tambahan untuk pengecualian: jaringan itu sendiri, dan sifat komunikasi jaringan. Komunikasi jaringan secara inheren tidak dapat diandalkan dan rentan terhadap kegagalan tak terduga. Untuk setiap cara aplikasi Anda menggunakan jaringan, Anda harus mempertahankan beberapa informasi status; dan kode aplikasi Anda harus menangani pengecualian jaringan dengan memperbarui informasi status tersebut dan memulai logika yang sesuai agar aplikasi Anda dapat membangun kembali atau mencoba kembali kegagalan komunikasi.

Ketika aplikasi Universal Windows memberikan pengecualian, handler pengecualian Anda dapat mengambil informasi yang lebih rinci tentang penyebab pengecualian untuk lebih memahami kegagalan dan membuat keputusan yang sesuai.

Setiap proyeksi bahasa mendukung metode untuk mengakses informasi yang lebih rinci ini. Proyek pengecualian sebagai nilai HRESULT di aplikasi Universal Windows. File Winerror.h menyertakan daftar nilai HRESULT yang sangat besar yang mencakup kesalahan jaringan.

API jaringan mendukung metode yang berbeda untuk mengambil informasi terperinci ini tentang penyebab pengecualian.

  • Beberapa API menyediakan metode pembantu yang mengonversi nilai HRESULT dari pengecualian menjadi nilai enumerasi.
  • API lain menyediakan metode untuk mengambil nilai HRESULT yang sebenarnya.