Wprowadzenie do żądań HTTP połączeń hybrydowych usługi Relay w języku Java

• NET
• Node.js

W tym przewodniku Szybki start utworzysz aplikacje nadawcy i odbiorcy Java, które wysyłają i odbierają komunikaty przy użyciu protokołu HTTP. Aplikacje korzystają z funkcji połączeń hybrydowych usługi Azure Relay. Aby uzyskać więcej ogólnych informacji o usłudze Azure Relay, zobacz Azure Relay.

W tym przewodniku Szybki start wykonasz następujące kroki:

1. Utworzenie przestrzeni nazw usługi Relay za pomocą witryny Azure Portal.
2. Utworzenie połączenia hybrydowego w tej przestrzeni nazw za pomocą witryny Azure Portal.
3. Napisanie aplikacji konsolowej serwera (odbiornika) służącej do odbierania komunikatów.
4. Napisanie aplikacji konsolowej klienta (nadawcy) służącej do wysyłania komunikatów.
5. Uruchamianie aplikacji.

Wymagania wstępne

• Java. Upewnij się, że używasz zestawu JDK 1.8 lub nowszego
• Maven. Upewnij się, że masz zainstalowane narzędzie Maven
• Zestaw SDK usługi Azure Relay. Przegląd zestawu Java SDK
• Subskrypcja Azure. Jeśli nie masz subskrypcji, przed rozpoczęciem utwórz bezpłatne konto.

Tworzenie przestrzeni nazw za pomocą usługi Azure Portal

1. Zaloguj się w witrynie Azure Portal.

2. Wybierz pozycję Wszystkie usługi w menu po lewej stronie. Wybierz pozycję Integracja, wyszukaj pozycję Przekaźniki, przenieś wskaźnik myszy nad przekaźnikami, a następnie wybierz pozycję Utwórz.

   

3. Na stronie Tworzenie przestrzeni nazw wykonaj następujące kroki:

   1. Wybierz subskrypcję platformy Azure, w której chcesz utworzyć przestrzeń nazw.

   2. W obszarze Grupa zasobów wybierz istniejącą grupę zasobów, w której chcesz umieścić przestrzeń nazw, lub utwórz nową.

   3. Wprowadź nazwę przestrzeni nazw usługi Relay.

   4. Wybierz region, w którym powinna być hostowana przestrzeń nazw.

   5. Wybierz pozycję Przejrzyj i utwórz w dolnej części strony.

      

   6. Na stronie Przeglądanie i tworzenie wybierz pozycję Utwórz.

   7. Po kilku minutach zostanie wyświetlona strona przekaźnika dla przestrzeni nazw.

      

Uzyskiwanie poświadczeń zarządzania

