Protocol implementation

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

namespace Infinity.Networking
{
	/// <summary>
	/// Summary description for ClientThread.
	/// </summary>
	public class ClientConnection : IDisposable	
	{
		private const int BUFFERSIZE = 1024;

		private bool _disposed;
		private Socket _clientSocket;
		private Thread _thread;
		private MultiThreadedServerBase _server;

		protected Socket Socket
		{
			get
			{
				return _clientSocket;
			}
		}

		public Thread Thread
		{
			get
			{
				return _thread;
			}
		}

		public ClientConnection(Socket clientSocket , MultiThreadedServerBase server)
		{
			_server = server;
			_disposed = false;
			_clientSocket = clientSocket;

			_thread = new Thread(new ThreadStart(Recieve));

			// start the thread.
			try
			{
				_thread.Start();
			}
			catch(ThreadAbortException abortException)
			{
				Console.WriteLine((string)abortException.ExceptionState);
			}
		}

		~ClientConnection()
		{
			if (!_disposed)
				Dispose();
		}

		internal void Recieve()
		{
			byte[] buffer = new byte[BUFFERSIZE];

			try
			{
				_clientSocket.Receive(buffer,0,buffer.Length,SocketFlags.None);
			}
			catch (SocketException se)
			{
				switch(se.ErrorCode)
				{
					case (int)SocketErrorCodes.ConnectionAborted :
						Dispose();
						break;

					case (int)SocketErrorCodes.ConnectionResetByPeer :
						Dispose();
						break;

					// this is thrown when i need to stop
					// if the server go's down.
					case (int)SocketErrorCodes.InterruptedFunctionCall:
						break;
				}
				return;
			}

			HandleCommand(buffer);
			buffer = null;
		}

		// if i recieved something then it should be handled.
		private void HandleCommand(byte[] data)
		{
			string rxData = Encoding.Default.GetString(data);
			string command = rxData.Trim('\0').Split(' ')[0];

			// check if i got a function for this command
			if (_server.MessageHandlers.Contains(command))
			{

				((NetworkMessageHandler)_server.MessageHandlers[command])
					.DynamicInvoke(new object[]{this,rxData});
			}
			// if not i'll just continue to recieve and do nothing.
			else if (command != "")
			{
				Recieve();
			}
		}

		private string GetString(byte[] data)
		{
			return Encoding.Default.GetString(data);
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;

				_clientSocket.Close();
				_clientSocket = null;

				_thread.Abort();
				_thread = null;
			}
			else
			{
				new ObjectDisposedException("connection has alraydy been disposed");
			}
		}
	}
}