1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

private void btnOpen_Click(object sender, EventArgs e)
        {
            if (!server.Connected)
                try
                {
                    server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    
                    server.Connect(ipEndPoint);
                    WriteLine("Connected to Server!");

                    var listener = new Thread(Listen);
                    listener.Priority = ThreadPriority.Lowest;
                    listener.Start();
                }
                catch (Exception exception)
                {
                    WriteLine(exception.Message);
                }
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

data = new byte[1024];
var localAddress = IPAddress.Any;
tcpListener = new TcpListener(localAddress, 9050);
tcpListener.Start();
Console.WriteLine("I'am the TCP Server!");
Console.WriteLine("Waiting for a client...");

while (true)
{
    tcpClient = tcpListener.AcceptTcpClient();
    networkStream = tcpClient.GetStream();

    data = "Welcome to TCP Server!".ToByteArray();
    networkStream.Write(data, 0, data.Length);

    var listener = new Thread(Listen);
    listener.Priority = ThreadPriority.Lowest;
    listener.Start();
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

while (true)
{
    data = new byte[1024];
    received = networkStream.Read(data, 0, data.Length);
    if (received == 0)
       break;

    string get = Encoding.ASCII.GetString(data, 0, received);
    var send = get.ToByteArray();
    Console.WriteLine("Received from TCP Client: " + get);
    networkStream.Write(send, 0, send.Length);
}

networkStream.Close();
tcpClient.Close();
tcpListener.Stop();					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:

    private static byte[] data;
    private static NetworkStream networkStream;
    private static int received;
    private static TcpClient tcpClient;
    private static TcpListener tcpListener;
    private static volatile bool running;

    public static void Main()
    {
        data = new byte[1024];
        var localAddress = IPAddress.Any;
        tcpListener = new TcpListener(localAddress, 9050);
        tcpListener.Start();
        Console.WriteLine("I'am the TCP Server!");
        Console.WriteLine("Waiting for a client...");

        tcpClient = tcpListener.AcceptTcpClient();
        networkStream = tcpClient.GetStream();
        
        data = "Welcome to TCP Server!".ToByteArray();
        networkStream.Write(data, 0, data.Length);

        var listener = new Thread(Listen);
        listener.Priority = ThreadPriority.Lowest;
        running = true;
        listener.Start();


        Console.ReadLine();
        running = false;
    }

    static void Listen()
    {
        
        while (running)
        {
            data = new byte[1024];
            received = networkStream.Read(data, 0, data.Length);
            if (received > 0)
            {
                string get = Encoding.ASCII.GetString(data, 0, received);
                var send = get.ToByteArray();
                Console.WriteLine("Received from TCP Client: " + get);
                networkStream.Write(send, 0, send.Length);
            }
        }
        networkStream.Close();
        tcpClient.Close();
        tcpListener.Stop();
    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:

static class TcpListenerEx
{
  public static Task<TcpClient> AcceptTcpClientAsync(this TcpListener self)
  {
    return Task<TcpClient>.Factory.FromAsync(self.BeginAcceptTcpClient, self.EndAcceptTcpClient, state: null);
  }
}

void AcceptClients()
{
  listener.AcceptTcpClientAsync().ContinueWith(client => {
      HandleClient(client.Result);
      AcceptClients();
  });
}

void HandleClient(TcpClient tcpClient)
{
  Stream stream = tcpClient.GetStream();
  var buffer = new byte[140];
  // Aus ParallelExtensionExtras, http://blogs.msdn.com/b/pfxteam/archive/2010/04/04/9990342.aspx
  stream.ReadAsync(buffer, 0, buffer.Length).ContinueWith(read => {
    if (read.Result > 0)
      stream.WriteAsync(buffer.Reverse().ToArray(), 0, buffer.Length).ContinueWith(_ =>
        HandleClient(tcpClient)
      );
  });
}

void AcceptClients2()
{
  // Ebenfalls ParallelExtensionExtras, siehe http://blogs.msdn.com/b/pfxteam/archive/2009/06/30/9809774.aspx
  Task.Factory.Iterate(this.AcceptClients2Loop());
}

IEnumerable<Task> AcceptClients2Loop()
{
  while (true)
  {
    var client = listener.AcceptTcpClientAsync();
    yield return client;
    Task.Factory.Iterate(HandleClient2(client.Result));
  }
}

IEnumerable<Task> HandleClient2(TcpClient tcpClient)
{
  Stream stream = tcpClient.GetStream();
  var buffer = new byte[140];

  while (true) {
    var read = stream.ReadAsync(buffer, 0, buffer.Length);
    yield return read;
    if (read.Result == 0)
      break;
    yield return stream.WriteAsync(buffer.Reverse().ToArray(), 0, buffer.Length);
  }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

private void Listen()
        {
            var recv = server.Receive(data);
            stringData = Encoding.ASCII.GetString(data, 0, recv);
            WriteLine(stringData);

            while (server.Connected)
            {
                data = new byte[1024];
                recv = server.Receive(data);
                stringData = Encoding.ASCII.GetString(data, 0, recv);
                WriteLine("Received from Server: " + stringData);
            }
            WriteLine("Disconnecting from server...");
            server.Close();
        }