try  
     {  
        s.Listen(30);  
     }  
     catch ( ObjectDisposedException e )   
     {  
        Console.WriteLine(e->Message );  
     }
     catch ( SocketException e )   
     {  
        Console.WriteLine(e->Message );  
     }

using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Timers;

namespace server
{
     class mainStart
     {
         static void Main(string[] args)
         {
             IPEndPoint Addr = null; //IP и порт
             int portInUse = 8563;
             System.Console.Title="Сервер"; /*Название окна*/
             System.Console.ForegroundColor = ConsoleColor.Green; /*Весь текст в консоли теперь зелёный! ^^*/
             Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); /*Создание основного сокета. AddressFamily - указание на тип семейства адресов (InterNetwork = IPv4),  
                    * SocketType - указание на тип сокетного подключения,  ProtocolType - используемый протокол для передачи данных */
             Console.WriteLine("Запуск сервера...");
             Addr = new IPEndPoint(IPAddress.Any, portInUse);
             s.Bind(Addr);
             try
             {
                 Console.WriteLine("Прослушиваемый порт: " + portInUse);
                 Console.WriteLine("Адрес: " + Addr);
                 s.Listen(30); /*Порт ставим в режим прослушивания. Поддерживаем 30 подключений*/
             }
             catch (ObjectDisposedException e)
             {
                 Console.WriteLine("We have some problems :(");
                 Console.WriteLine(e.Message);
             }
             catch (SocketException e)
             {
                 Console.WriteLine("We have some problems :(");
                 Console.WriteLine(e.Message);
             }
             catch (InvalidOperationException e)
             {
                 Console.WriteLine("We have some problems :(");
                 Console.WriteLine(e.Message);
             }
             Console.WriteLine("Waiting...");
             Socket sAccept = s.Accept(); /*Ожидаем подключения*/
             Console.WriteLine("Есть соединение!");
             while (true)
             {
                 byte[] msg = new byte[sAccept.Available];
                 sAccept.Receive(msg); /*Принимаем сообщение*/
                 Console.WriteLine(Encoding.UTF8.GetString(msg)); /*Конвертируем и выводим на экран*/
             }
         }
     }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Timers;

namespace client
{
     class classClient
     {
         static void Main()
         {
             IPEndPoint Addr = null; //конечная точка(IP и порт)
         Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //Создаем основной сокет
         IPAddress ipAddress = null; //IP-адрес
         Console.Title = "Клиент";
         ipAddress = Dns.GetHostEntry("127.0.0.1").AddressList[0];
         Addr = new IPEndPoint(ipAddress, 8563); //"localhost" = 127.0.0.1
         s.Connect(Addr); //Коннектимся к срверу
         while (true) //Вечная истина <img src="http://s12.ucoz.net/sm/1/smile.gif" border="0" align="absmiddle" alt="smile" />
         {
             byte[] msg = Encoding.UTF8.GetBytes(Console.ReadLine()); //Конвертируем
             s.Send(msg); //Отправляем
         }
         }
     }
}

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

// State object for reading client data asynchronously
public class StateObject {
     // Client  socket.
     public Socket workSocket = null;
     // Size of receive buffer.
     public const int BufferSize = 1024;
     // Receive buffer.
     public byte[] buffer = new byte[BufferSize];
// Received data string.
     public StringBuilder sb = new StringBuilder();   
}

public class AsynchronousSocketListener {
     // Thread signal.
     public static ManualResetEvent allDone = new ManualResetEvent(false);

     public AsynchronousSocketListener() {
     }

     public static void StartListening() {
         // Data buffer for incoming data.
         byte[] bytes = new Byte[1024];

         // Establish the local endpoint for the socket.
         // The DNS name of the computer
         // running the listener is "host.contoso.com".
         IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
         IPAddress ipAddress = ipHostInfo.AddressList[0];
         IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

         // Create a TCP/IP socket.
         Socket listener = new Socket(AddressFamily.InterNetwork,
             SocketType.Stream, ProtocolType.Tcp );

         // Bind the socket to the local endpoint and listen for incoming connections.
         try {
             listener.Bind(localEndPoint);
             listener.Listen(100);

             while (true) {
                 // Set the event to nonsignaled state.
                 allDone.Reset();

                 // Start an asynchronous socket to listen for connections.
                 Console.WriteLine("Waiting for a connection...");
                 listener.BeginAccept(  
                     new AsyncCallback(AcceptCallback),
                     listener );

                 // Wait until a connection is made before continuing.
                 allDone.WaitOne();
             }

         } catch (Exception e) {
             Console.WriteLine(e.ToString());
         }

         Console.WriteLine("\nPress ENTER to continue...");
         Console.Read();
          
     }

