View difference between Paste ID: ELyBNp68 and 28zRZGx1

 using System;
 using System.Collections.Generic;
 using System.Net;
 using System.Net.Sockets;
 using System.Linq;
 using System.Text;
 using System.Threading;
 
 namespace Phurious.Android.Blazr
 {
     /// <summary>
     /// An Asynchronous TCP Server that makes use of system managed threads
     /// and callbacks to stop the server ever locking up.
     /// </summary>
     public class AsyncTcpServer
     {
         /// <summary>
         /// The encoding to use when sending / receiving strings.
         /// </summary>
         public Encoding Encoding { get; set; }
 
         private TcpListener _tcpListener;
         private List<AsyncTcpClient> _clients;
 
         /// <summary>
         /// Constructor for a new server using an IPAddress and Port
         /// </summary>
         /// <param name="localaddr">The Local IP Address for the server.</param>
         /// <param name="port">The port for the server.</param>
         public AsyncTcpServer(IPAddress localaddr, int port)
             : this()
         {
             _tcpListener = new TcpListener(localaddr, port);
         }
 
         /// <summary>
         /// Constructor for a new server using an end point
         /// </summary>
         /// <param name="localEP">The local end point for the server.</param>
         public AsyncTcpServer(IPEndPoint localEP)
             : this()
         {
             _tcpListener = new TcpListener(localEP);
         }
 
         /// <summary>
         /// Private constructor for the common constructor operations.
         /// </summary>
         private AsyncTcpServer()
         {
             this.Encoding = Encoding.ASCII;
             this._clients = new List<AsyncTcpClient>();
         }
 
         /// <summary>
         /// An enumerable collection of all the currently connected tcp clients
         /// </summary>
         public IEnumerable<TcpClient> TcpClients
         {
             get
             {
                 foreach (AsyncTcpClient client in this._clients)
                 {
                     yield return client.TcpClient;
                 }
             }
         }
 
         /// <summary>
         /// Starts the TCP Server listening for new clients.
         /// </summary>
         public void Listen()
         {
             this._tcpListener.Start();
             this._tcpListener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
         }
 
 
 
         /// <summary>
         /// Stops the TCP Server listening for new clients and disconnects
         /// any currently connected clients.
         /// </summary>
         public void StopListening()
         {
             this._tcpListener.Stop();
             lock (this._clients)
             {
                 foreach (AsyncTcpClient client in this._clients)
                 {
                     client.TcpClient.Client.Disconnect(false);
                 }
 
                 this._clients.Clear();
             }
         }
 
         /// <summary>
         /// Writes a string to a given TCP Client
         /// </summary>
         /// <param name="tcpClient">The client to write to</param>
         /// <param name="data">The string to send.</param>
         public void Write(TcpClient tcpClient, String data)
         {
             byte[] bytes = this.Encoding.GetBytes(data);
 
             Write(tcpClient, bytes);
         }
 
 
 
         /// <summary>
         /// Writes a string to all clients connected.
         /// </summary>
         /// <param name="data">The string to send.</param>
         public void Write(String data)
         {
             foreach (AsyncTcpClient client in this._clients)
             {
                 Write(client.TcpClient, data);
             }
         }
 
         /// <summary>
         /// Writes a byte array to all clients connected.
         /// </summary>
         /// <param name="bytes">The bytes to send.</param>
         public void Write(Byte[] bytes)
         {
             foreach (AsyncTcpClient client in this._clients)
             {
                 Write(client.TcpClient, bytes);
             }
         }
 
         /// <summary>
         /// Writes a byte array to a given TCP Client
         /// </summary>
         /// <param name="tcpClient">The client to write to</param>
         /// <param name="bytes">The bytes to send</param>
         public void Write(TcpClient tcpClient, Byte[] bytes)
         {
             NetworkStream networkStream = tcpClient.GetStream();
 
             networkStream.BeginWrite(bytes, 0, bytes.Length, WriteCallback, tcpClient);
         }
 
         public void Write(AsyncTcpClient client, Byte[] bytes)
         {
             NetworkStream networkStream = client.NetworkStream;
 
             networkStream.BeginWrite(bytes, 0, bytes.Length, WriteCallback, client.TcpClient);
         }
 
         /// <summary>
         /// Callback for the write opertaion.
         /// </summary>
         /// <param name="result">The async result object</param>
         private void WriteCallback(IAsyncResult result)
         {
             TcpClient tcpClient = result.AsyncState as TcpClient;
             NetworkStream networkStream = tcpClient.GetStream();
 
             networkStream.EndWrite(result);
         }
 
         /// <summary>
         /// Callback for the accept tcp client opertaion.
         /// </summary>
         /// <param name="result">The async result object</param>
         private void AcceptTcpClientCallback(IAsyncResult result)
         {
             TcpClient tcpClient = _tcpListener.EndAcceptTcpClient(result);
             byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
             AsyncTcpClient client = new AsyncTcpClient(tcpClient, buffer);
             client.DataReceived += new AsyncTcpClient.DataReceivedHandler(Program.ProcessCommand);
 
             lock (this._clients)
             {
                 this._clients.Add(client);
             }
 
             NetworkStream networkStream = client.NetworkStream;
 
             networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);
 
             _tcpListener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
         }
 
         /// <summary>
         /// Callback for the read opertaion.
         /// </summary>
         /// <param name="result">The async result object</param>
         private void ReadCallback(IAsyncResult result)
         {
             AsyncTcpClient client = result.AsyncState as AsyncTcpClient;
 
             if (client == null) return;
 
             NetworkStream networkStream = client.NetworkStream;
 
             int read = networkStream.EndRead(result);
 
             if (read == 0)
             {
                 lock (this._clients)
                 {
                     this._clients.Remove(client);
                     return;
                 }
             }
 
             string data = this.Encoding.GetString(client.Buffer, 0, read);
 
             networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);
         }
     }
 
 /// <summary>
     /// Internal class to join the TCP client and buffer together
     /// for easy management in the server
     /// </summary>
     public class AsyncTcpClient
     {
         public delegate void DataReceivedHandler(AsyncTcpClient client);
         public event DataReceivedHandler DataReceived;
 
         /// <summary>
         /// The encoding to use when sending / receiving strings.
         /// </summary>
         public Encoding Encoding { get; set; }
 
         private TcpClient _tcpClient = null;
         private Byte[] _buffer = null;
 
         /// <summary>
         /// Constructor for a new Client
         /// </summary>
         /// <param name="tcpClient">The TCP client</param>
         /// <param name="buffer">The byte array buffer</param>
         public AsyncTcpClient(TcpClient tcpClient, Byte[] buffer)
             : this()
         {
             if (tcpClient == null) throw new ArgumentNullException("tcpClient is null");
 
             if (buffer == null) throw new ArgumentNullException("Buffer is null");
 
             this.TcpClient = tcpClient;
 
             this.Buffer = buffer;
         }
 
         private AsyncTcpClient()
         {
             this.Encoding = Encoding.ASCII;
         }
 
         /// <summary>
         /// Gets the TCP Client
         /// </summary>
         public TcpClient TcpClient
         {
             get
             {
                 return _tcpClient;
             }
             set
             {
                 _tcpClient = value;
             }
         }
 
         /// <summary>
         /// Gets the Buffer.
         /// </summary>
         public Byte[] Buffer
         {
             get
             {
                 return _buffer;
             }
             set
             {
                 _buffer = value;
                 if (this.DataReceived != null) this.DataReceived(this);
             }
         }
 
 
         /// <summary>
         /// Gets the network stream
         /// </summary>
         public NetworkStream NetworkStream
         {
             get
             {
                 return TcpClient.GetStream();
             }
         }
     }
 }