1. Na stronie Przekaźnik wybierz pozycję Zasady dostępu współdzielonego w menu po lewej stronie. `

2. Na stronie Zasady dostępu współdzielonego wybierz pozycję RootManageSharedAccessKey.

3. W obszarze Zasady sygnatury dostępu współdzielonego: RootManageSharedAccessKey wybierz przycisk Kopiuj obok pozycji Podstawowe parametry połączenia. Ta akcja kopiuje parametry połączenia do schowka do późniejszego użycia. Wklej tę wartość do Notatnika lub innej tymczasowej lokalizacji.

4. Powtórz poprzedni krok w celu skopiowania i wklejenia wartości pozycji Klucz podstawowy w lokalizacji tymczasowej do późniejszego użycia.

   

Tworzenie połączenia hybrydowego za pomocą witryny Azure Portal

Na stronie Przekaźnik dla przestrzeni nazw wykonaj następujące kroki, aby utworzyć połączenie hybrydowe.

1. W menu po lewej stronie w obszarze Jednostki wybierz pozycję Połączenia hybrydowe, a następnie wybierz pozycję + Połączenie hybrydowe.

   

2. Na stronie Tworzenie połączenia hybrydowego wprowadź nazwę połączenia hybrydowego, a następnie wybierz pozycję Utwórz.

   

Tworzenie aplikacji serwera (odbiornika)

Aby nasłuchiwać i odbierać komunikaty z usługi Relay, napisz aplikację konsolową Java.

Tworzenie aplikacji Java

Jeśli podczas tworzenia przekaźnika wyłączono opcję "Wymaga autoryzacji klienta", możesz wysyłać żądania do adresu URL połączeń hybrydowych przy użyciu dowolnej przeglądarki. Aby uzyskać dostęp do chronionych punktów końcowych, musisz utworzyć i przekazać token w nagłówku ServiceBusAuthorization pokazanym w tym miejscu.

Oto prosta struktura projektu Maven i klasa Języka Java, która demonstruje wysyłanie żądań do adresu URL połączeń hybrydowych z autoryzacją klienta przy użyciu biblioteki usługi Azure Relay.

Dodawanie pakietu relay

Zmodyfikuj plik pom.xml w pakiecie aplikacji maven, aby uwzględnić pakiet usługi Azure Relay.

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-relay</artifactId>
    <version>0.0.6</version>
</dependency>

Uruchom polecenie mvn dependency:copy-dependencies -DoutputDirectory=lib w projekcie mvn, aby dodać plik jar zależności w katalogu lib projektu. Importuje wszystkie zależności azure-relay pakietu mvn. Ten pakiet udostępnia funkcje do konstruowania identyfikatorów jednolitych zasobów (URI) i tokenów usługi Relay.

Pisanie kodu w celu wysyłania komunikatów

1. Dodaj pliki jar zależności do ścieżki ClassPath pliku Listener.java .

   javac -cp lib/* src/main/java/com/example/listener/Listener.Java
   

2. Zaimportuj zależności do klasy Listener.java .

   import java.io.BufferedReader;
   import java.io.IOException;
   import java.io.InputStreamReader;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.Scanner;
   import com.microsoft.azure.relay.HybridConnectionListener;
   import com.microsoft.azure.relay.RelayConnectionStringBuilder;
   import com.microsoft.azure.relay.RelayedHttpListenerResponse;
   import com.microsoft.azure.relay.TokenProvider;
   

3. Dodaj następujący kod constants na początku Listener.java pliku do createConnectionString funkcji java, aby uzyskać szczegółowe informacje o połączeniu hybrydowym.

   public static String createConnectionString(){
       StringBuilder connectionString = new StringBuilder();
       connectionString.append("Endpoint=sb://");
       connectionString.append("{namespace}");
       connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
       connectionString.append("{keyrule}");
       connectionString.append(";SharedAccessKey=");
       connectionString.append("{key}");
       connectionString.append(";EntityPath=");
       connectionString.append("{path}");
       return connectionString.toString();
   }
   

   Zastąp symbole zastępcze w nawiasach wartościami uzyskanymi podczas tworzenia połączenia hybrydowego.

   • namespace — obszar nazw usługi Relay. Pamiętaj, aby użyć w pełni kwalifikowanej nazwy obszaru nazw, na przykład {namespace}.servicebus.windows.net.
   • path — nazwa połączenia hybrydowego.
   • keyrule - Nazwa klucza zasad dostępu współdzielonego, który jest RootManageSharedAccessKey domyślnie.
   • nst key - Klucz podstawowy zapisanej wcześniej przestrzeni nazw.

4. Dodaj następujący kod do pliku Listener.java. Funkcja główna powinna wyglądać podobnie do następującego kodu:

   public static void main( String[] args ) throws URISyntaxException
   {
       String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
       RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
       TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                   connectionParams.getSharedAccessKeyName(),
                   connectionParams.getSharedAccessKey());
       HybridConnectionListener listener = new HybridConnectionListener(new URI(connectionParams.getEndpoint().toString() + connectionParams.getEntityPath()), tokenProvider);
   
       // The "context" object encapsulates both the incoming request and the outgoing response
       listener.setRequestHandler((context) -> {
           String receivedText = "";
           if (context.getRequest().getInputStream() != null) {
               try (BufferedReader reader = new BufferedReader(new InputStreamReader(context.getRequest().getInputStream(), "UTF8"))) {
                   StringBuilder builder = new StringBuilder();
                   String inputLine;
                   while ((inputLine = reader.readLine()) != null) {
                       builder.append(inputLine);
                   }
                   receivedText = builder.toString();
               } catch (IOException e) {
                   System.out.println(e.getMessage());
               }
           }
           System.out.println("requestHandler received " + receivedText);
   
           RelayedHttpListenerResponse response = context.getResponse();
           response.setStatusCode(202);
           response.setStatusDescription("OK");
   
           try {
               response.getOutputStream().write(("Echo: " + receivedText).getBytes());
           } catch (IOException e) {
               e.printStackTrace();
           }
   
           // The context MUST be closed for the message to be sent
           response.close();
       });
   
       listener.openAsync().join();
   
       Scanner in = new Scanner(System.in);
       System.out.println("Press ENTER to terminate this program.");
       in.nextLine();
   
       listener.close();
       in.close();
   }
   
   

   Oto jak powinien wyglądać plik Listener.java :

   package com.example.listener;
   import java.io.BufferedReader;
   import java.io.IOException;
   import java.io.InputStreamReader;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.Scanner;
   import com.microsoft.azure.relay.HybridConnectionListener;
   import com.microsoft.azure.relay.RelayConnectionStringBuilder;
   import com.microsoft.azure.relay.RelayedHttpListenerResponse;
   import com.microsoft.azure.relay.TokenProvider;
   
    public class Listener
    {
       public static String createConnectionString(){
           StringBuilder connectionString = new StringBuilder();
           connectionString.append("Endpoint=sb://");
           connectionString.append("{namespace}");
           connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
           connectionString.append("{keyrule}");
           connectionString.append(";SharedAccessKey=");
           connectionString.append("{key}");
           connectionString.append(";EntityPath=");
           connectionString.append("{path}");
           return connectionString.toString();
       }
   
       public static void main( String[] args ) throws URISyntaxException
       {
           String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
           RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
           TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                       connectionParams.getSharedAccessKeyName(),
                       connectionParams.getSharedAccessKey());
           HybridConnectionListener listener = new HybridConnectionListener(new URI(connectionParams.getEndpoint().toString() + connectionParams.getEntityPath()), tokenProvider);
   
           // The "context" object encapsulates both the incoming request and the outgoing response
           listener.setRequestHandler((context) -> {
               String receivedText = "";
               if (context.getRequest().getInputStream() != null) {
                   try (BufferedReader reader = new BufferedReader(new InputStreamReader(context.getRequest().getInputStream(), "UTF8"))) {
                       StringBuilder builder = new StringBuilder();
                       String inputLine;
                       while ((inputLine = reader.readLine()) != null) {
                           builder.append(inputLine);
                       }
                       receivedText = builder.toString();
                   } catch (IOException e) {
                       System.out.println(e.getMessage());
                   }
               }
               System.out.println("requestHandler received " + receivedText);
   
               RelayedHttpListenerResponse response = context.getResponse();
               response.setStatusCode(202);
               response.setStatusDescription("OK");
   
               try {
                   response.getOutputStream().write(("Echo: " + receivedText).getBytes());
               } catch (IOException e) {
                   e.printStackTrace();
               }
   
               // The context MUST be closed for the message to be sent
               response.close();
           });
   
           listener.openAsync().join();
   
           Scanner in = new Scanner(System.in);
           System.out.println("Press ENTER to terminate this program.");
           in.nextLine();
   
           listener.close();
           in.close();
       }
   }
   

Tworzenie aplikacji klienta (nadawcy)

Aby wysyłać komunikaty do usługi Relay, możesz użyć dowolnego klienta HTTP lub napisać aplikację konsolową Java.

Tworzenie aplikacji Java

Jeśli podczas tworzenia przekaźnika wyłączono opcję "Wymaga autoryzacji klienta", możesz wysyłać żądania do adresu URL połączeń hybrydowych przy użyciu dowolnej przeglądarki. Aby uzyskać dostęp do chronionych punktów końcowych, musisz utworzyć i przekazać token w nagłówku ServiceBusAuthorization pokazanym w tym miejscu.

Oto prosta struktura projektu Maven i klasa Języka Java, która demonstruje wysyłanie żądań do adresu URL połączeń hybrydowych z autoryzacją klienta przy użyciu biblioteki usługi Azure Relay.

Dodawanie pakietu relay

Zmodyfikuj plik pom.xml w pakiecie aplikacji maven, aby uwzględnić pakiet usługi Azure Relay.

<dependency>
	<groupId>com.microsoft.azure</groupId>
	<artifactId>azure-relay</artifactId>
	<version>0.0.6</version>
</dependency>

Uruchom polecenie mvn dependency:copy-dependencies -DoutputDirectory=lib w projekcie mvn, aby dodać plik jar zależności w katalogu lib projektu. Importuje również wszystkie zależności azure-relay pakietu mvn. Ten pakiet udostępnia funkcje do konstruowania identyfikatorów jednolitych zasobów (URI) i tokenów usługi Relay.

Pisanie kodu w celu wysyłania komunikatów

1. Dodaj pliki jar zależności do ścieżki ClassPath pliku Sender.java .

   javac -cp lib/* src/main/java/com/example/sender/Sender.Java
   

2. Zaimportuj zależności do klasy Sender.java .

   import java.io.BufferedReader;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.InputStreamReader;
   import java.io.OutputStreamWriter;
   import java.net.HttpURLConnection;
   import java.net.MalformedURLException;
   import java.net.URL;
   import java.time.Duration;
   import java.util.Scanner;
   import com.microsoft.azure.relay.RelayConnectionStringBuilder;
   import com.microsoft.azure.relay.TokenProvider;
   

3. Dodaj następujący kod constants na początku Sender.java pliku do createConnectionString funkcji java, aby uzyskać szczegółowe informacje o połączeniu hybrydowym.

   public static String createConnectionString(){
       StringBuilder connectionString = new StringBuilder();
       connectionString.append("Endpoint=sb://");
       connectionString.append("{namespace}");
       connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
       connectionString.append("{keyrule}");
       connectionString.append(";SharedAccessKey=");
       connectionString.append("{key}");
       connectionString.append(";EntityPath=");
       connectionString.append("{path}");
       return connectionString.toString();
   }
   

   Zastąp symbole zastępcze w nawiasach wartościami uzyskanymi podczas tworzenia połączenia hybrydowego.

   • namespace — obszar nazw usługi Relay. Pamiętaj, aby użyć w pełni kwalifikowanej nazwy obszaru nazw, na przykład {namespace}.servicebus.windows.net.
   • path — nazwa połączenia hybrydowego.
   • keyrule - Nazwa klucza zasad dostępu współdzielonego, który jest RootManageSharedAccessKey domyślnie.
   • nst key - Klucz podstawowy zapisanej wcześniej przestrzeni nazw.

4. Dodaj następujący kod do pliku Sender.java. Funkcja główna powinna wyglądać podobnie do poniższego kodu.

   public static void main(String[] args) throws IOException {
       String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
       if (CONNECTION_STRING_ENV_VARIABLE_NAME == null || CONNECTION_STRING_ENV_VARIABLE_NAME.isEmpty()){
           System.err.println("Connection string is null or empty. Please check your createConnectionString method.");
           return;
       }
       RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
       TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
               connectionParams.getSharedAccessKeyName(), 
               connectionParams.getSharedAccessKey());
       URL url = buildHttpConnectionURL(connectionParams.getEndpoint().toString(), connectionParams.getEntityPath());
       String tokenString = tokenProvider.getTokenAsync(url.toString(), Duration.ofHours(1)).join().getToken();
       Scanner in = new Scanner(System.in);
       while (true) {
           System.out.println("Press ENTER to terminate this program.");
           String message = in.nextLine();
           int value = System.in.read();
           if (value == '\n' || value == '\r') {
               System.out.println("Terminating the program...");
               break;}
           // Starting a HTTP connection to the listener
           HttpURLConnection conn = (HttpURLConnection) url.openConnection();
           // Sending an HTTP request to the listener
           // To send a message body, use POST
           conn.setRequestMethod((message == null || message.length() == 0) ? "GET" : "POST");
           conn.setRequestProperty("ServiceBusAuthorization", tokenString);
           conn.setDoOutput(true);
           OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream());
           out.write(message, 0, message.length());
           out.flush();
           out.close();
           // Reading the HTTP response
           String inputLine;
           BufferedReader reader = null;
           StringBuilder responseBuilder = new StringBuilder();
           try {
               InputStream inputStream = conn.getInputStream();
               reader = new BufferedReader(new InputStreamReader(inputStream));
               System.out.println("status code: " + conn.getResponseCode());
               while ((inputLine = reader.readLine()) != null) {
                   responseBuilder.append(inputLine);
               }
               System.out.println("received back " + responseBuilder.toString());
           } catch (IOException e) {
               System.out.println("The listener is offline or could not be reached.");
               break;
           } finally {
               if (reader != null) {
                   reader.close();
               }
           }
       }
       in.close();
   }
   
   static URL buildHttpConnectionURL(String endpoint, String entity) throws MalformedURLException {
       StringBuilder urlBuilder = new StringBuilder(endpoint + entity);
   
       // For HTTP connections, the scheme must be https://
       int schemeIndex = urlBuilder.indexOf("://");
       if (schemeIndex < 0) {
           throw new IllegalArgumentException("Invalid scheme from the given endpoint.");
       }
       urlBuilder.replace(0, schemeIndex, "https");
       return new URL(urlBuilder.toString());
   }
   

   Oto jak powinien wyglądać plik Sender.java :

   package com.example.sender;
   import java.io.BufferedReader;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.InputStreamReader;
   import java.io.OutputStreamWriter;
   import java.net.HttpURLConnection;
   import java.net.MalformedURLException;
   import java.net.URL;
   import java.time.Duration;
   import java.util.Scanner;
   import com.microsoft.azure.relay.RelayConnectionStringBuilder;
   import com.microsoft.azure.relay.TokenProvider;
   
   public class Sender
   {
       public static String createConnectionString(){
           StringBuilder connectionString = new StringBuilder();
           connectionString.append("Endpoint=sb://");
           connectionString.append("{namespace}");
           connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
           connectionString.append("{keyrule}");
           connectionString.append(";SharedAccessKey=");
           connectionString.append("{key}");
           connectionString.append(";EntityPath=");
           connectionString.append("{path}");
           return connectionString.toString();
           }
       public static void main(String[] args) throws IOException {
           String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
           if (CONNECTION_STRING_ENV_VARIABLE_NAME == null || CONNECTION_STRING_ENV_VARIABLE_NAME.isEmpty()){
               System.err.println("Connection string is null or empty. Please check your createConnectionString method.");
               return;
           }
           RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
           TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                   connectionParams.getSharedAccessKeyName(), 
                   connectionParams.getSharedAccessKey());
           URL url = buildHttpConnectionURL(connectionParams.getEndpoint().toString(), connectionParams.getEntityPath());
           String tokenString = tokenProvider.getTokenAsync(url.toString(), Duration.ofHours(1)).join().getToken();
           Scanner in = new Scanner(System.in);
           while (true) {
               System.out.println("Press ENTER to terminate this program.");
               String message = in.nextLine();
               int value = System.in.read();
               if (value == '\n' || value == '\r') {
                   System.out.println("Terminating the program...");
                   break;}
               // Starting a HTTP connection to the listener
               HttpURLConnection conn = (HttpURLConnection) url.openConnection();
               // Sending an HTTP request to the listener
               // To send a message body, use POST
               conn.setRequestMethod((message == null || message.length() == 0) ? "GET" : "POST");
               conn.setRequestProperty("ServiceBusAuthorization", tokenString);
               conn.setDoOutput(true);
               OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream());
               out.write(message, 0, message.length());
               out.flush();
               out.close();
               // Reading the HTTP response
               String inputLine;
               BufferedReader reader = null;
               StringBuilder responseBuilder = new StringBuilder();
               try {
                   InputStream inputStream = conn.getInputStream();
                   reader = new BufferedReader(new InputStreamReader(inputStream));
                   System.out.println("status code: " + conn.getResponseCode());
                   while ((inputLine = reader.readLine()) != null) {
                       responseBuilder.append(inputLine);
                   }
                   System.out.println("received back " + responseBuilder.toString());
               } catch (IOException e) {
                   System.out.println("The listener is offline or could not be reached.");
                   break;
               } finally {
                   if (reader != null) {
                       reader.close();
                   }
               }
           }
           in.close();
       }
   
       static URL buildHttpConnectionURL(String endpoint, String entity) throws MalformedURLException {
           StringBuilder urlBuilder = new StringBuilder(endpoint + entity);
   
           // For HTTP connections, the scheme must be https://
           int schemeIndex = urlBuilder.indexOf("://");
           if (schemeIndex < 0) {
               throw new IllegalArgumentException("Invalid scheme from the given endpoint.");
           }
           urlBuilder.replace(0, schemeIndex, "https");
           return new URL(urlBuilder.toString());
       }
   }
   

Uwaga

Przykładowy kod w tym artykule używa parametry połączenia do uwierzytelniania w przestrzeni nazw usługi Azure Relay, aby zachować prostotę samouczka. Zalecamy użycie uwierzytelniania identyfikatora Entra firmy Microsoft w środowiskach produkcyjnych zamiast używania parametry połączenia lub sygnatur dostępu współdzielonego, co może być łatwiejsze w przypadku naruszenia zabezpieczeń. Aby uzyskać szczegółowe informacje i przykładowy kod do korzystania z uwierzytelniania identyfikatora entra firmy Microsoft, zobacz Uwierzytelnianie i autoryzacja aplikacji przy użyciu identyfikatora Entra firmy Microsoft w celu uzyskania dostępu do jednostek usługi Azure Relay i uwierzytelnianie tożsamości zarządzanej za pomocą identyfikatora Entra firmy Microsoft w celu uzyskania dostępu do zasobów usługi Azure Relay.

Uruchamianie aplikacji

1. Uruchom aplikację serwera: w wierszu polecenia Java lub w aplikacji wpisz java -cp <jar_dependency_path> com.example.listener.Listener.java.
2. Uruchom aplikację kliencką: w wierszu polecenia java lub w aplikacji wpisz java -cp <jar_dependency_path> com.example.sender.Sender.java, a następnie wprowadź jakiś tekst.
3. Upewnij się, że w konsoli aplikacji serwera pojawia się tekst wprowadzony w aplikacji klienta.

Gratulacje, utworzono kompleksową aplikację połączeń hybrydowych przy użyciu języka Java!

Następne kroki

W tym przewodniku Szybki start utworzono aplikacje klienckie i serwerowe Java, które używały protokołu HTTP do wysyłania i odbierania komunikatów. Funkcja połączeń hybrydowych usługi Azure Relay obsługuje również wysyłanie i odbieranie komunikatów przy użyciu obiektów WebSocket. Aby dowiedzieć się, jak używać obiektów WebSocket z funkcją połączeń hybrydowych usługi Azure Relay, zobacz Przewodnik Szybki start dotyczący obiektów WebSocket.

W tym przewodniku Szybki start użyto języka Java do tworzenia aplikacji klienckich i serwerowych. Aby dowiedzieć się, jak pisać aplikacje klienta i serwera na platformie .NET Framework, zobacz Przewodnik Szybki start dotyczący obiektów WebSocket na platformie .NET lub Przewodnik Szybki start dotyczący protokołu HTTP na platformie .NET.