Självstudie: Kom igång med Relay Hybrid Connections WebSockets i .NET

• .NET
• Node.js

I den här snabbstarten skapar du ett sändar- och mottagarprogram i .NET som skickar och tar emot meddelanden med hybridanslutningar med Websockets i Azure Relay. Läs mer om Azure Relay i allmänhet i Azure Relay.

I den här snabbstarten gör du följande:

1. Skapa ett Relay-namnområde med Azure Portal.
2. Skapa en hybridanslutning i det namnområdet med Azure Portal.
3. Skriva ett serverkonsolprogram (lyssnare) för att ta emot meddelanden.
4. Skriva ett klientkonsolprogram (avsändare) för att ta emot meddelanden.
5. Kör program.

Förutsättningar

För att slutföra den här självstudien, finns följande förhandskrav:

• Visual Studio 2015 eller senare. I exemplen i den här självstudiekursen används Visual Studio 2017.
• En Azure-prenumeration Om du inte har ett konto kan du skapa ett kostnadsfritt konto innan du börjar.

Skapa ett namnområde

1. Logga in på Azure-portalen.

2. Välj Alla tjänster på den vänstra menyn. Välj Integrering, sök efter Reläer, flytta musen över Reläer och välj sedan Skapa.

   

3. Följ dessa steg på sidan Skapa namnområde :

   1. Välj en Azure-prenumeration där du vill skapa namnområdet.

   2. För Resursgrupp väljer du en befintlig resursgrupp där du vill placera namnområdet eller skapar en ny.

   3. Ange ett namn för Relay-namnområdet.

   4. Välj den region där ditt namnområde ska finnas.

   5. Välj Granska + skapa längst ned på sidan.

      

   6. På sidan Granska + skapa väljer du Skapa.

   7. Efter några minuter visas sidan Relay för namnområdet.

      

Få autentiseringsuppgifter för hantering

1. På sidan Relay väljer du Principer för delad åtkomst på den vänstra menyn.

2. På sidan Principer för delad åtkomst väljer du RootManageSharedAccessKey.

3. Under SAS-princip: RootManageSharedAccessKey väljer du knappen Kopiera bredvid Primär anslutningssträng. Den här åtgärden kopierar anslutningssträng till Urklipp för senare användning. Klistra in det här värdet i Anteckningar eller på en tillfällig plats.

4. Upprepa föregående steg för att kopiera och klistra in värdet för primärnyckeln till en tillfällig plats för senare användning.

   

Skapa en hybridanslutning

På sidan Relay för ditt namnområde följer du de här stegen för att skapa en hybridanslutning.

1. På den vänstra menyn under Entiteter väljer du Hybridanslutningar och sedan + Hybridanslutning.

   

2. På sidan Skapa hybridanslutning anger du ett namn för hybridanslutningen och väljer Skapa.

   

Skapa ett serverprogram (lyssnare)

För att lyssna på och ta emot meddelanden från Relay skriver du ett C#-konsolprogram i Visual Studio.

Skapa ett konsolprogram

Skapa ett nytt projekt för Konsolprogram (.NET Framework) i Visual Studio.

Lägg till Relay NuGet-paketet

1. Högerklicka på det nyskapade projektet och välj sedan Hantera NuGet-paket.
2. Välj Bläddra och sök sedan efter Microsoft.Azure.Relay. I sökresultaten väljer du Microsoft Azure Relay.
3. Välj Installera för att slutföra installationen. Stäng dialogrutan.

Skriv kod för att ta emot meddelanden

1. Ersätt de befintliga using-satserna överst i filen Program.cs med följande using-satser:

   using System;
   using System.IO;
   using System.Threading;
   using System.Threading.Tasks;
   using System.Net;
   using Microsoft.Azure.Relay;
   

2. Lägg till konstanter i klassen Program för hybridanslutningsinformationen. Ersätt platshållarna med de värden som du fick när du skapade hybridanslutningen. Se till att du använder det fullständiga namnområdesnamnet.

   // replace {RelayNamespace} with the name of your namespace
   private const string RelayNamespace = "YOUR-RELAY-NAMESPACE-NAME.servicebus.windows.net";
   
   // replace {HybridConnectionName} with the name of your hybrid connection
   private const string ConnectionName = "HYBRID-CONNECTION-NAME";
   
   // replace {SAKKeyName} with the name of your Shared Access Policies key, which is RootManageSharedAccessKey by default
   private const string KeyName = "SAS-KEY-NAME";
   
   // replace {SASKey} with the primary key of the namespace you saved earlier
   private const string Key = "SAS-KEY-VALUE";
   

