C# System.Net.Sockets.TcpClient.Close方法代码示例

        public void TryPrint(string zplCommands)
        {
            try
            {
                // Open connection
                System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient();
                client.Connect(this.m_IPAddress, this.m_Port);

                // Write ZPL String to connection
                System.IO.StreamWriter writer = new System.IO.StreamWriter(client.GetStream());
                writer.Write(zplCommands);
                writer.Flush();

                // Close Connection
                writer.Close();
                client.Close();
            }
            catch (Exception ex)
            {
                this.m_ErrorCount += 1;
                if(this.m_ErrorCount < 10)
                {
                    System.Threading.Thread.Sleep(5000);
                    this.TryPrint(zplCommands);
                }
                else
                {
                    throw ex;
                }
            }
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            System.Text.Encoding enc = System.Text.Encoding.UTF8;

            string host = textBox2.Text.Trim();
            int port = int.Parse(textBox3.Text);
            try
            {
                System.Net.Sockets.TcpClient tcp =
                  new System.Net.Sockets.TcpClient(host, port);

                System.Net.Sockets.NetworkStream ns = tcp.GetStream();

                string sendMsg = textBox1.Text;
                if (sendMsg == "" || textBox1.Text.Length > 140)
                {
                    textBlock1.Text = "ツイートできる条件を満たしてません！！";
                    tcp.Close();
                    return;
                }

                byte[] sendBytes = enc.GetBytes(sendMsg + '\n');
                ns.Write(sendBytes, 0, sendBytes.Length);

                //TCPソケットサーバーからストリームが送られてくる場合に受け取れるように
                if (checkBox1.IsChecked == true) {
                    System.IO.MemoryStream ms = new System.IO.MemoryStream();
                     byte[] resBytes = new byte[256];
                     int resSize;
                     do
                     {
                         resSize = ns.Read(resBytes, 0, resBytes.Length);
                         if (resSize == 0)
                         {
                             textBlock1.Text = "サーバーが切断しました。";
                             return;
                         }
                         ms.Write(resBytes, 0, resSize);
                     } while (ns.DataAvailable);//TODO:RubyのTCPSocketのputsメソッドに対応していない
                     string resMsg = enc.GetString(ms.ToArray());

                    textBlock1.Text = resMsg;
                    ms.Close();
                }
                ns.Close();
                tcp.Close();
                textBlock1.Text = host + "のmikutterでつぶやきました。";
                textBox1.Text = "";
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(),"Error");
                Environment.Exit(1);
            }
        }

        public static bool CheckPort(string ip, int port, int timeout)
        {
            using (System.Net.Sockets.TcpClient tcp = new System.Net.Sockets.TcpClient())
            {
                IAsyncResult ar = tcp.BeginConnect(ip, port, null, null);
                System.Threading.WaitHandle wh = ar.AsyncWaitHandle;
                try
                {
                    if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(timeout), false))
                    {
                        tcp.Close();
                        throw new TimeoutException();
                    }

                    tcp.EndConnect(ar);

                    return true;
                }
                catch (Exception)
                {
                    return false;
                }
                finally
                {
                    wh.Close();
                }
            }
        }

        private void printButton_Click(object sender, EventArgs e)
        {
            // Printer IP Address and communication port
            string ipAddress = printerIpText.Text;
            int port = 9100;

            try
            {
                // Open connection
                System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient();
                client.Connect(ipAddress, port);

                // Write ZPL String to connection
                System.IO.StreamWriter writer = new System.IO.StreamWriter(client.GetStream());
                writer.Write(zplCode);
                writer.Flush();

                // Close Connection
                writer.Close();
                client.Close();
                MessageBox.Show("Print Successful!", "Success");
                this.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: {0}", ex);
                MessageBox.Show("No printer installed corresponds to the IP address given", "No response");
            }
        }

 public void checkAvailability(object sender, System.ComponentModel.DoWorkEventArgs e) {
     try {
         System.Net.Sockets.TcpClient clnt = new System.Net.Sockets.TcpClient("smtp.gmail.com", 587);
         clnt.Close();
         e.Result = EmailResponse.ServerReachable;
     } catch {
         e.Result = EmailResponse.ServerUnreachable;
     }
 }

 private void checkAvailability(object sender, System.ComponentModel.DoWorkEventArgs e)
 {
     try {
         System.Net.Sockets.TcpClient clnt=new System.Net.Sockets.TcpClient("smtp.gmail.com",587);
         clnt.Close();
         email_available = true;
     } catch {
         email_available = false;
     }
 }

        public static string PerformWhois(string WhoisServerHost, int WhoisServerPort, string Host)
        {
            string result="";
            try {
                String strDomain = Host;
                char[] chSplit = {'.'};
                string[] arrDomain = strDomain.Split(chSplit);
                // There may only be exactly one domain name and one suffix
                if (arrDomain.Length != 2) {
                    return "";
                }

                // The suffix may only be 2 or 3 characters long
                int nLength = arrDomain[1].Length;
                if (nLength != 2 && nLength != 3) {
                    return "";
                }

                System.Collections.Hashtable table = new System.Collections.Hashtable();
                table.Add("de", "whois.denic.de");
                table.Add("be", "whois.dns.be");
                table.Add("gov", "whois.nic.gov");
                table.Add("mil", "whois.nic.mil");

                String strServer = WhoisServerHost;
                if (table.ContainsKey(arrDomain[1])) {
                    strServer = table[arrDomain[1]].ToString();
                }
                else if (nLength == 2) {
                    // 2-letter TLD's always default to RIPE in Europe
                    strServer = "whois.ripe.net";
                }

                System.Net.Sockets.TcpClient tcpc = new System.Net.Sockets.TcpClient ();
                tcpc.Connect(strServer, WhoisServerPort);
                String strDomain1 = Host+"\r\n";
                Byte[] arrDomain1 = System.Text.Encoding.ASCII.GetBytes(strDomain1.ToCharArray());
                System.IO.Stream s = tcpc.GetStream();
                s.Write(arrDomain1, 0, strDomain1.Length);
                System.IO.StreamReader sr = new System.IO.StreamReader(tcpc.GetStream(), System.Text.Encoding.ASCII);
                System.Text.StringBuilder strBuilder = new System.Text.StringBuilder();
                string strLine = null;
                while (null != (strLine = sr.ReadLine())) {
                    strBuilder.Append(strLine+"\r\n");
                }
                result = strBuilder.ToString();
                tcpc.Close();
            }catch(Exception exc) {
                result="Could not connect to WHOIS server!\r\n"+exc.ToString();
            }
            return result;
        }

 //--簡單檢查連線狀況
 public static bool ConnectionExists()
 {
     try
     {
         System.Net.Sockets.TcpClient clnt = new System.Net.Sockets.TcpClient("mis.twse.com.tw", 80);
         clnt.Close();
         return true;
     }
     catch //(System.Exception ex)
     {
         return false;
     }
 }

        private void SendBytes(IPEndPoint endpoint, byte[] buffer)
        {
            using (var client = new System.Net.Sockets.TcpClient())
            {
                client.Connect(endpoint);

                var stream = client.GetStream();
                stream.Write(buffer, 0, buffer.Length);
                stream.Flush();

                client.Close();
            }
        }

        static void _main()
        {
            BlackCore.basic.cParams args = bcore.app.args;

               client = new System.Net.Sockets.TcpClient();

               int wavInDevices = WaveIn.DeviceCount;
               int selWav = 0;
               for (int wavDevice = 0; wavDevice < wavInDevices; wavDevice++)
               {
               WaveInCapabilities deviceInfo = WaveIn.GetCapabilities(wavDevice);
               Console.WriteLine("Device {0}: {1}, {2} channels", wavDevice, deviceInfo.ProductName, deviceInfo.Channels);
               }

               Console.Write("Select device: ");
               selWav = int.Parse(Console.ReadLine());
               Console.WriteLine("Selected device is " + selWav.ToString());

               sshClient = new SshClient(args["host"], args["user"], args["pass"]);
               sshClient.Connect();

               if (sshClient.IsConnected)
               {

               shell = sshClient.CreateShellStream("xterm", 50, 50, 640, 480, 17640);
               Console.WriteLine("Open listening socket...");
               shell.WriteLine("nc -l " + args["port"] + "|pacat --playback");
               System.Threading.Thread.Sleep(2000);

               Console.WriteLine("Try to connect...");
               client.Connect(args["host"], int.Parse(args["port"]));
               if (!client.Connected) return;
               upStream = client.GetStream();

               //====================

               WaveInEvent wavInStream = new WaveInEvent();
               wavInStream.DataAvailable += new EventHandler<WaveInEventArgs>(wavInStream_DataAvailable);
               wavInStream.DeviceNumber = selWav;
               wavInStream.WaveFormat = new WaveFormat(44100, 16, 2);
               wavInStream.StartRecording();
               Console.WriteLine("Working.....");

               Console.ReadKey();
               sshClient.Disconnect();
               client.Close();
               wavInStream.StopRecording();
               wavInStream.Dispose();
               wavInStream = null;
               }
        }

 //public ActionResult ListUpnp()
 //{
 //    var upnp = new NATUPNPLib.UPnPNATClass();
 //    if (upnp.StaticPortMappingCollection == null) return Content("UPnP Disabled");
 //    var result = upnp.StaticPortMappingCollection.Cast<NATUPNPLib.IStaticPortMapping>()
 //        .Aggregate("", (s, m) => s + m.Description + "<br/>");
 //    return Content(result);
 //}
 //public ActionResult EnableUpnp()
 //{
 //    var upnp = new NATUPNPLib.UPnPNATClass();
 //    if (upnp.StaticPortMappingCollection == null) return Content("UPnP Disabled");
 //    var localIP = System.Net.Dns.GetHostAddresses(System.Net.Dns.GetHostName())
 //        .First(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
 //    upnp.StaticPortMappingCollection.Add(25565, "TCP", 25565, localIP.ToString(), true, "Minecraft");
 //    return Redirect("/Home/ListUpnp");
 //}
 //public ActionResult DisableUpnp()
 //{
 //    var upnp = new NATUPNPLib.UPnPNATClass();
 //    if (upnp.StaticPortMappingCollection == null) return Content("UPnP Disabled");
 //    upnp.StaticPortMappingCollection.Remove(25565, "TCP");
 //    return Redirect("/Home/ListUpnp");
 //}
 public ActionResult Test()
 {
     var client = new System.Net.Sockets.TcpClient();
     try
     {
         client.Connect("localhost", 25565);
         client.Close();
         return Content("Connection OK " + DateTime.Now.Ticks);
     }
     catch (Exception e)
     {
         return Content("Error:<br />" + e.Message);
     }
 }

 public static bool TcpSocketTest(string websiteUrl)
 {
     try
     {
         System.Net.Sockets.TcpClient client =
             new System.Net.Sockets.TcpClient(websiteUrl, 80);
         client.Close();
         return true;
     }
     catch (System.Exception ex)
     {
         return false;
     }
 }

        private bool checkInternetConnection()
        {
            try
            {
                System.Net.Sockets.TcpClient clnt = new System.Net.Sockets.TcpClient("developer.anscamobile.com", 80);
                clnt.Close();
                return true;

            }
            catch (Exception ex)
            {
                return false; // host not reachable.
            }
        }

        public void Scan(object data)
        {
            System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient();
            try {

                client.BeginConnect(this.IPAddress, this.Port, new AsyncCallback(AttemptConnect), client);
                int x = 0;
                while (x <= Settings.PortScanTimeoutSeconds) {
                    System.Threading.Thread.Sleep(1000);
                    x++;
                }
                client.Close();
            } catch (Exception e) {
                Terminals.Logging.Log.Info("", e);
            }
        }

        public static void SendRaw(string Hostname, int TunnelPort, System.IO.Stream ClientStream)
        {
            System.Net.Sockets.TcpClient tunnelClient = new System.Net.Sockets.TcpClient(Hostname, TunnelPort);
            var tunnelStream = tunnelClient.GetStream();
            var tunnelReadBuffer = new byte[BUFFER_SIZE];

            Task sendRelay = new Task(() => StreamHelper.CopyTo(ClientStream, tunnelStream, BUFFER_SIZE));
            Task receiveRelay = new Task(() => StreamHelper.CopyTo(tunnelStream, ClientStream, BUFFER_SIZE));

            sendRelay.Start();
            receiveRelay.Start();

            Task.WaitAll(sendRelay, receiveRelay);

            if (tunnelStream != null)
                tunnelStream.Close();

            if (tunnelClient != null)
                tunnelClient.Close();
        }