small refactor

Author: honfika

examples/Titanium.Web.Proxy.Examples.Basic/ProxyTestController.cs

@@ -91,7 +91,7 @@ public void StartProxy()
 
             //proxyServer.AddEndPoint(transparentEndPoint);
             //proxyServer.UpStreamHttpProxy = new ExternalProxy("localhost", 8888);
-            //proxyServer.UpStreamHttpsProxy = new ExternalProxy("localhost", 8888( });
+            //proxyServer.UpStreamHttpsProxy = new ExternalProxy("localhost", 8888);
 
             // SOCKS proxy
             //proxyServer.UpStreamHttpProxy = new ExternalProxy("46.63.0.17", 4145) { ProxyType = ExternalProxyType.Socks4 };

src/Titanium.Web.Proxy/Network/Tcp/TcpConnectionFactory.cs

@@ -395,55 +395,9 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost
                             tcpServerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                         }
 
-                        Task connectTask;
-                        if (socks)
-                        {
-                            var clientSocket = (ProxySocket.ProxySocket)tcpServerSocket;
-
-                            IAsyncResult BeginConnect(IPAddress address, int port, AsyncCallback requestCallback,
-                                object state)
-                            {
-                                return clientSocket.BeginConnect(address, port, requestCallback, state);
-                            }
-
-                            void EndConnect(IAsyncResult asyncResult)
-                            {
-                                var s = clientSocket;
-                                if (s == null)
-                                {
-                                    // Dispose nulls out the client socket field.
-                                    throw new ObjectDisposedException(GetType().Name);
-                                }
-
-                                s.EndConnect(asyncResult);
-                            }
-
-                            connectTask = Task.Factory.FromAsync(BeginConnect, EndConnect, ipAddress, port, state: this);
-                        }
-                        else
-                        {
-                            var clientSocket = tcpServerSocket;
-
-                            IAsyncResult BeginConnect(IPAddress address, int port, AsyncCallback requestCallback,
-                                object state)
-                            {
-                                return clientSocket.BeginConnect(address, port, requestCallback, state);
-                            }
-
-                            void EndConnect(IAsyncResult asyncResult)
-                            {
-                                var s = clientSocket;
-                                if (s == null)
-                                {
-                                    // Dispose nulls out the client socket field.
-                                    throw new ObjectDisposedException(GetType().Name);
-                                }
-
-                                s.EndConnect(asyncResult);
-                            }
-
-                            connectTask = Task.Factory.FromAsync(BeginConnect, EndConnect, ipAddress, port, state: this);
-                        }
+                        var connectTask = socks 
+                            ? ProxySocketConnectionTaskFactory.CreateTask((ProxySocket.ProxySocket)tcpServerSocket, ipAddress, port) 
+                            : SocketConnectionTaskFactory.CreateTask(tcpServerSocket, ipAddress, port);
 
                         await Task.WhenAny(connectTask, Task.Delay(proxyServer.ConnectTimeOutSeconds * 1000, cancellationToken));
                         if (!connectTask.IsCompleted || !tcpServerSocket.Connected)
@@ -767,5 +721,43 @@ public void Dispose()
                 }
             }
         }
+
+        static class SocketConnectionTaskFactory
+        {
+            static IAsyncResult beginConnect(IPAddress address, int port, AsyncCallback requestCallback,
+                object state)
+            {
+                return ((Socket)state).BeginConnect(address, port, requestCallback, state);
+            }
+
+            static void endConnect(IAsyncResult asyncResult)
+            {
+                ((Socket)asyncResult.AsyncState).EndConnect(asyncResult);
+            }
+            
+            public static Task CreateTask(Socket socket, IPAddress ipAddress, int port)
+            {
+                return Task.Factory.FromAsync(beginConnect, endConnect, ipAddress, port, state: socket);
+            }
+        }
+
+        static class ProxySocketConnectionTaskFactory
+        {
+            static IAsyncResult beginConnect(IPAddress address, int port, AsyncCallback requestCallback,
+                object state)
+            {
+                return ((ProxySocket.ProxySocket)state).BeginConnect(address, port, requestCallback, state);
+            }
+
+            static void endConnect(IAsyncResult asyncResult)
+            {
+                ((ProxySocket.ProxySocket)asyncResult.AsyncState).EndConnect(asyncResult);
+            }
+
+            public static Task CreateTask(ProxySocket.ProxySocket socket, IPAddress ipAddress, int port)
+            {
+                return Task.Factory.FromAsync(beginConnect, endConnect, ipAddress, port, state: socket);
+            }
+        }
     }
 }