3. Lägg till metoden ProcessMessagesOnConnection i klassen Program:

   // The method initiates the connection.
   private static async void ProcessMessagesOnConnection(HybridConnectionStream relayConnection, CancellationTokenSource cts)
   {
       Console.WriteLine("New session");
   
       // The connection is a fully bidrectional stream. 
       // Put a stream reader and a stream writer over it.  
       // This allows you to read UTF-8 text that comes from 
       // the sender, and to write text replies back.
       var reader = new StreamReader(relayConnection);
       var writer = new StreamWriter(relayConnection) { AutoFlush = true };
       while (!cts.IsCancellationRequested)
       {
           try
           {
               // Read a line of input until a newline is encountered.
               var line = await reader.ReadLineAsync();
   
               if (string.IsNullOrEmpty(line))
               {
                   // If there's no input data, signal that 
                   // you will no longer send data on this connection,
                   // and then break out of the processing loop.
                   await relayConnection.ShutdownAsync(cts.Token);
                   break;
               }
   
               // Write the line on the console.
               Console.WriteLine(line);
   
               // Write the line back to the client, prepended with "Echo:"
               await writer.WriteLineAsync($"Echo: {line}");
           }
           catch (IOException)
           {
               // Catch an I/O exception. This likely occurred when
               // the client disconnected.
               Console.WriteLine("Client closed connection");
               break;
           }
       }
   
       Console.WriteLine("End session");
   
       // Close the connection.
       await relayConnection.CloseAsync(cts.Token);
   }
   

4. Lägg till metoden RunAsync i klassen Program:

   private static async Task RunAsync()
   {
       var cts = new CancellationTokenSource();
   
       var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
       var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
   
       // Subscribe to the status events.
       listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
       listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
       listener.Online += (o, e) => { Console.WriteLine("Online"); };
   
       // Opening the listener establishes the control channel to
       // the Azure Relay service. The control channel is continuously 
       // maintained, and is reestablished when connectivity is disrupted.
       await listener.OpenAsync(cts.Token);
       Console.WriteLine("Server listening");
   
       // Provide callback for the cancellation token that will close the listener.
       cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));
   
       // Start a new thread that will continuously read the console.
       new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start();
   
       // Accept the next available, pending connection request. 
       // Shutting down the listener allows a clean exit. 
       // This method returns null.
       while (true)
       {
           var relayConnection = await listener.AcceptConnectionAsync();
           if (relayConnection == null)
           {
               break;
           }
   
           ProcessMessagesOnConnection(relayConnection, cts);
       }
   
       // Close the listener after you exit the processing loop.
       await listener.CloseAsync(cts.Token);
   }
   

5. Lägg till följande kodrad till metoden Main i klassen Program:

   RunAsync().GetAwaiter().GetResult();
   

   Den färdiga Program.cs-filen bör se ut så här:

   namespace Server
   {
       using System;
       using System.IO;
       using System.Threading;
       using System.Threading.Tasks;
       using Microsoft.Azure.Relay;
   
       public class Program
       {
           private const string RelayNamespace = "{RelayNamespace}.servicebus.windows.net";
           private const string ConnectionName = "{HybridConnectionName}";
           private const string KeyName = "{SASKeyName}";
           private const string Key = "{SASKey}";
   
           public static void Main(string[] args)
           {
               RunAsync().GetAwaiter().GetResult();
           }
   
           private static async Task RunAsync()
           {
               var cts = new CancellationTokenSource();
   
               var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
               var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
   
               // Subscribe to the status events.
               listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
               listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
               listener.Online += (o, e) => { Console.WriteLine("Online"); };
   
               // Opening the listener establishes the control channel to
               // the Azure Relay service. The control channel is continuously 
               // maintained, and is reestablished when connectivity is disrupted.
               await listener.OpenAsync(cts.Token);
               Console.WriteLine("Server listening");
   
               // Provide callback for a cancellation token that will close the listener.
               cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));
   
               // Start a new thread that will continuously read the console.
               new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start();
   
               // Accept the next available, pending connection request. 
               // Shutting down the listener allows a clean exit. 
               // This method returns null.
               while (true)
               {
                   var relayConnection = await listener.AcceptConnectionAsync();
                   if (relayConnection == null)
                   {
                       break;
                   }
   
                   ProcessMessagesOnConnection(relayConnection, cts);
               }
   
               // Close the listener after you exit the processing loop.
               await listener.CloseAsync(cts.Token);
           }
   
           private static async void ProcessMessagesOnConnection(HybridConnectionStream relayConnection, CancellationTokenSource cts)
           {
               Console.WriteLine("New session");
   
               // The connection is a fully bidrectional stream. 
               // Put a stream reader and a stream writer over it.  
               // This allows you to read UTF-8 text that comes from 
               // the sender, and to write text replies back.
               var reader = new StreamReader(relayConnection);
               var writer = new StreamWriter(relayConnection) { AutoFlush = true };
               while (!cts.IsCancellationRequested)
               {
                   try
                   {
                       // Read a line of input until a newline is encountered.
                       var line = await reader.ReadLineAsync();
   
                       if (string.IsNullOrEmpty(line))
                       {
                           // If there's no input data, signal that 
                           // you will no longer send data on this connection.
                           // Then, break out of the processing loop.
                           await relayConnection.ShutdownAsync(cts.Token);
                           break;
                       }
   
                       // Write the line on the console.
                       Console.WriteLine(line);
   
                       // Write the line back to the client, prepended with "Echo:"
                       await writer.WriteLineAsync($"Echo: {line}");
                   }
                   catch (IOException)
                   {
                       // Catch an I/O exception. This likely occurred when
                       // the client disconnected.
                       Console.WriteLine("Client closed connection");
                       break;
                   }
               }
   
               Console.WriteLine("End session");
   
               // Close the connection.
               await relayConnection.CloseAsync(cts.Token);
           }
       }
   }
   

