C#

        private void button5_Click(object sender, EventArgs e)
        {
            Ping ps = new Ping();
            string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            int timeout = 10000;
            PingOptions op = new PingOptions();
            PingReply rp = ps.Send("127.0.0.1(removed)", timeout, buffer, op);
            if (rp.Status == IPStatus.Success)
            {
                listBox1.Items.Add(rp.RoundtripTime.ToString() + " MS - This is your average ping to Korea (Test 1)\n");
            }
            else
            {
                listBox1.Items.Add(rp.Status.ToString() + "Unable to connect! Server might be down - try again later..\n");
            }
        }
    }
}

public bool FileTransferStatus(FileInfo oFile, string localCertificateNames, bool isFileType, out string statusMessage)
        {
            FtpWebRequest ftpRequest;
            FtpWebResponse ftpResponse;
            try
            {
                ftpRequest = (FtpWebRequest)FtpWebRequest.Create(FTPSite + CurrentDirectory + oFile.Name);
                ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
                ftpRequest.Proxy = null;
                ftpRequest.UseBinary = true;
                ftpRequest.Credentials = new NetworkCredential(UserName, Password);
                ftpRequest.KeepAlive = KeepAlive;
                ftpRequest.EnableSsl = UseSSL;
                ftpRequest.UsePassive = true;

                if (UseSSL)
                {
                    ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateServerCertificate);
                    
                    List<string> listLocalCertificates = localCertificateNames.Split(',').ToList<string>();
                    if (isFileType)
                    {
                        foreach (string localCertificate in listLocalCertificates)
                        {
                            string currentCertificate = localCertificate.Replace("\n", "").Replace("\t", "").Replace("\r", "");
                            X509Certificate certificate = X509Certificate.CreateFromCertFile(System.AppDomain.CurrentDomain.BaseDirectory + currentCertificate.Trim());
                            ftpRequest.ClientCertificates.Add(certificate);
                        }
                    }
                    else
                    {
                        X509Store storeRoot = new X509Store(StoreName.Root, StoreLocation.LocalMachine);
                        storeRoot.Open(OpenFlags.ReadOnly);
                        X509Store storePersonal = new X509Store(StoreName.My, StoreLocation.LocalMachine);
                        storePersonal.Open(OpenFlags.ReadOnly);
                        List<string> listSerialNumbers = localCertificateNames.Split(',').ToList<string>();

                        foreach (string sn in listSerialNumbers)
                        {
                            string serialNumber = sn.Trim().ToUpper();
                            
                            X509CertificateCollection certificates = storeRoot.Certificates.Find(X509FindType.FindBySerialNumber, serialNumber, false);

                            if (certificates.Count == 0) // Not in root store
                            {
                                certificates = storePersonal.Certificates.Find(X509FindType.FindBySerialNumber, serialNumber, true);
                            }

                            if (certificates.Count == 0) //Not in personal store
                            {
                                throw new Exception(string.Format("Certificate {0} not found", serialNumber));
                            }

                            storeRoot.Close();
                            storePersonal.Close();

                            X509Certificate certificate = certificates[0];
                            ftpRequest.ClientCertificates.Add(certificate);

                        }
                    }
                }

                //Selection of file to be uploaded          
                byte[] fileContents = new byte[oFile.Length];
                using (FileStream fr = oFile.OpenRead())
                {
                    fr.Read(fileContents, 0, Convert.ToInt32(oFile.Length));
                }
                
                using (Stream writer = ftpRequest.GetRequestStream())
                {
                    writer.Write(fileContents, 0, fileContents.Length);
                }

                //Gets the FtpWebResponse of the uploading operation          
                ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
                ftpResponse.Close();
                ftpRequest = null;

                statusMessage = "Uploaded successfully";

                return true;
            }
            catch (Exception webex)
            {             
                statusMessage = webex.Message;

                return false;
            }

        }

private void onButtonClick() {
TcpClient client;            
client = new TcpClient("127.0.0.1", 25543);

            StreamWriter writer = new StreamWriter(client.GetStream());
            writer.Write("Test");
            writer.Flush();
        }

TcpClient client = new TcpClient();
        TcpListener listener = new TcpListener(25543);

if (listener.Pending()) {
                message = null;
                client = listener.AcceptTcpClient();

                StreamReader reader = new StreamReader(client.GetStream());

                while (reader.Peek() != -1)
                {
                    message += reader.Read().ToString();
                }

                MessageBox.Show(message);
            }

identity = identity.Replace("-", "");

public class VTBunchOLists : List<IEnumerable<T>>
{
    private bool isInt;

    // 'ctor
    public VTBunchOLists()
    {
        isInt = typeof(T) == typeof(Int32);
    }

    // utility conversion from T to Int32
    public Int32 TToInt32(T value)
    {
        return (Int32)Convert.ChangeType(value, typeof(Int32));
    }

    // 'Add to List
    public void Add(T howmanyT, bool ascending = true)
    {
        if (isInt)
        {
            var range = CreateRange(1, TToInt32(howmanyT), ascending);
            this.Add(range as IEnumerable<T>);
        }
    }

    private IEnumerable<int> CreateRange(Int32 howMany, bool ascending = true)
    {
        var range = Enumerable.Range(start, end);

        return (ascending) ? range : range.Reverse();
    }
}