Improve the class-level Socket example (dotnet#8602)

- Remove the complicated ConnectSocket method, and leave DNS-resolution for the socket itself - Demonstrate low-allocation buffering - Introduce an async version of the same example - Emphasize the benefits of using cancellable overloads, including the implicit performance benefit: cancellable overloads always return a ValueTask - Delete VB and C++/CLI examples; the maintenance burden is not worth the benefits.

Author: antonfirsov

snippets/cpp/VS_Snippets_Remoting/System.Net.Sockets.Socket/CPP/socket.cpp

@@ -3,97 +3,117 @@
  * This example creates a socket connection to the server specified by the user,
  * using port 80. Once the connection has been established it asks the server for
  * the content of its home page. If no server name is passed as argument to this
- * program, it sends the request to the current machine.
+ * program, it sends the request to example.com.
  * */
- //<Snippet1>
 using System;
 using System.Text;
-using System.IO;
-using System.Net;
 using System.Net.Sockets;
+using System.Threading.Tasks;
+using System.Threading;
+using System.Linq;
 
 public class GetSocket
 {
- private static Socket ConnectSocket(string server, int port)
+ public static async Task Main(string[] args)
  {
- Socket s = null;
- IPHostEntry hostEntry = null;
-
- // Get host related information.
- hostEntry = Dns.GetHostEntry(server);
-
- // Loop through the AddressList to obtain the supported AddressFamily. This is to avoid
- // an exception that occurs when the host IP Address is not compatible with the address family
- // (typical in the IPv6 case).
- foreach(IPAddress address in hostEntry.AddressList)
- {
- IPEndPoint ipe = new IPEndPoint(address, port);
- Socket tempSocket =
- new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
-
- tempSocket.Connect(ipe);
-
- if(tempSocket.Connected)
- {
- s = tempSocket;
- break;
- }
- else
- {
- continue;
- }
- }
- return s;
+ Uri? uri = args.Any() ? new Uri(args[0]) : null;
+
+ // Sync:
+ SendHttpRequest(uri);
+
+ // Async:
+ await SendHttpRequestAsync(uri);
  }
 
- // This method requests the home page content for the specified server.
- private static string SocketSendReceive(string server, int port)
+//<Snippet1>
+private static void SendHttpRequest(Uri? uri = null, int port = 80)
+{
+ uri ??= new Uri("http://example.com");
+
+ // Construct a minimalistic HTTP/1.1 request
+ byte[] requestBytes = Encoding.ASCII.GetBytes(@$"GET {uri.AbsoluteUri} HTTP/1.0
+Host: {uri.Host}
+Connection: Close
+
+");
+
+ // Create and connect a dual-stack socket
+ using Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+ socket.Connect(uri.Host, port);
+
+ // Send the request.
+ // For the tiny amount of data in this example, the first call to Send() will likely deliver the buffer completely,
+ // however this is not guaranteed to happen for larger real-life buffers.
+ // The best practice is to iterate until all the data is sent.
+ int bytesSent = 0;
+ while (bytesSent < requestBytes.Length)
  {
- string request = "GET / HTTP/1.1\r\nHost: " + server +
- "\r\nConnection: Close\r\n\r\n";
- Byte[] bytesSent = Encoding.ASCII.GetBytes(request);
- Byte[] bytesReceived = new Byte[256];
- string page = "";
-
- // Create a socket connection with the specified server and port.
- using(Socket s = ConnectSocket(server, port)) {
-
- if (s == null)
- return ("Connection failed");
-
- // Send request to the server.
- s.Send(bytesSent, bytesSent.Length, 0);
-
- // Receive the server home page content.
- int bytes = 0;
- page = "Default HTML page on " + server + ":\r\n";
-
- // The following will block until the page is transmitted.
- do {
- bytes = s.Receive(bytesReceived, bytesReceived.Length, 0);
- page = page + Encoding.ASCII.GetString(bytesReceived, 0, bytes);
- }
- while (bytes > 0);
- }
-
- return page;
+ bytesSent += socket.Send(requestBytes, bytesSent, requestBytes.Length - bytesSent, SocketFlags.None);
  }
 
- public static void Main(string[] args)
+ // Do minimalistic buffering assuming ASCII response
+ byte[] responseBytes = new byte[256];
+ char[] responseChars = new char[256];
+
+ while (true)
  {
- string host;
- int port = 80;
-
- if (args.Length == 0)
- // If no server name is passed as argument to this program,
- // use the current host name as the default.
- host = Dns.GetHostName();
- else
- host = args[0];
-
- string result = SocketSendReceive(host, port);
- Console.WriteLine(result);
+ int bytesReceived = socket.Receive(responseBytes);
+
+ // Receiving 0 bytes means EOF has been reached
+ if (bytesReceived == 0) break;
+
+ // Convert byteCount bytes to ASCII characters using the 'responseChars' buffer as destination
+ int charCount = Encoding.ASCII.GetChars(responseBytes, 0, bytesReceived, responseChars, 0);
+
+ // Print the contents of the 'responseChars' buffer to Console.Out
+ Console.Out.Write(responseChars, 0, charCount);
  }
 }
-
 //</Snippet1>
+
+//<Snippet2>
+private static async Task SendHttpRequestAsync(Uri? uri = null, int port = 80, CancellationToken cancellationToken = default)
+{
+ uri ??= new Uri("http://example.com");
+
+ // Construct a minimalistic HTTP/1.1 request
+ byte[] requestBytes = Encoding.ASCII.GetBytes(@$"GET {uri.AbsoluteUri} HTTP/1.1
+Host: {uri.Host}
+Connection: Close
+
+");
+
+ // Create and connect a dual-stack socket
+ using Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+ await socket.ConnectAsync(uri.Host, port, cancellationToken);
+
+ // Send the request.
+ // For the tiny amount of data in this example, the first call to SendAsync() will likely deliver the buffer completely,
+ // however this is not guaranteed to happen for larger real-life buffers.
+ // The best practice is to iterate until all the data is sent.
+ int bytesSent = 0;
+ while (bytesSent < requestBytes.Length)
+ {
+ bytesSent += await socket.SendAsync(requestBytes.AsMemory(bytesSent), SocketFlags.None);
+ }
+
+ // Do minimalistic buffering assuming ASCII response
+ byte[] responseBytes = new byte[256];
+ char[] responseChars = new char[256];
+
+ while (true)
+ {
+ int bytesReceived = await socket.ReceiveAsync(responseBytes, SocketFlags.None, cancellationToken);
+
+ // Receiving 0 bytes means EOF has been reached
+ if (bytesReceived == 0) break;
+
+ // Convert byteCount bytes to ASCII characters using the 'responseChars' buffer as destination
+ int charCount = Encoding.ASCII.GetChars(responseBytes, 0, bytesReceived, responseChars, 0);
+
+ // Print the contents of the 'responseChars' buffer to Console.Out
+ await Console.Out.WriteAsync(responseChars.AsMemory(0, charCount), cancellationToken);
+ }
+}
+//</Snippet2>
+}