Skapa ett klientprogram (avsändare)

För att skicka meddelanden till Relay skriver du ett C#-konsolprogram i Visual Studio.

Skapa ett konsolprogram

Skapa ett nytt projekt för Konsolprogram (.NET Framework) i Visual Studio.

Lägg till Relay NuGet-paketet

1. Högerklicka på det nyskapade projektet och välj sedan Hantera NuGet-paket.
2. Välj Bläddra och sök sedan efter Microsoft.Azure.Relay. I sökresultaten väljer du Microsoft Azure Relay.
3. Välj Installera för att slutföra installationen. Stäng dialogrutan.

Skriv kod för att skicka meddelanden

1. Ersätt de befintliga using-satserna överst i filen Program.cs med följande using-satser:

   using System;
   using System.IO;
   using System.Threading;
   using System.Threading.Tasks;
   using Microsoft.Azure.Relay;
   

2. Lägg till konstanter i klassen Program för hybridanslutningsinformationen. Ersätt platshållarna med de värden som du fick när du skapade hybridanslutningen. Se till att du använder det fullständiga namnområdesnamnet.

   // replace {RelayNamespace} with the name of your namespace
   private const string RelayNamespace = "YOUR-RELAY-NAMESPACE-NAME.servicebus.windows.net";
   
   // replace {HybridConnectionName} with the name of your hybrid connection
   private const string ConnectionName = "HYBRID-CONNECTION-NAME";
   
   // replace {SAKKeyName} with the name of your Shared Access Policies key, which is RootManageSharedAccessKey by default
   private const string KeyName = "SAS-KEY-NAME";
   
   // replace {SASKey} with the primary key of the namespace you saved earlier
   private const string Key = "SAS-KEY-VALUE";
   

3. Lägg till följande metod i klassen Program:

   private static async Task RunAsync()
   {
       Console.WriteLine("Enter lines of text to send to the server with ENTER");
   
       // Create a new hybrid connection client.
       var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
       var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
   
       // Initiate the connection.
       var relayConnection = await client.CreateConnectionAsync();
   
       // Run two concurrent loops on the connection. One 
       // reads input from the console and writes it to the connection 
       // with a stream writer. The other reads lines of input from the 
       // connection with a stream reader and writes them to the console. 
       // Entering a blank line shuts down the write task after 
       // sending it to the server. The server then cleanly shuts down
       // the connection, which terminates the read task.
   
       var reads = Task.Run(async () => {
           // Initialize the stream reader over the connection.
           var reader = new StreamReader(relayConnection);
           var writer = Console.Out;
           do
           {
               // Read a full line of UTF-8 text up to newline.
               string line = await reader.ReadLineAsync();
               // If the string is empty or null, you are done.
               if (String.IsNullOrEmpty(line))
                   break;
               // Write to the console.
               await writer.WriteLineAsync(line);
           }
           while (true);
       });
   
       // Read from the console and write to the hybrid connection.
       var writes = Task.Run(async () => {
           var reader = Console.In;
           var writer = new StreamWriter(relayConnection) { AutoFlush = true };
           do
           {
               // Read a line from the console.
               string line = await reader.ReadLineAsync();
               // Write the line out, also when it's empty.
               await writer.WriteLineAsync(line);
               // Quit when the line is empty,
               if (String.IsNullOrEmpty(line))
                   break;
           }
           while (true);
       });
   
       // Wait for both tasks to finish.
       await Task.WhenAll(reads, writes);
       await relayConnection.CloseAsync(CancellationToken.None);
   }
   

