source: 2015/koodauskerho/sieerinn/TasohyppelyNettipeli/TasohyppelyNettipeli/TasohyppelyNettipeli/NetworkConnection.cs @ 7144

using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.Serialization;
using System.Threading;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;


public class NetworkConnection
{
    sealed class AssemblyBinder : SerializationBinder
    {
        public override Type BindToType(string assemblyName, string typeName)
        {
            return Type.GetType(String.Format("{0}, {1}", typeName, Assembly.GetExecutingAssembly().FullName));
        }
    }

    private const int BLOCK_SIZE = 2048;

    private readonly byte[] guidBytes;
    private readonly TcpClient client;
    private readonly CancellationTokenSource cancelSource;
    private readonly string gameName;
    private NetworkStream networkStream;
    private Thread receiveThread;

    public delegate void MessageReceived(Guid id, string message);
    public delegate void ConnectionChanged(Guid id);

    public event MessageReceived OnMessageReceive;
    public event ConnectionChanged OnConnect;
    public event ConnectionChanged OnDisconnect;

    public bool Connected { get; private set; }

    public enum MessageType
    {
        Connected = 0, Disconnected, Message
    }

    public NetworkConnection(string gameName)
    {
        Connected = false;
        this.gameName = gameName;
        var guid = Guid.NewGuid();
        guidBytes = guid.ToByteArray();
        cancelSource = new CancellationTokenSource();
        client = new TcpClient();
    }

    public bool Connect(string ip, int port)
    {
        try
        {
            client.Connect(ip, port); // TODO: try
        } catch (SocketException ex)
        {
            return false;
        }
        networkStream = client.GetStream();
        receiveThread = new Thread(() => ReceiveThread(cancelSource.Token));
        receiveThread.Start();
        Connected = true;
        Send(MessageType.Connected);
        return true;
    }

    public void Close()
    {
        if (!Connected) return;
        Send(MessageType.Disconnected);
        cancelSource.Cancel();
        receiveThread.Join();
        networkStream.Close();
        client.Client.Close();
        client.Close();
        Connected = false;
    }

    private void Send(MessageType type, string message = "")
    {
        //var mstream = new MemoryStream();
        //var writer = new BinaryWriter(mstream);

        //writer.Write((byte)type);
        //writer.Write(guidBytes, 0, guidBytes.Length);
        //writer.Write(gameName);
        //if (message.Length > 0)
        //    writer.Write(message);

        //var sendBytes = mstream.ToArray();
        //var lengthBytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(sendBytes.Length));

        //networkStream.Write(lengthBytes, 0, lengthBytes.Length);
        //networkStream.Write(sendBytes, 0, sendBytes.Length);
        //networkStream.Flush();

        var builder = new StringBuilder();

        builder.Append((int)type);
        builder.Append('\x01');

        builder.Append(Convert.ToBase64String(guidBytes));
        builder.Append('\x01');

        builder.Append(gameName);
        builder.Append('\x01');

        if (message.Length > 0)
        {
            builder.Append(message);
            builder.Append('\x01');
        }

        builder.Append('\x00');

        var bytes = Encoding.ASCII.GetBytes(builder.ToString());
        networkStream.Write(bytes, 0, bytes.Length);
        networkStream.Flush();
    }

    public void SendMessage(string message)
    {
        Send(MessageType.Message, message);
    }

    public T DeserializeFromString<T>(string settings) where T : class
    {
        var bytes = Convert.FromBase64String(settings);
        using (var mstream = new MemoryStream(bytes))
        {
            var formatter = new BinaryFormatter();
            formatter.Binder = new AssemblyBinder();
            mstream.Seek(0, SeekOrigin.Begin);
            return formatter.Deserialize(mstream) as T;
        }
    }

    public void SendObject(object serializableObject)
    {
        using (var mstream = new MemoryStream())
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(mstream, serializableObject);
            mstream.Flush();
            mstream.Position = 0;
            SendMessage(Convert.ToBase64String(mstream.ToArray()));
        }
    }

    private void ParsePacket(string packet)
    {
        var parts = packet.Split('\x01');

        var messageType = (MessageType)int.Parse(parts[0]);
        var senderGuid = new Guid(Convert.FromBase64String(parts[1]));
        var game = parts[2];

        if (messageType == MessageType.Message && OnMessageReceive != null)
        {
            var message = parts[3];
            OnMessageReceive(senderGuid, message);
        }
        else if (messageType == MessageType.Connected && OnConnect != null)
        {
            OnConnect(senderGuid);
        }
        else if (messageType == MessageType.Disconnected && OnDisconnect != null)
        {
            OnDisconnect(senderGuid);
        }
    }

    private void ReceiveThread(CancellationToken cancelToken)
    {
        var buffer = new StringBuilder();

        while (!cancelToken.IsCancellationRequested)
        {
            if (client.Available == 0)
                continue;

            var receivedBytes = new byte[BLOCK_SIZE];
            var bytesRead = networkStream.Read(receivedBytes, 0, BLOCK_SIZE);

            for (int i = 0; i < bytesRead; i++)
            {
                if (receivedBytes[i] == '\x00')
                {
                    ParsePacket(buffer.ToString());
                    buffer.Clear();
                }
                else
                {
                    buffer.Append((char)receivedBytes[i]);
                }
            }
        }
    }
}