Change the customizing way of TCP connecting to a functional style

Author: jsakamoto

WhoisClient.NET/DefaultTcpConnector.cs

@@ -1,4 +1,7 @@
-using System.Text;
+using System;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading.Tasks;
 
 namespace Whois.NET
 {
@@ -25,8 +28,9 @@ internal interface IQueryOptions
         bool RethrowExceptions { get; }
 
         /// <summary>
-        /// Gets or sets connection manager instance. Replace it if you need to create a connection in specific way, for example, over SOCKS proxy.
+        /// Gets the function to create a TCP connection to a whois server asynchronously.<br/>
+        /// This property allows us to override a way of creating a connection.
         /// </summary>
-        ITcpConnector TcpConnector { get; }
+        Func<TcpConnectionArgs, Task<TcpClient>> ConnectAsync { get; }
     }
 }

WhoisClient.NET/IQueryOptions.cs

@@ -0,0 +1,25 @@
+using System.Threading;
+
+namespace Whois.NET
+{
+    /// <summary>
+    /// Represents the arguments required for establishing a TCP connection.
+    /// </summary>
+    public class TcpConnectionArgs
+    {
+        /// <summary>
+        /// Gets the host name or IP address of the server.
+        /// </summary>
+        public string Host { get; internal set; }
+
+        /// <summary>
+        /// Gets the TCP port number to connect to on the server.
+        /// </summary>
+        public int Port { get; internal set; }
+
+        /// <summary>
+        /// Gets the cancellation token to monitor for cancellation requests.
+        /// </summary>
+        public CancellationToken CancellationToken { get; internal set; }
+    }
+}

WhoisClient.NET/ITcpConnector.cs

@@ -274,7 +274,7 @@ private static string RawQuery(string query, EndPoint server, IQueryOptions opti
             try
             {
                 // Async connect
-                var tcpClientTask = options.TcpConnector.ConnectAsync(server.Host, server.Port);
+                var tcpClientTask = ConnectAsync(server, options);
                 tcpClientTask.ConfigureAwait(false);
 
                 // Wait at most timeout
@@ -318,7 +318,7 @@ private static string RawQuery(string query, EndPoint server, IQueryOptions opti
                     {
                         cbRead = s.Read(readBuff, 0, readBuff.Length);
                         res.Append(options.Encoding.GetString(readBuff, 0, cbRead));
-                        if (cbRead > 0) 
+                        if (cbRead > 0)
                             Thread.Sleep(100);
                     } while (cbRead > 0);
 
@@ -393,8 +393,7 @@ private static async Task<string> RawQueryAsync(string query, EndPoint server, I
             // Async connect
             try
             {
-                tcpClient = await options.TcpConnector.ConnectAsync(server.Host, server.Port, token)
-                    .ConfigureAwait(false);
+                tcpClient = await ConnectAsync(server, options, token).ConfigureAwait(false);
             }
             catch (SocketException)
             {
@@ -426,7 +425,7 @@ private static async Task<string> RawQueryAsync(string query, EndPoint server, I
                     {
                         cbRead = await s.ReadAsync(readBuff, 0, buffSize, token).ConfigureAwait(false);
                         res.Append(options.Encoding.GetString(readBuff, 0, cbRead));
-                        if (cbRead > 0) 
+                        if (cbRead > 0)
                             await Task.Delay(100, token).ConfigureAwait(false);
                     } while (cbRead > 0);
 
@@ -448,5 +447,27 @@ private static async Task<string> RawQueryAsync(string query, EndPoint server, I
                 tcpClient.Close();
             }
         }
+
+        private static readonly Func<TcpConnectionArgs, Task<TcpClient>> DefaultConnectAsync = async args =>
+        {
+            if (string.IsNullOrWhiteSpace(args.Host)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(args.Host));
+            if (args.Port <= 0 || args.Port > ushort.MaxValue) throw new ArgumentOutOfRangeException(nameof(args.Port));
+
+            var tcpClient = new TcpClient();
+            await tcpClient.ConnectAsync(args.Host, args.Port).ConfigureAwait(false);
+            return tcpClient;
+        };
+
+        private static async Task<TcpClient> ConnectAsync(EndPoint server, IQueryOptions options, CancellationToken cancellationToken = default)
+        {
+            var tcpConnectionArgs = new TcpConnectionArgs
+            {
+                Host = server.Host,
+                Port = server.Port,
+                CancellationToken = CancellationToken.None
+            };
+            var connectAsync = options.ConnectAsync != null ? options.ConnectAsync : DefaultConnectAsync;
+            return await connectAsync.Invoke(tcpConnectionArgs).ConfigureAwait(false);
+        }
     }
 }

WhoisClient.NET/TcpConnectionArgs.cs

@@ -1,4 +1,7 @@
-using System.Text;
+using System;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading.Tasks;
 
 namespace Whois.NET
 {
@@ -38,8 +41,9 @@ public class WhoisQueryOptions : IQueryOptions
         public bool RethrowExceptions { get; set; } = false;
 
         /// <summary>
-        /// Gets or sets connection manager instance. Replace it if you need to create a connection in specific way, for example, over SOCKS proxy.
+        /// Gets or sets the function to create a TCP connection to a whois server asynchronously.<br/>
+        /// Replace it if you need to create a connection in a specific way, for example, over a SOCKS proxy.
         /// </summary>
-        public ITcpConnector TcpConnector { get; set; } = DefaultTcpConnector.Instance;
+        public Func<TcpConnectionArgs, Task<TcpClient>> ConnectAsync { get; set; }
     }
 }