C# Async Mini RPC Demo

RPCDemo.cs

using ServiceStack.Text;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace NuGetABTest
{
    class Program
    {
        static int loops = 100000;
        static Stopwatch sw = new Stopwatch();
        static void Main(string[] args)
        {
            sw.Start();
            DoThingsSync();
            sw.Stop();
            Console.WriteLine("Sync version took: " + sw.Elapsed.TotalSeconds);

            sw.Restart();
            DoThingsAsync();
            sw.Stop();
            Console.WriteLine("Async version took: " + sw.Elapsed.TotalSeconds);
            Console.WriteLine();
        }

        public static void DoThingsAsync()
        {
            var t1 = Task.Run(() => ListenForThings());
            var t2 = Task.Run(() => SendStuff("Sender"));

            Task.WaitAll(t1, t2);
        }

        public static void DoThingsSync()
        {
            var t1 = Task.Run(() => ListenForThingsSync());
            var t2 = Task.Run(() => SendStuffSync("Sender"));

            Task.WaitAll(t1, t2);
        }

        public static async Task ListenForThings()
        {
            TcpListener listener = new TcpListener(IPAddress.Any, 1000);
            listener.Start();

            
            var clientTask = listener.AcceptTcpClientAsync();
            await clientTask;

            if (clientTask.IsCompleted)
            {
                await ReceiveStuff(clientTask.Result);
            }
            listener.Stop();
        }

        public static void ListenForThingsSync()
        {
            TcpListener listener = new TcpListener(IPAddress.Any, 1001);
            listener.Start();

            var client= listener.AcceptTcpClient();
            ReceiveStuffSync(client);
        }

        public static async Task ReceiveStuff(TcpClient receiver)
        {
            StreamReader reader = new StreamReader(receiver.GetStream());
            for (int i = 0; i < loops; i++)
            {
                var readTask = reader.ReadLineAsync();
                var s = RPCMessage.DecodeMessage<DateTime>(await readTask);
            }
            receiver.Close();
        }

        public static void ReceiveStuffSync(TcpClient receiver)
        {
            StreamReader reader = new StreamReader(receiver.GetStream());
            for (int i = 0; i < loops; i++)
            {
                var s = RPCMessage.DecodeMessage<DateTime>(reader.ReadLine());
            }
            receiver.Close();
        }

        public static async Task SendStuff(string name)
        {
            TcpClient sender = new TcpClient();

            await sender.ConnectAsync("127.0.0.1", 1000);

            StreamWriter writer = new StreamWriter(sender.GetStream());

            for (int sent = 0; sent < loops; sent++)
            {
                writer.WriteLine(RPCMessage.CreateMessage(DateTime.Now));
            }

            writer.Flush();
            sender.Close();
        }

        public static void SendStuffSync(string name)
        {
            TcpClient sender = new TcpClient();

            sender.Connect("127.0.0.1", 1001);

            StreamWriter writer = new StreamWriter(sender.GetStream());

            for (int i = 0; i < loops; i++)
            {
                writer.WriteLine(RPCMessage.CreateMessage(DateTime.Now));
            }

            writer.Flush();
            sender.Close();
            
        }

        public class RPCMessage
        {
            public int Dispatch { get; set; }
            public Type MessageType { get; set; }
            public string MessageData { get; set; }

            public static string CreateMessage<T>(T data)
            {
                return JsonSerializer.SerializeToString(new RPCMessage
                {
                    Dispatch = 0,
                    MessageType = typeof(T),
                    MessageData = JsonSerializer.SerializeToString(data)
                });
            }

            public static T DecodeMessage<T>(string msg)
            {
                var rpcmsg = JsonSerializer.DeserializeFromString<RPCMessage>(
                    msg);
                return (T)JsonSerializer.DeserializeFromString(
                    rpcmsg.MessageData, rpcmsg.MessageType);
            }
        }
    }
}