Асинхронный сокет сервер + SSL

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
 
namespace FServer
{
    class Program
    {
        static void Main(string[] args)
        {
 
            ThreadedServer ts = new ThreadedServer(
            5000);
            ts.Start();
            Console.ReadLine();
 
        }
    }
 
 class ThreadedServer
    {
        private Socket _serverSocket;
        private int _port;
 
        public ThreadedServer(int port) { _port = port; }
 
        private void SetupServerSocket()
        {
            // Получаем информацию о локальном компьютере
            IPHostEntry localMachineInfo =
                Dns.GetHostEntry(Dns.GetHostName());
            IPEndPoint myEndpoint = new IPEndPoint(
                IPAddress.Parse("127.0.0.1"), _port);
 
            // Создаем сокет, привязываем его к адресу
            // и начинаем прослушивание
            _serverSocket = new Socket(
                myEndpoint.Address.AddressFamily,
                SocketType.Stream, ProtocolType.Tcp);
            _serverSocket.Bind(myEndpoint);
            _serverSocket.Listen((int)SocketOptionName.MaxConnections);
        }
 
        private class ConnectionInfo
        {
            public Socket Socket;
            public byte[] Buffer;
        }
 
 
        private List<ConnectionInfo> _connections =
            new List<ConnectionInfo>();
 
 
        public void Start()
        {
            SetupServerSocket();
            for (int i = 0; i < 10; i++)
                _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
 
        private void AcceptCallback(IAsyncResult result)
        {
            ConnectionInfo connection = new ConnectionInfo();
            try
            {
                // Завершение операции Accept
                Socket s = (Socket)result.AsyncState;
                connection.Socket = s.EndAccept(result);
                connection.Buffer = new byte[255];
                lock (_connections) _connections.Add(connection);
 
                // Начало операции Receive и новой операции Accept
                connection.Socket.BeginReceive(connection.Buffer,
                    0, connection.Buffer.Length, SocketFlags.None,
                    new AsyncCallback(ReceiveCallback),
                    connection);
                _serverSocket.BeginAccept(new AsyncCallback(
                    AcceptCallback), result.AsyncState);
            }
            catch (SocketException exc)
            {
                CloseConnection(connection);
                Console.WriteLine("Socket exception: " +
                    exc.SocketErrorCode);
            }
            catch (Exception exc)
            {
                CloseConnection(connection);
                Console.WriteLine("Exception: " + exc);
            }
        }
 
        private void ReceiveCallback(IAsyncResult result)
        {
            ConnectionInfo connection =
                (ConnectionInfo)result.AsyncState;
            try
            {
                int bytesRead =
                    connection.Socket.EndReceive(result);
                string s = System.Text.Encoding.Unicode.GetString(connection.Buffer,0,bytesRead)+"_mds";
                byte[] b = Encoding.Unicode.GetBytes(s);
                if (0 != bytesRead)
                {
                    lock (_connections)
                    {
                        foreach (ConnectionInfo conn in
                            _connections)
                        {
                            if (connection != conn)
                            {
                                conn.Socket.Send(b,
                                    bytesRead+8, SocketFlags.None);
                            }
                        }
                    }
                    connection.Socket.BeginReceive(
                        connection.Buffer, 0,
                        connection.Buffer.Length, SocketFlags.None,
                        new AsyncCallback(ReceiveCallback),
                        connection);
                }
                else CloseConnection(connection);
            }
            catch (SocketException exc)
            {
                CloseConnection(connection);
                Console.WriteLine("Socket exception: " +
                    exc.SocketErrorCode);
            }
            catch (Exception exc)
            {
                CloseConnection(connection);
                Console.WriteLine("Exception: " + exc);
            }
        }
 
        private void CloseConnection(ConnectionInfo ci)
        {
            ci.Socket.Close();
            lock (_connections) _connections.Remove(ci);
        }
    }
}

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
 
namespace FClient
{
    class Program
    {
        static Thread sendCom;
        static Thread getCom;
        static NetworkStream stream;
        static Socket client;
 
 
        static void Main(string[] args)
        {
              Connect("127.0.0.1");
              Thread.Sleep(1000);
        }
 
        static void Connect(String server)
        {
            try
            {
                IPEndPoint iep = new IPEndPoint(IPAddress.Parse(server), 5000);
                client = new Socket(iep.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                client.BeginConnect(iep, new AsyncCallback(ConnectedTo), client);
 
            }
            catch (ArgumentNullException e)
            {
                Console.WriteLine("ArgumentNullException: {0}", e);
            }
            catch (SocketException e)
            {
                Console.WriteLine("SocketException: {0}", e);
            }
 
        }
 
        static void ConnectedTo(IAsyncResult iar)
        {
            try
            {
                client.EndConnect(iar);
 
                sendCom = new Thread(new ThreadStart(SendTo));
                sendCom.Name = "sdfd";
                sendCom.Start();
                getCom = new Thread(new ThreadStart(ReceiveData));
                getCom.Name = "RforCL";
                getCom.IsBackground = true;
                getCom.Start();
 
            }
            catch (SocketException)
            {
                Console.WriteLine("2000");
                Console.ReadLine();
            }
        }
 
        static void ReceiveData()
        {
            byte[] data = new byte[1024];
            int recv;
            string stringData;
            while (true)
            {
                try
                {
                    recv = client.Receive(data);
                }
                catch
                {
                    Console.WriteLine("2000");
                    Console.ReadLine(); 
                    break;
                }
                stringData = Encoding.Unicode.GetString(data, 0, recv);
                Console.WriteLine("Received: {0}", stringData);
            }
            return;
        }
 
        public static void SendTo()
        {
            try
            {
                while (true)
                {
                    string message = Console.ReadLine();
                    Byte[] data = System.Text.Encoding.Unicode.GetBytes(message);
                    client.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendDataSr), client);
                }
            }
            catch
            {
                Console.WriteLine("2000");
                Console.ReadLine();
            }
        }
 
        static void SendDataSr(IAsyncResult iar)
        {
            Socket remote = (Socket)iar.AsyncState;
            int sent = remote.EndSend(iar);
        }
 
        static byte[] data = new Byte[256];
 
    }
}