Substantial improvements to memory use and performance; server can talk back to client; simplified code

Author: haneytron

SimplSockets/BlockingQueue.cs

@@ -6,6 +6,7 @@ namespace SimplSockets
 {
     /// <summary>
     /// A queue that wraps a regular generic queue but when empty will block Dequeue threads until an item is available.
+    /// This class is thread safe.
     /// </summary>
     /// <typeparam name="T">The type of the object contained in the queue.</typeparam>
     internal sealed class BlockingQueue<T>

SimplSockets/ISimplSocket.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Net;
+
+namespace SimplSockets
+{
+    /// <summary>
+    /// Represents a socket.
+    /// </summary>
+    public interface ISimplSocket : IDisposable
+    {
+        /// <summary>
+        /// Connects to an endpoint. Once this is called, you must call Close before calling Connect or Listen again. This method will not raise an error.
+        /// </summary>
+        /// <param name="endPoint">The endpoint.</param>
+        /// <returns>true if connection is successful, false otherwise.</returns>
+        bool Connect(EndPoint endPoint);
+
+        /// <summary>
+        /// Begin listening for incoming connections. Once this is called, you must call Close before calling Connect or Listen again.
+        /// </summary>
+        /// <param name="localEndpoint">The local endpoint to listen on.</param>
+        void Listen(EndPoint localEndpoint);
+
+        /// <summary>
+        /// Sends a message to the server without waiting for a response (one-way communication).
+        /// </summary>
+        /// <param name="message">The message to send.</param>
+        void Send(byte[] message);
+
+        /// <summary>
+        /// Sends a message to the server and receives the response to that message.
+        /// </summary>
+        /// <param name="message">The message to send.</param>
+        /// <returns>The response message.</returns>
+        byte[] SendReceive(byte[] message);
+
+        /// <summary>
+        /// Sends a message back to the client.
+        /// </summary>
+        /// <param name="message">The reply message to send.</param>
+        /// <param name="receivedMessage">The received message which is being replied to.</param>
+        void Reply(byte[] message, SimplSocket.ReceivedMessage receivedMessage);
+
+        /// <summary>
+        /// Closes the connection. Once this is called, you can call Connect or Listen again to start a new connection.
+        /// </summary>
+        void Close();
+
+        /// <summary>
+        /// Gets the currently connected client count (when acting as a client, this will return 0 or 1).
+        /// </summary>
+        int CurrentlyConnectedClientCount { get; }
+
+        /// <summary>
+        /// An event that is fired whenever a message is received. Hook into this to process messages and potentially call Reply to send a response.
+        /// </summary>
+        event EventHandler<MessageReceivedArgs> MessageReceived;
+
+        /// <summary>
+        /// An event that is fired whenever a socket communication error occurs. Hook into this to do something when communication errors happen.
+        /// </summary>
+        event EventHandler<SocketErrorArgs> Error;
+    }
+}

SimplSockets/ISimplSocketClient.cs

@@ -33,7 +33,7 @@ public Pool(int poolCount, Func<T> newItemMethod, Action<T> resetItemMethod)
         }
 
         /// <summary>
-        /// Pushes an item into the pool for later re-use.
+        /// Pushes an item into the pool for later re-use. The item will have its state reset.
         /// </summary>
         /// <param name="item">The item.</param>
         public void Push(T item)
@@ -44,6 +44,11 @@ public void Push(T item)
                 return;
             }
 
+            if (_resetItemMethod != null)
+            {
+                _resetItemMethod(item);
+            }
+
             lock (_queue)
             {
                 _queue.Enqueue(item);
@@ -53,42 +58,26 @@ public void Push(T item)
         /// <summary>
         /// Pops an item out of the pool for use. The item will have its state reset.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>An item.</returns>
         public T Pop()
         {
             T result = null;
 
-            // Cheap check
-            if (_queue.Count == 0)
-            {
-                result = _newItemMethod();
-                if (_resetItemMethod != null)
-                {
-                    _resetItemMethod(result);
-                }
-                return result;
-            }
-
             lock (_queue)
             {
                 // Double lock check
-                if (_queue.Count == 0)
+                if (_queue.Count > 0)
                 {
-                    result = _newItemMethod();
-                    if (_resetItemMethod != null)
-                    {
-                        _resetItemMethod(result);
-                    }
-                    return result;
+                    return _queue.Dequeue();
                 }
+            }
 
-                result = _queue.Dequeue();
-                if (_resetItemMethod != null)
-                {
-                    _resetItemMethod(result);
-                }
-                return result;
+            result = _newItemMethod();
+            if (_resetItemMethod != null)
+            {
+                _resetItemMethod(result);
             }
+            return result;
         }
     }
 }