     public static void AcceptCallback(IAsyncResult ar) {
         // Signal the main thread to continue.
         allDone.Set();

         // Get the socket that handles the client request.
         Socket listener = (Socket) ar.AsyncState;
         Socket handler = listener.EndAccept(ar);

         // Create the state object.
         StateObject state = new StateObject();
         state.workSocket = handler;
         handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
             new AsyncCallback(ReadCallback), state);
     }

     public static void ReadCallback(IAsyncResult ar) {
         String content = String.Empty;
          
         // Retrieve the state object and the handler socket
         // from the asynchronous state object.
         StateObject state = (StateObject) ar.AsyncState;
         Socket handler = state.workSocket;

         // Read data from the client socket.  
         int bytesRead = handler.EndReceive(ar);

         if (bytesRead > 0) {
             // There  might be more data, so store the data received so far.
             state.sb.Append(Encoding.ASCII.GetString(
                 state.buffer,0,bytesRead));

             // Check for end-of-file tag. If it is not there, read  
             // more data.
             content = state.sb.ToString();
             if (content.IndexOf("<EOF>") > -1) {
                 // All the data has been read from the  
                 // client. Display it on the console.
                 Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",
                     content.Length, content );
                 // Echo the data back to the client.
                 Send(handler, content);
             } else {
                 // Not all data received. Get more.
                 handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                 new AsyncCallback(ReadCallback), state);
             }
         }
     }
      
     private static void Send(Socket handler, String data) {
         // Convert the string data to byte data using ASCII encoding.
         byte[] byteData = Encoding.ASCII.GetBytes(data);

         // Begin sending the data to the remote device.
         handler.BeginSend(byteData, 0, byteData.Length, 0,
             new AsyncCallback(SendCallback), handler);
     }

     private static void SendCallback(IAsyncResult ar) {
         try {
             // Retrieve the socket from the state object.
             Socket handler = (Socket) ar.AsyncState;

             // Complete sending the data to the remote device.
             int bytesSent = handler.EndSend(ar);
             Console.WriteLine("Sent {0} bytes to client.", bytesSent);

             handler.Shutdown(SocketShutdown.Both);
             handler.Close();

         } catch (Exception e) {
             Console.WriteLine(e.ToString());
         }
     }

     public static int Main(String[] args) {
         StartListening();
         return 0;
     }
}

// Received data string.
     public StringBuilder sb = new StringBuilder();  

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace asServer
{
     class server
     {
         public static void serverStart()  
         {
             System.Console.Title = "Server";
             System.Console.ForegroundColor = ConsoleColor.Green;
             IPEndPoint fullAddress = null; /* x.x.x.x:xxxx; (IP:port)*/
             System.Console.WriteLine("Какой порт поставить в режим прослушивания?");
             System.Console.Write(">>");
             int portInUse, online;
             string pPort = System.Console.ReadLine();
             int.TryParse(pPort, out portInUse);
             System.Console.WriteLine("Сколько допускать подключений к порту " + portInUse + "?");
             System.Console.Write(">>");
             string tOnline = System.Console.ReadLine();
             int.TryParse(tOnline, out online);
             System.Console.WriteLine("Запускаем сервер...");
             Socket mySock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
             System.Console.WriteLine("port: " + portInUse);
             System.Console.WriteLine("Количество возможных подключений: " + online);
             try
             {
                 fullAddress = new IPEndPoint(IPAddress.Any, portInUse);
                 System.Console.WriteLine("Ставим порт " + portInUse + " в режим прослушивания...");
                 mySock.Bind(fullAddress);
                 mySock.Listen(online);
             }
             catch (ObjectDisposedException e)
             {
                 Console.WriteLine("We have some problems :(");
                 Console.Write("Тект ошибки: ");
                 Console.WriteLine(e.Message);
             }
             catch (SocketException e)
             {
                 Console.WriteLine("We have some problems :(");
                 Console.Write("Тект ошибки: ");
                 Console.WriteLine(e.Message);
             }
             catch (InvalidOperationException e)
             {
                 Console.WriteLine("We have some problems :(");
                 Console.Write("Тект ошибки: ");
                 Console.WriteLine(e.Message);
             }

         }
         public static void Main(string[] args)
         {
             serverStart();
             System.Console.ReadKey();
         }
     }
}