4. Lägg till följande kodrad till Main-metoden i Program-klassen.

   RunAsync().GetAwaiter().GetResult();
   

   Program.cs bör se ut så här:

   using System;
   using System.IO;
   using System.Threading;
   using System.Threading.Tasks;
   using Microsoft.Azure.Relay;
   
   namespace Client
   {
       class Program
       {
           private const string RelayNamespace = "{RelayNamespace}.servicebus.windows.net";
           private const string ConnectionName = "{HybridConnectionName}";
           private const string KeyName = "{SASKeyName}";
           private const string Key = "{SASKey}";
   
           static void Main(string[] args)
           {
               RunAsync().GetAwaiter().GetResult();
           }
   
           private static async Task RunAsync()
           {
               Console.WriteLine("Enter lines of text to send to the server with ENTER");
   
               // Create a new hybrid connection client.
               var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
               var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
   
               // Initiate the connection.
               var relayConnection = await client.CreateConnectionAsync();
   
               // Run two concurrent loops on the connection. One 
               // reads input from the console and then writes it to the connection 
               // with a stream writer. The other reads lines of input from the 
               // connection with a stream reader and then writes them to the console. 
               // Entering a blank line shuts down the write task after 
               // sending it to the server. The server then cleanly shuts down
               // the connection, which terminates the read task.
   
               var reads = Task.Run(async () => {
                   // Initialize the stream reader over the connection.
                   var reader = new StreamReader(relayConnection);
                   var writer = Console.Out;
                   do
                   {
                       // Read a full line of UTF-8 text up to newline.
                       string line = await reader.ReadLineAsync();
                       // If the string is empty or null, you are done.
                       if (String.IsNullOrEmpty(line))
                           break;
                       // Write to the console.
                       await writer.WriteLineAsync(line);
                   }
                   while (true);
               });
   
               // Read from the console and write to the hybrid connection.
               var writes = Task.Run(async () => {
                   var reader = Console.In;
                   var writer = new StreamWriter(relayConnection) { AutoFlush = true };
                   do
                   {
                       // Read a line from the console.
                       string line = await reader.ReadLineAsync();
                       // Write the line out, also when it's empty.
                       await writer.WriteLineAsync(line);
                       // Quit when the line is empty.
                       if (String.IsNullOrEmpty(line))
                           break;
                   }
                   while (true);
               });
   
               // Wait for both tasks to finish.
               await Task.WhenAll(reads, writes);
               await relayConnection.CloseAsync(CancellationToken.None);
           }
       }
   }
   

Kommentar

Exempelkoden i den här artikeln använder en anslutningssträng för att autentisera till ett Azure Relay-namnområde för att hålla självstudien enkel. Vi rekommenderar att du använder Microsoft Entra-ID-autentisering i produktionsmiljöer i stället för att använda anslutningssträng eller signaturer för delad åtkomst, vilket är enklare att kompromettera. Detaljerad information och exempelkod för användning av Microsoft Entra-ID-autentisering finns i Autentisera och auktorisera ett program med Microsoft Entra-ID för åtkomst till Azure Relay-entiteter och Autentisera en hanterad identitet med Microsoft Entra-ID för åtkomst till Azure Relay-resurser.

Kör programmen

1. Kör serverprogrammet.

2. Kör klientprogrammet och skriv in lite text.

3. Se till att serverprogramkonsolen visar den text som angavs i klientprogrammet.

   

Relaterat innehåll

I den här snabbstarten skapade du .NET-klient- och -serverprogram som använde WebSockets för att skicka och ta emot meddelanden. Funktionen Hybridanslutningar i Azure Relay stöder också användningen av HTTP för att skicka och ta emot meddelanden. Läs om hur du använder HTTP med Azure Relay-hybridanslutningar i HTTP-snabbstarten.

I den här snabbstarten använde du .NET Framework för att skapa klient- och serverprogram. Om du vill läsa om hur du skriver klient- och serverprogram med hjälp av Node.js läser du Node.js-snabbstarten eller Node.jsT HTTP-snabbstarten.