Работа с сокетами: клиент и сервер в одной программе

new Thread(()=>
{
while(true)
{
byte[] buffer = new byte[256];
EndPoint sndr = new EndPoint(0,0);
listener.ReceiveFrom(buffer, out sndr);
Socket sender = /*тут смотря какой протокол юзаешь*/;
sender.Connect(sndr);
sender.Send(Encoding.UTF8.GetBytes("hi, i'm server:)"));
}
}).Start();

public Socket listener;
public int Port = 12500;
//-----
        public event _OnConnect OnConnect;
        public event _OnDisconnect OnDisconnect;
        public event _OnReceive OnReceive;
        //-----
        public delegate void _OnConnect(ConnectArgs args);
        public delegate void _OnDisconnect(DisconnectArgs args);
        public delegate void _OnReceive(ReceiveArgs args);
        //-----
public class NetWrapper
{
public NetWrapper(IPEndPoint ListenPoint)
        {
            listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            listener.Bind(ListenPoint);
            Accept();
        }
}
public void Accept(){
new Thread(() =>
            {
                while(true){
                EndPoint node = new IPEndPoint(0, 0);
                byte[] data = new byte[0];
                listener.ReceiveFrom(data, ref node);
                
                    Connect((IPEndPoint)node);
                
                }
 
            }).Start();
}
public Socket Connect(IPEndPoint ConnectPoint)
        {
            int port = ++Port;
            Socket handler = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            handler.Bind(new IPEndPoint(0, port));
            handler.Connect(ConnectPoint);
            OnConnect(new ConnectArgs(node));
           //точно не помню, вроде бы после бинда в пакетах отсылается новый прослушиваемый порт.. ну да сам разберешься
            HandleNode(handler);
            return handler;
        }
private void HandleNode(Socket handler)
        {
            new Thread(() =>
            {
                byte[] data = new byte[512];
                
            HandleNode:
                int received = handler.Receive(data);
                if(received>0)
                    OnReceive(new ReceiveArgs(data, handler.RemoteEndPoint));
                if (handler.Connected)
                    goto HandleNode;
                OnDisconnect(new DisconnectArgs(handler.RemoteEndPoint));
            }).Start();
        }
/// <summary>
        /// Data sending.
        /// WARNING!
        /// If ConnectionPoint will not listen on remote machine, this method cause exception
        /// </summary>
        /// <param name="Data">Data, which need send to remote machine</param>
        /// <param name="ConnectPoint">Point(IP and PORT) on remote machine</param>
        public void Send(byte[] Data, IPEndPoint ConnectPoint)
        {
            Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            sender.Connect(ConnectPoint);
            sender.Send(Data);
        }
 
//----------------------
    /// <summary>
    /// On connect arguments
    /// </summary>
    public class ConnectArgs : EventArgs                   
    {   
                                           
        private IPEndPoint node;                           
        private DateTime date;
 
        /// <summary>
        /// Connected node
        /// </summary>
        public IPEndPoint Node { get { return node; } }
        /// <summary>
        /// Connection date 
        /// </summary>
        public DateTime Date{ get { return date; } }
        
        public ConnectArgs(EndPoint NODE)
        {
            node = (IPEndPoint)NODE;                       
            date = DateTime.Now;                           
        }                                                  
    }                                                      
    
 
    /// <summary>
    /// On Receive arguments
    /// </summary>
    public class ReceiveArgs : EventArgs
    {
        private IPEndPoint sender;
        private DateTime date;
        private byte[] data;
        /// <summary>
        /// Point, from which receives data
        /// </summary>
        public IPEndPoint Sender { get { return sender; } }
        /// <summary>
        /// Receive date
        /// </summary>
        public DateTime Date { get { return date; } }
        /// <summary>
        /// Buffer
        /// </summary>
        public byte[] Data { get { return data; } }
        public ReceiveArgs(byte[] DATA, EndPoint SENDER)
        {
            date = DateTime.Now;
            sender = (IPEndPoint)SENDER;
            data = DATA;
        }
    }
    /// <summary>
    /// On disconnect arguments
    /// </summary>
    public class DisconnectArgs : EventArgs
    {
        private IPEndPoint node;
        private DateTime date;
        /// <summary>
        /// Disconnected node
        /// </summary>
        public IPEndPoint Node { get { return node; } }
        /// <summary>
        /// Disconnect date
        /// </summary>
        public DateTime Date { get { return date; } }
        public DisconnectArgs(EndPoint NODE)
        {
            node = (IPEndPoint)NODE;
            date = DateTime.Now;
        }
    }

//часть программы№2 находится в режим прослушке
private void ServStart() // метод для старта сервера
        {
 
            IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 17103);
            Socket ClientSock; // сокет для обмена данными.
            Listener = new TcpListener(ipep);
            Listener.Start();//запуск прослушки
            Int32 i = 0;    
             byte[] buf = new byte[2]; //для отсылки ответов. хотя можно и др вариантами
            // начали слушать
            while (true) 
            {
                try
                {   
                    ClientSock = Listener.AcceptSocket(); // принимаем пакет                    
                    i = 0;
                     while (ClientSock.Connected)
                    {              
                       try
                       {
                           i = ClientSock.Receive(buffer);             // попытка чтения   
                           //buf-записали в него чегонить
                          ClientSock.Send(buf);
                          ClientSock.Close();                   
                         }
                        catch
                        {
                            ClientSock.Close();                          // ну эт если какая хрень..
                        }
                    }
                }
                catch
                {
                }
            } 
        }
 
 
//часть программы№1 по нажатию кнопки отправляет данные по сокетам и получает ответ от программы№2
 
 private void button6_Click(object sender, EventArgs e)
        {
            byte[] buffer=new byte[2];
            //создаём соккет для отправки запроса серверу
            Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 17103);
           //  buffer-записали в негочегонить
            try
            {
                //создаём соединение
                sock.Connect(ipep);
                if (sock.Connected)
                {
                    //отправляем запрос на сервер
                    sock.Send(buffer);
                    int i = sock.Receive(buf);
                    sock.Close();
                }
            }
            catch
            {
                sock.Close();
            }
        }