diff --git a/lib/csharp/src/Server/TServer.cs b/lib/csharp/src/Server/TServer.cs
index 34f06a9..2bc04f3 100644
--- a/lib/csharp/src/Server/TServer.cs
+++ b/lib/csharp/src/Server/TServer.cs
@@ -28,128 +28,128 @@
 
 namespace Thrift.Server
 {
-  public abstract class TServer
-  {
-    //Attributes
-    protected TProcessorFactory processorFactory;
-    protected TServerTransport serverTransport;
-    protected TTransportFactory inputTransportFactory;
-    protected TTransportFactory outputTransportFactory;
-    protected TProtocolFactory inputProtocolFactory;
-    protected TProtocolFactory outputProtocolFactory;
-    protected TServerEventHandler serverEventHandler = null;
+    public abstract class TServer
+    {
+        //Attributes
+        protected TProcessorFactory processorFactory;
+        protected TServerTransport serverTransport;
+        protected TTransportFactory inputTransportFactory;
+        protected TTransportFactory outputTransportFactory;
+        protected TProtocolFactory inputProtocolFactory;
+        protected TProtocolFactory outputProtocolFactory;
+        protected TServerEventHandler serverEventHandler = null;
 
-    //Methods
-    public void setEventHandler(TServerEventHandler seh)
-    {
-      serverEventHandler = seh;
-    }
-    public TServerEventHandler getEventHandler()
-    {
-      return serverEventHandler;
-    }
+        //Methods
+        public void setEventHandler(TServerEventHandler seh)
+        {
+            serverEventHandler = seh;
+        }
+        public TServerEventHandler getEventHandler()
+        {
+            return serverEventHandler;
+        }
 
-    //Log delegation
-    public delegate void LogDelegate(string str);
-    private LogDelegate _logDelegate;
-    protected LogDelegate logDelegate
-    {
-      get { return _logDelegate; }
-      set { _logDelegate = (value != null) ? value : DefaultLogDelegate; }
-    }
-    protected static void DefaultLogDelegate(string s)
-    {
-      Console.Error.WriteLine(s);
-    }
+        //Log delegation
+        public delegate void LogDelegate(string str);
+        private LogDelegate _logDelegate;
+        protected LogDelegate logDelegate
+        {
+            get { return _logDelegate; }
+            set { _logDelegate = (value != null) ? value : DefaultLogDelegate; }
+        }
+        protected static void DefaultLogDelegate(string s)
+        {
+            Console.Error.WriteLine(s);
+        }
 
-    //Construction
-    public TServer(TProcessor processor,
-              TServerTransport serverTransport)
-      : this(processor, serverTransport,
-         new TTransportFactory(),
-         new TTransportFactory(),
-         new TBinaryProtocol.Factory(),
-         new TBinaryProtocol.Factory(),
-         DefaultLogDelegate)
-    {
-    }
+        //Construction
+        public TServer(TProcessor processor,
+                  TServerTransport serverTransport)
+          : this(processor, serverTransport,
+             new TTransportFactory(),
+             new TTransportFactory(),
+             new TBinaryProtocol.Factory(),
+             new TBinaryProtocol.Factory(),
+             DefaultLogDelegate)
+        {
+        }
 
-    public TServer(TProcessor processor,
+        public TServer(TProcessor processor,
+                TServerTransport serverTransport,
+                LogDelegate logDelegate)
+          : this(processor,
+             serverTransport,
+             new TTransportFactory(),
+             new TTransportFactory(),
+             new TBinaryProtocol.Factory(),
+             new TBinaryProtocol.Factory(),
+             logDelegate)
+        {
+        }
+
+        public TServer(TProcessor processor,
+                  TServerTransport serverTransport,
+                  TTransportFactory transportFactory)
+          : this(processor,
+             serverTransport,
+             transportFactory,
+             transportFactory,
+             new TBinaryProtocol.Factory(),
+             new TBinaryProtocol.Factory(),
+             DefaultLogDelegate)
+        {
+        }
+
+        public TServer(TProcessor processor,
+                  TServerTransport serverTransport,
+                  TTransportFactory transportFactory,
+                  TProtocolFactory protocolFactory)
+          : this(processor,
+             serverTransport,
+             transportFactory,
+             transportFactory,
+             protocolFactory,
+             protocolFactory,
+               DefaultLogDelegate)
+        {
+        }
+
+        public TServer(TProcessor processor,
             TServerTransport serverTransport,
+            TTransportFactory inputTransportFactory,
+            TTransportFactory outputTransportFactory,
+            TProtocolFactory inputProtocolFactory,
+            TProtocolFactory outputProtocolFactory,
             LogDelegate logDelegate)
-      : this(processor,
-         serverTransport,
-         new TTransportFactory(),
-         new TTransportFactory(),
-         new TBinaryProtocol.Factory(),
-         new TBinaryProtocol.Factory(),
-         logDelegate)
-    {
-    }
+        {
+            this.processorFactory = new TSingletonProcessorFactory(processor);
+            this.serverTransport = serverTransport;
+            this.inputTransportFactory = inputTransportFactory;
+            this.outputTransportFactory = outputTransportFactory;
+            this.inputProtocolFactory = inputProtocolFactory;
+            this.outputProtocolFactory = outputProtocolFactory;
+            this.logDelegate = (logDelegate != null) ? logDelegate : DefaultLogDelegate;
+        }
 
-    public TServer(TProcessor processor,
-              TServerTransport serverTransport,
-              TTransportFactory transportFactory)
-      : this(processor,
-         serverTransport,
-         transportFactory,
-         transportFactory,
-         new TBinaryProtocol.Factory(),
-         new TBinaryProtocol.Factory(),
-         DefaultLogDelegate)
-    {
-    }
+        public TServer(TProcessorFactory processorFactory,
+                  TServerTransport serverTransport,
+                  TTransportFactory inputTransportFactory,
+                  TTransportFactory outputTransportFactory,
+                  TProtocolFactory inputProtocolFactory,
+                  TProtocolFactory outputProtocolFactory,
+                  LogDelegate logDelegate)
+        {
+            this.processorFactory = processorFactory;
+            this.serverTransport = serverTransport;
+            this.inputTransportFactory = inputTransportFactory;
+            this.outputTransportFactory = outputTransportFactory;
+            this.inputProtocolFactory = inputProtocolFactory;
+            this.outputProtocolFactory = outputProtocolFactory;
+            this.logDelegate = (logDelegate != null) ? logDelegate : DefaultLogDelegate;
+        }
 
-    public TServer(TProcessor processor,
-              TServerTransport serverTransport,
-              TTransportFactory transportFactory,
-              TProtocolFactory protocolFactory)
-      : this(processor,
-         serverTransport,
-         transportFactory,
-         transportFactory,
-         protocolFactory,
-         protocolFactory,
-           DefaultLogDelegate)
-    {
+        //Abstract Interface
+        public abstract void Serve();
+        public abstract void Stop();
     }
-
-    public TServer(TProcessor processor,
-        TServerTransport serverTransport,
-        TTransportFactory inputTransportFactory,
-        TTransportFactory outputTransportFactory,
-        TProtocolFactory inputProtocolFactory,
-        TProtocolFactory outputProtocolFactory,
-        LogDelegate logDelegate)
-    {
-        this.processorFactory = new TSingletonProcessorFactory(processor);
-        this.serverTransport = serverTransport;
-        this.inputTransportFactory = inputTransportFactory;
-        this.outputTransportFactory = outputTransportFactory;
-        this.inputProtocolFactory = inputProtocolFactory;
-        this.outputProtocolFactory = outputProtocolFactory;
-        this.logDelegate = (logDelegate != null) ? logDelegate : DefaultLogDelegate;
-    }
-
-    public TServer(TProcessorFactory processorFactory,
-              TServerTransport serverTransport,
-              TTransportFactory inputTransportFactory,
-              TTransportFactory outputTransportFactory,
-              TProtocolFactory inputProtocolFactory,
-              TProtocolFactory outputProtocolFactory,
-              LogDelegate logDelegate)
-    {
-        this.processorFactory = processorFactory;
-        this.serverTransport = serverTransport;
-        this.inputTransportFactory = inputTransportFactory;
-        this.outputTransportFactory = outputTransportFactory;
-        this.inputProtocolFactory = inputProtocolFactory;
-        this.outputProtocolFactory = outputProtocolFactory;
-        this.logDelegate = (logDelegate != null) ? logDelegate : DefaultLogDelegate;
-    }
-
-    //Abstract Interface
-    public abstract void Serve();
-    public abstract void Stop();
-  }
 }
diff --git a/lib/csharp/src/Server/TServerEventHandler.cs b/lib/csharp/src/Server/TServerEventHandler.cs
index 843b166..e81efc6 100644
--- a/lib/csharp/src/Server/TServerEventHandler.cs
+++ b/lib/csharp/src/Server/TServerEventHandler.cs
@@ -25,26 +25,29 @@
 
 namespace Thrift.Server
 {
-  /// <summary>
-  /// Interface implemented by server users to handle events from the server
-  /// </summary>
-  public interface TServerEventHandler
-  {
     /// <summary>
-    /// Called before the server begins */
+    /// Interface implemented by server users to handle events from the server.
     /// </summary>
-    void preServe();
-    /// <summary>
-    /// Called when a new client has connected and is about to being processing */
-    /// </summary>
-    Object createContext(Thrift.Protocol.TProtocol input, Thrift.Protocol.TProtocol output);
-    /// <summary>
-    /// Called when a client has finished request-handling to delete server context */
-    /// </summary>
-    void deleteContext(Object serverContext, Thrift.Protocol.TProtocol input, Thrift.Protocol.TProtocol output);
-    /// <summary>
-    /// Called when a client is about to call the processor */
-    /// </summary>
-    void processContext(Object serverContext, Thrift.Transport.TTransport transport);
-  };
+    public interface TServerEventHandler
+    {
+        /// <summary>
+        /// Called before the server begins.
+        /// </summary>
+        void preServe();
+
+        /// <summary>
+        /// Called when a new client has connected and is about to being processing.
+        /// </summary>
+        object createContext(Thrift.Protocol.TProtocol input, Thrift.Protocol.TProtocol output);
+
+        /// <summary>
+        /// Called when a client has finished request-handling to delete server context.
+        /// </summary>
+        void deleteContext(object serverContext, Thrift.Protocol.TProtocol input, Thrift.Protocol.TProtocol output);
+
+        /// <summary>
+        /// Called when a client is about to call the processor.
+        /// </summary>
+        void processContext(object serverContext, Thrift.Transport.TTransport transport);
+    };
 }
diff --git a/lib/csharp/src/Server/TSimpleServer.cs b/lib/csharp/src/Server/TSimpleServer.cs
index c73fecf..4e7ea96 100644
--- a/lib/csharp/src/Server/TSimpleServer.cs
+++ b/lib/csharp/src/Server/TSimpleServer.cs
@@ -27,154 +27,154 @@
 
 namespace Thrift.Server
 {
-  /// <summary>
-  /// Simple single-threaded server for testing
-  /// </summary>
-  public class TSimpleServer : TServer
-  {
-    private bool stop = false;
-
-    public TSimpleServer(TProcessor processor,
-              TServerTransport serverTransport)
-      : base(processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(), DefaultLogDelegate)
+    /// <summary>
+    /// Simple single-threaded server for testing.
+    /// </summary>
+    public class TSimpleServer : TServer
     {
-    }
+        private bool stop = false;
 
-    public TSimpleServer(TProcessor processor,
-              TServerTransport serverTransport,
-              LogDelegate logDel)
-      : base(processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(), logDel)
-    {
-    }
-
-    public TSimpleServer(TProcessor processor,
-              TServerTransport serverTransport,
-              TTransportFactory transportFactory)
-      : base(processor,
-         serverTransport,
-         transportFactory,
-         transportFactory,
-         new TBinaryProtocol.Factory(),
-         new TBinaryProtocol.Factory(),
-           DefaultLogDelegate)
-    {
-    }
-
-    public TSimpleServer(TProcessor processor,
-        TServerTransport serverTransport,
-        TTransportFactory transportFactory,
-        TProtocolFactory protocolFactory)
-        : base(processor,
-           serverTransport,
-           transportFactory,
-           transportFactory,
-           protocolFactory,
-           protocolFactory,
-           DefaultLogDelegate)
-    {
-    }
-
-    public TSimpleServer(TProcessorFactory processorFactory,
-              TServerTransport serverTransport,
-              TTransportFactory transportFactory,
-              TProtocolFactory protocolFactory)
-      : base(processorFactory,
-         serverTransport,
-         transportFactory,
-         transportFactory,
-         protocolFactory,
-         protocolFactory,
-         DefaultLogDelegate)
-    {
-    }
-
-    public override void Serve()
-    {
-      try
-      {
-        serverTransport.Listen();
-      }
-      catch (TTransportException ttx)
-      {
-        logDelegate(ttx.ToString());
-        return;
-      }
-
-      //Fire the preServe server event when server is up but before any client connections
-      if (serverEventHandler != null)
-        serverEventHandler.preServe();
-
-      while (!stop)
-      {
-        TProcessor processor = null;
-        TTransport client = null;
-        TTransport inputTransport = null;
-        TTransport outputTransport = null;
-        TProtocol inputProtocol = null;
-        TProtocol outputProtocol = null;
-        Object connectionContext = null;
-        try
+        public TSimpleServer(TProcessor processor,
+                  TServerTransport serverTransport)
+          : base(processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(), DefaultLogDelegate)
         {
-          using (client = serverTransport.Accept())
-          {
-            processor = processorFactory.GetProcessor(client);
-            if (client != null)
+        }
+
+        public TSimpleServer(TProcessor processor,
+                  TServerTransport serverTransport,
+                  LogDelegate logDel)
+          : base(processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(), logDel)
+        {
+        }
+
+        public TSimpleServer(TProcessor processor,
+                  TServerTransport serverTransport,
+                  TTransportFactory transportFactory)
+          : base(processor,
+             serverTransport,
+             transportFactory,
+             transportFactory,
+             new TBinaryProtocol.Factory(),
+             new TBinaryProtocol.Factory(),
+               DefaultLogDelegate)
+        {
+        }
+
+        public TSimpleServer(TProcessor processor,
+            TServerTransport serverTransport,
+            TTransportFactory transportFactory,
+            TProtocolFactory protocolFactory)
+            : base(processor,
+               serverTransport,
+               transportFactory,
+               transportFactory,
+               protocolFactory,
+               protocolFactory,
+               DefaultLogDelegate)
+        {
+        }
+
+        public TSimpleServer(TProcessorFactory processorFactory,
+                  TServerTransport serverTransport,
+                  TTransportFactory transportFactory,
+                  TProtocolFactory protocolFactory)
+          : base(processorFactory,
+             serverTransport,
+             transportFactory,
+             transportFactory,
+             protocolFactory,
+             protocolFactory,
+             DefaultLogDelegate)
+        {
+        }
+
+        public override void Serve()
+        {
+            try
             {
-              using (inputTransport = inputTransportFactory.GetTransport(client))
-              {
-                using (outputTransport = outputTransportFactory.GetTransport(client))
-                {
-                  inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
-                  outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
-
-                  //Recover event handler (if any) and fire createContext server event when a client connects
-                  if (serverEventHandler != null)
-                    connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol);
-
-                  //Process client requests until client disconnects
-                  while (!stop)
-                  {
-                    if (!inputTransport.Peek())
-                      break;
-
-                    //Fire processContext server event
-                    //N.B. This is the pattern implemented in C++ and the event fires provisionally.
-                    //That is to say it may be many minutes between the event firing and the client request
-                    //actually arriving or the client may hang up without ever makeing a request.
-                    if (serverEventHandler != null)
-                      serverEventHandler.processContext(connectionContext, inputTransport);
-                    //Process client request (blocks until transport is readable)
-                    if (!processor.Process(inputProtocol, outputProtocol))
-                      break;
-                  }
-                }
-              }
+                serverTransport.Listen();
             }
-          }
-        }
-        catch (TTransportException ttx)
-        {
-          if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted)
-          {
-            logDelegate(ttx.ToString());
-          }
-        }
-        catch (Exception x)
-        {
-          //Unexpected
-          logDelegate(x.ToString());
+            catch (TTransportException ttx)
+            {
+                logDelegate(ttx.ToString());
+                return;
+            }
+
+            //Fire the preServe server event when server is up but before any client connections
+            if (serverEventHandler != null)
+                serverEventHandler.preServe();
+
+            while (!stop)
+            {
+                TProcessor processor = null;
+                TTransport client = null;
+                TTransport inputTransport = null;
+                TTransport outputTransport = null;
+                TProtocol inputProtocol = null;
+                TProtocol outputProtocol = null;
+                object connectionContext = null;
+                try
+                {
+                    using (client = serverTransport.Accept())
+                    {
+                        processor = processorFactory.GetProcessor(client);
+                        if (client != null)
+                        {
+                            using (inputTransport = inputTransportFactory.GetTransport(client))
+                            {
+                                using (outputTransport = outputTransportFactory.GetTransport(client))
+                                {
+                                    inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
+                                    outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
+
+                                    //Recover event handler (if any) and fire createContext server event when a client connects
+                                    if (serverEventHandler != null)
+                                        connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol);
+
+                                    //Process client requests until client disconnects
+                                    while (!stop)
+                                    {
+                                        if (!inputTransport.Peek())
+                                            break;
+
+                                        //Fire processContext server event
+                                        //N.B. This is the pattern implemented in C++ and the event fires provisionally.
+                                        //That is to say it may be many minutes between the event firing and the client request
+                                        //actually arriving or the client may hang up without ever makeing a request.
+                                        if (serverEventHandler != null)
+                                            serverEventHandler.processContext(connectionContext, inputTransport);
+                                        //Process client request (blocks until transport is readable)
+                                        if (!processor.Process(inputProtocol, outputProtocol))
+                                            break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (TTransportException ttx)
+                {
+                    if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted)
+                    {
+                        logDelegate(ttx.ToString());
+                    }
+                }
+                catch (Exception x)
+                {
+                    //Unexpected
+                    logDelegate(x.ToString());
+                }
+
+                //Fire deleteContext server event after client disconnects
+                if (serverEventHandler != null)
+                    serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol);
+            }
         }
 
-        //Fire deleteContext server event after client disconnects
-        if (serverEventHandler != null)
-          serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol);
-      }
+        public override void Stop()
+        {
+            stop = true;
+            serverTransport.Close();
+        }
     }
-
-    public override void Stop()
-    {
-      stop = true;
-      serverTransport.Close();
-    }
-  }
 }
diff --git a/lib/csharp/src/Server/TThreadPoolServer.cs b/lib/csharp/src/Server/TThreadPoolServer.cs
index ec283da..a494ce7 100644
--- a/lib/csharp/src/Server/TThreadPoolServer.cs
+++ b/lib/csharp/src/Server/TThreadPoolServer.cs
@@ -28,268 +28,268 @@
 
 namespace Thrift.Server
 {
-  /// <summary>
-  /// Server that uses C# built-in ThreadPool to spawn threads when handling requests
-  /// </summary>
-  public class TThreadPoolServer : TServer
-  {
-    private const int DEFAULT_MIN_THREADS = -1;  // use .NET ThreadPool defaults
-    private const int DEFAULT_MAX_THREADS = -1;  // use .NET ThreadPool defaults
-    private volatile bool stop = false;
-
-    public struct Configuration
-    {
-      public int MinWorkerThreads;
-      public int MaxWorkerThreads;
-      public int MinIOThreads;
-      public int MaxIOThreads;
-
-      public Configuration(int min = DEFAULT_MIN_THREADS, int max = DEFAULT_MAX_THREADS)
-      {
-        MinWorkerThreads = min;
-        MaxWorkerThreads = max;
-        MinIOThreads = min;
-        MaxIOThreads = max;
-      }
-
-      public Configuration(int minWork, int maxWork, int minIO, int maxIO)
-      {
-        MinWorkerThreads = minWork;
-        MaxWorkerThreads = maxWork;
-        MinIOThreads = minIO;
-        MaxIOThreads = maxIO;
-      }
-    }
-
-    public TThreadPoolServer(TProcessor processor, TServerTransport serverTransport)
-        : this(new TSingletonProcessorFactory(processor), serverTransport,
-         new TTransportFactory(), new TTransportFactory(),
-         new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
-         new Configuration(), DefaultLogDelegate)
-    {
-    }
-
-    public TThreadPoolServer(TProcessor processor, TServerTransport serverTransport, LogDelegate logDelegate)
-        : this(new TSingletonProcessorFactory(processor), serverTransport,
-         new TTransportFactory(), new TTransportFactory(),
-         new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
-         new Configuration(), logDelegate)
-    {
-    }
-
-    public TThreadPoolServer(TProcessor processor,
-     TServerTransport serverTransport,
-     TTransportFactory transportFactory,
-     TProtocolFactory protocolFactory)
-        : this(new TSingletonProcessorFactory(processor), serverTransport,
-           transportFactory, transportFactory,
-           protocolFactory, protocolFactory,
-           new Configuration(), DefaultLogDelegate)
-    {
-    }
-
-    public TThreadPoolServer(TProcessorFactory processorFactory,
-                 TServerTransport serverTransport,
-                 TTransportFactory transportFactory,
-                 TProtocolFactory protocolFactory)
-        : this(processorFactory, serverTransport,
-         transportFactory, transportFactory,
-         protocolFactory, protocolFactory,
-         new Configuration(), DefaultLogDelegate)
-    {
-    }
-
-    public TThreadPoolServer(TProcessorFactory processorFactory,
-                 TServerTransport serverTransport,
-                 TTransportFactory inputTransportFactory,
-                 TTransportFactory outputTransportFactory,
-                 TProtocolFactory inputProtocolFactory,
-                 TProtocolFactory outputProtocolFactory,
-                 int minThreadPoolThreads, int maxThreadPoolThreads, LogDelegate logDel)
-        : this(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
-         inputProtocolFactory, outputProtocolFactory,
-         new Configuration(minThreadPoolThreads, maxThreadPoolThreads),
-         logDel)
-    {
-    }
-
-    public TThreadPoolServer(TProcessorFactory processorFactory,
-                 TServerTransport serverTransport,
-                 TTransportFactory inputTransportFactory,
-                 TTransportFactory outputTransportFactory,
-                 TProtocolFactory inputProtocolFactory,
-                 TProtocolFactory outputProtocolFactory,
-                 Configuration threadConfig,
-                 LogDelegate logDel)
-        : base(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
-        inputProtocolFactory, outputProtocolFactory, logDel)
-    {
-      lock (typeof(TThreadPoolServer))
-      {
-        if ((threadConfig.MaxWorkerThreads > 0) || (threadConfig.MaxIOThreads > 0))
-        {
-          int work, comm;
-          ThreadPool.GetMaxThreads(out work, out comm);
-          if (threadConfig.MaxWorkerThreads > 0)
-            work = threadConfig.MaxWorkerThreads;
-          if (threadConfig.MaxIOThreads > 0)
-            comm = threadConfig.MaxIOThreads;
-          if (!ThreadPool.SetMaxThreads(work, comm))
-            throw new Exception("Error: could not SetMaxThreads in ThreadPool");
-        }
-
-        if ((threadConfig.MinWorkerThreads > 0) || (threadConfig.MinIOThreads > 0))
-        {
-          int work, comm;
-          ThreadPool.GetMinThreads(out work, out comm);
-          if (threadConfig.MinWorkerThreads > 0)
-            work = threadConfig.MinWorkerThreads;
-          if (threadConfig.MinIOThreads > 0)
-            comm = threadConfig.MinIOThreads;
-          if (!ThreadPool.SetMinThreads(work, comm))
-            throw new Exception("Error: could not SetMinThreads in ThreadPool");
-        }
-      }
-    }
-
-
     /// <summary>
-    /// Use new ThreadPool thread for each new client connection
+    /// Server that uses C# built-in ThreadPool to spawn threads when handling requests.
     /// </summary>
-    public override void Serve()
+    public class TThreadPoolServer : TServer
     {
-      try
-      {
-        serverTransport.Listen();
-      }
-      catch (TTransportException ttx)
-      {
-        logDelegate("Error, could not listen on ServerTransport: " + ttx);
-        return;
-      }
+        private const int DEFAULT_MIN_THREADS = -1;  // use .NET ThreadPool defaults
+        private const int DEFAULT_MAX_THREADS = -1;  // use .NET ThreadPool defaults
+        private volatile bool stop = false;
 
-      //Fire the preServe server event when server is up but before any client connections
-      if (serverEventHandler != null)
-        serverEventHandler.preServe();
-
-      while (!stop)
-      {
-        int failureCount = 0;
-        try
+        public struct Configuration
         {
-          TTransport client = serverTransport.Accept();
-          ThreadPool.QueueUserWorkItem(this.Execute, client);
+            public int MinWorkerThreads;
+            public int MaxWorkerThreads;
+            public int MinIOThreads;
+            public int MaxIOThreads;
+
+            public Configuration(int min = DEFAULT_MIN_THREADS, int max = DEFAULT_MAX_THREADS)
+            {
+                MinWorkerThreads = min;
+                MaxWorkerThreads = max;
+                MinIOThreads = min;
+                MaxIOThreads = max;
+            }
+
+            public Configuration(int minWork, int maxWork, int minIO, int maxIO)
+            {
+                MinWorkerThreads = minWork;
+                MaxWorkerThreads = maxWork;
+                MinIOThreads = minIO;
+                MaxIOThreads = maxIO;
+            }
         }
-        catch (TTransportException ttx)
-        {
-          if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted)
-          {
-            ++failureCount;
-            logDelegate(ttx.ToString());
-          }
 
+        public TThreadPoolServer(TProcessor processor, TServerTransport serverTransport)
+            : this(new TSingletonProcessorFactory(processor), serverTransport,
+             new TTransportFactory(), new TTransportFactory(),
+             new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
+             new Configuration(), DefaultLogDelegate)
+        {
         }
-      }
 
-      if (stop)
-      {
-        try
+        public TThreadPoolServer(TProcessor processor, TServerTransport serverTransport, LogDelegate logDelegate)
+            : this(new TSingletonProcessorFactory(processor), serverTransport,
+             new TTransportFactory(), new TTransportFactory(),
+             new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
+             new Configuration(), logDelegate)
         {
-          serverTransport.Close();
         }
-        catch (TTransportException ttx)
-        {
-          logDelegate("TServerTransport failed on close: " + ttx.Message);
-        }
-        stop = false;
-      }
-    }
 
-    /// <summary>
-    /// Loops on processing a client forever
-    /// threadContext will be a TTransport instance
-    /// </summary>
-    /// <param name="threadContext"></param>
-    private void Execute(Object threadContext)
-    {
-      using( TTransport client = (TTransport)threadContext)
-      {
-        TProcessor processor = processorFactory.GetProcessor(client, this);
-        TTransport inputTransport = null;
-        TTransport outputTransport = null;
-        TProtocol inputProtocol = null;
-        TProtocol outputProtocol = null;
-        Object connectionContext = null;
-        try
+        public TThreadPoolServer(TProcessor processor,
+         TServerTransport serverTransport,
+         TTransportFactory transportFactory,
+         TProtocolFactory protocolFactory)
+            : this(new TSingletonProcessorFactory(processor), serverTransport,
+               transportFactory, transportFactory,
+               protocolFactory, protocolFactory,
+               new Configuration(), DefaultLogDelegate)
         {
-          try
-          {
-            inputTransport = inputTransportFactory.GetTransport(client);
-            outputTransport = outputTransportFactory.GetTransport(client);
-            inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
-            outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
-                   
-            //Recover event handler (if any) and fire createContext server event when a client connects
+        }
+
+        public TThreadPoolServer(TProcessorFactory processorFactory,
+                     TServerTransport serverTransport,
+                     TTransportFactory transportFactory,
+                     TProtocolFactory protocolFactory)
+            : this(processorFactory, serverTransport,
+             transportFactory, transportFactory,
+             protocolFactory, protocolFactory,
+             new Configuration(), DefaultLogDelegate)
+        {
+        }
+
+        public TThreadPoolServer(TProcessorFactory processorFactory,
+                     TServerTransport serverTransport,
+                     TTransportFactory inputTransportFactory,
+                     TTransportFactory outputTransportFactory,
+                     TProtocolFactory inputProtocolFactory,
+                     TProtocolFactory outputProtocolFactory,
+                     int minThreadPoolThreads, int maxThreadPoolThreads, LogDelegate logDel)
+            : this(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
+             inputProtocolFactory, outputProtocolFactory,
+             new Configuration(minThreadPoolThreads, maxThreadPoolThreads),
+             logDel)
+        {
+        }
+
+        public TThreadPoolServer(TProcessorFactory processorFactory,
+                     TServerTransport serverTransport,
+                     TTransportFactory inputTransportFactory,
+                     TTransportFactory outputTransportFactory,
+                     TProtocolFactory inputProtocolFactory,
+                     TProtocolFactory outputProtocolFactory,
+                     Configuration threadConfig,
+                     LogDelegate logDel)
+            : base(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
+            inputProtocolFactory, outputProtocolFactory, logDel)
+        {
+            lock (typeof(TThreadPoolServer))
+            {
+                if ((threadConfig.MaxWorkerThreads > 0) || (threadConfig.MaxIOThreads > 0))
+                {
+                    int work, comm;
+                    ThreadPool.GetMaxThreads(out work, out comm);
+                    if (threadConfig.MaxWorkerThreads > 0)
+                        work = threadConfig.MaxWorkerThreads;
+                    if (threadConfig.MaxIOThreads > 0)
+                        comm = threadConfig.MaxIOThreads;
+                    if (!ThreadPool.SetMaxThreads(work, comm))
+                        throw new Exception("Error: could not SetMaxThreads in ThreadPool");
+                }
+
+                if ((threadConfig.MinWorkerThreads > 0) || (threadConfig.MinIOThreads > 0))
+                {
+                    int work, comm;
+                    ThreadPool.GetMinThreads(out work, out comm);
+                    if (threadConfig.MinWorkerThreads > 0)
+                        work = threadConfig.MinWorkerThreads;
+                    if (threadConfig.MinIOThreads > 0)
+                        comm = threadConfig.MinIOThreads;
+                    if (!ThreadPool.SetMinThreads(work, comm))
+                        throw new Exception("Error: could not SetMinThreads in ThreadPool");
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Use new ThreadPool thread for each new client connection.
+        /// </summary>
+        public override void Serve()
+        {
+            try
+            {
+                serverTransport.Listen();
+            }
+            catch (TTransportException ttx)
+            {
+                logDelegate("Error, could not listen on ServerTransport: " + ttx);
+                return;
+            }
+
+            //Fire the preServe server event when server is up but before any client connections
             if (serverEventHandler != null)
-              connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol);
-  
-            //Process client requests until client disconnects
+                serverEventHandler.preServe();
+
             while (!stop)
             {
-              if (!inputTransport.Peek())
-                break;
-  
-              //Fire processContext server event
-              //N.B. This is the pattern implemented in C++ and the event fires provisionally.
-              //That is to say it may be many minutes between the event firing and the client request
-              //actually arriving or the client may hang up without ever makeing a request.
-              if (serverEventHandler != null)
-                serverEventHandler.processContext(connectionContext, inputTransport);
-              //Process client request (blocks until transport is readable)
-              if (!processor.Process(inputProtocol, outputProtocol))
-                break;
-            }
-          }
-          catch (TTransportException)
-          {
-            //Usually a client disconnect, expected
-          }
-          catch (Exception x)
-          {
-            //Unexpected
-            logDelegate("Error: " + x);
-          }
-  
-          //Fire deleteContext server event after client disconnects
-          if (serverEventHandler != null)
-            serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol);
-  
-        } 
-        finally
-        {
-          //Close transports
-          if (inputTransport != null)
-            inputTransport.Close();
-          if (outputTransport != null)
-            outputTransport.Close();
-		
-          // disposable stuff should be disposed
-          if( inputProtocol != null)
-            inputProtocol.Dispose();
-          if( outputProtocol != null)
-            outputProtocol.Dispose();
-          if( inputTransport != null)
-            inputTransport.Dispose();
-          if( outputTransport != null)
-            outputTransport.Dispose();
-        }
-      }
-    }
+                int failureCount = 0;
+                try
+                {
+                    TTransport client = serverTransport.Accept();
+                    ThreadPool.QueueUserWorkItem(this.Execute, client);
+                }
+                catch (TTransportException ttx)
+                {
+                    if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted)
+                    {
+                        ++failureCount;
+                        logDelegate(ttx.ToString());
+                    }
 
-    public override void Stop()
-    {
-      stop = true;
-      serverTransport.Close();
+                }
+            }
+
+            if (stop)
+            {
+                try
+                {
+                    serverTransport.Close();
+                }
+                catch (TTransportException ttx)
+                {
+                    logDelegate("TServerTransport failed on close: " + ttx.Message);
+                }
+                stop = false;
+            }
+        }
+
+        /// <summary>
+        /// Loops on processing a client forever
+        /// threadContext will be a TTransport instance
+        /// </summary>
+        /// <param name="threadContext"></param>
+        private void Execute(object threadContext)
+        {
+            using (TTransport client = (TTransport)threadContext)
+            {
+                TProcessor processor = processorFactory.GetProcessor(client, this);
+                TTransport inputTransport = null;
+                TTransport outputTransport = null;
+                TProtocol inputProtocol = null;
+                TProtocol outputProtocol = null;
+                object connectionContext = null;
+                try
+                {
+                    try
+                    {
+                        inputTransport = inputTransportFactory.GetTransport(client);
+                        outputTransport = outputTransportFactory.GetTransport(client);
+                        inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
+                        outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
+
+                        //Recover event handler (if any) and fire createContext server event when a client connects
+                        if (serverEventHandler != null)
+                            connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol);
+
+                        //Process client requests until client disconnects
+                        while (!stop)
+                        {
+                            if (!inputTransport.Peek())
+                                break;
+
+                            //Fire processContext server event
+                            //N.B. This is the pattern implemented in C++ and the event fires provisionally.
+                            //That is to say it may be many minutes between the event firing and the client request
+                            //actually arriving or the client may hang up without ever makeing a request.
+                            if (serverEventHandler != null)
+                                serverEventHandler.processContext(connectionContext, inputTransport);
+                            //Process client request (blocks until transport is readable)
+                            if (!processor.Process(inputProtocol, outputProtocol))
+                                break;
+                        }
+                    }
+                    catch (TTransportException)
+                    {
+                        //Usually a client disconnect, expected
+                    }
+                    catch (Exception x)
+                    {
+                        //Unexpected
+                        logDelegate("Error: " + x);
+                    }
+
+                    //Fire deleteContext server event after client disconnects
+                    if (serverEventHandler != null)
+                        serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol);
+
+                }
+                finally
+                {
+                    //Close transports
+                    if (inputTransport != null)
+                        inputTransport.Close();
+                    if (outputTransport != null)
+                        outputTransport.Close();
+
+                    // disposable stuff should be disposed
+                    if (inputProtocol != null)
+                        inputProtocol.Dispose();
+                    if (outputProtocol != null)
+                        outputProtocol.Dispose();
+                    if (inputTransport != null)
+                        inputTransport.Dispose();
+                    if (outputTransport != null)
+                        outputTransport.Dispose();
+                }
+            }
+        }
+
+        public override void Stop()
+        {
+            stop = true;
+            serverTransport.Close();
+        }
     }
-  }
 }
diff --git a/lib/csharp/src/Server/TThreadedServer.cs b/lib/csharp/src/Server/TThreadedServer.cs
index 3a1734a..cc051a3 100644
--- a/lib/csharp/src/Server/TThreadedServer.cs
+++ b/lib/csharp/src/Server/TThreadedServer.cs
@@ -26,258 +26,257 @@
 
 namespace Thrift.Server
 {
-  /// <summary>
-  /// Server that uses C# threads (as opposed to the ThreadPool) when handling requests
-  /// </summary>
-  public class TThreadedServer : TServer
-  {
-    private const int DEFAULT_MAX_THREADS = 100;
-    private volatile bool stop = false;
-    private readonly int maxThreads;
-
-    private Queue<TTransport> clientQueue;
-    private THashSet<Thread> clientThreads;
-    private object clientLock;
-    private Thread workerThread;
-
-    public int ClientThreadsCount  {
-        get { return clientThreads.Count; }
-    }
-
-    public TThreadedServer(TProcessor processor, TServerTransport serverTransport)
-        : this(new TSingletonProcessorFactory(processor), serverTransport,
-         new TTransportFactory(), new TTransportFactory(),
-         new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
-         DEFAULT_MAX_THREADS, DefaultLogDelegate)
-    {
-    }
-
-    public TThreadedServer(TProcessor processor, TServerTransport serverTransport, LogDelegate logDelegate)
-        : this(new TSingletonProcessorFactory(processor), serverTransport,
-         new TTransportFactory(), new TTransportFactory(),
-         new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
-         DEFAULT_MAX_THREADS, logDelegate)
-    {
-    }
-
-
-    public TThreadedServer(TProcessor processor,
-                 TServerTransport serverTransport,
-                 TTransportFactory transportFactory,
-                 TProtocolFactory protocolFactory)
-        : this(new TSingletonProcessorFactory(processor), serverTransport,
-         transportFactory, transportFactory,
-         protocolFactory, protocolFactory,
-         DEFAULT_MAX_THREADS, DefaultLogDelegate)
-    {
-    }
-
-    public TThreadedServer(TProcessorFactory processorFactory,
-           TServerTransport serverTransport,
-           TTransportFactory transportFactory,
-           TProtocolFactory protocolFactory)
-        : this(processorFactory, serverTransport,
-         transportFactory, transportFactory,
-         protocolFactory, protocolFactory,
-         DEFAULT_MAX_THREADS, DefaultLogDelegate)
-    {
-    }
-    public TThreadedServer(TProcessorFactory processorFactory,
-                 TServerTransport serverTransport,
-                 TTransportFactory inputTransportFactory,
-                 TTransportFactory outputTransportFactory,
-                 TProtocolFactory inputProtocolFactory,
-                 TProtocolFactory outputProtocolFactory,
-                 int maxThreads, LogDelegate logDel)
-      : base(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
-          inputProtocolFactory, outputProtocolFactory, logDel)
-    {
-      this.maxThreads = maxThreads;
-      clientQueue = new Queue<TTransport>();
-      clientLock = new object();
-      clientThreads = new THashSet<Thread>();
-    }
-
     /// <summary>
-    /// Use new Thread for each new client connection. block until numConnections < maxThreads
+    /// Server that uses C# threads (as opposed to the ThreadPool) when handling requests.
     /// </summary>
-    public override void Serve()
+    public class TThreadedServer : TServer
     {
-      try
-      {
-        //start worker thread
-        workerThread = new Thread(new ThreadStart(Execute));
-        workerThread.Start();
-        serverTransport.Listen();
-      }
-      catch (TTransportException ttx)
-      {
-        logDelegate("Error, could not listen on ServerTransport: " + ttx);
-        return;
-      }
+        private const int DEFAULT_MAX_THREADS = 100;
+        private volatile bool stop = false;
+        private readonly int maxThreads;
 
-      //Fire the preServe server event when server is up but before any client connections
-      if (serverEventHandler != null)
-        serverEventHandler.preServe();
+        private Queue<TTransport> clientQueue;
+        private THashSet<Thread> clientThreads;
+        private object clientLock;
+        private Thread workerThread;
 
-      while (!stop)
-      {
-        int failureCount = 0;
-        try
+        public int ClientThreadsCount
         {
-          TTransport client = serverTransport.Accept();
-          lock (clientLock)
-          {
-            clientQueue.Enqueue(client);
-            Monitor.Pulse(clientLock);
-          }
+            get { return clientThreads.Count; }
         }
-        catch (TTransportException ttx)
-        {
-          if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted)
-          {
-            ++failureCount;
-            logDelegate(ttx.ToString());
-          }
 
+        public TThreadedServer(TProcessor processor, TServerTransport serverTransport)
+            : this(new TSingletonProcessorFactory(processor), serverTransport,
+             new TTransportFactory(), new TTransportFactory(),
+             new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
+             DEFAULT_MAX_THREADS, DefaultLogDelegate)
+        {
         }
-      }
 
-      if (stop)
-      {
-        try
+        public TThreadedServer(TProcessor processor, TServerTransport serverTransport, LogDelegate logDelegate)
+            : this(new TSingletonProcessorFactory(processor), serverTransport,
+             new TTransportFactory(), new TTransportFactory(),
+             new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
+             DEFAULT_MAX_THREADS, logDelegate)
         {
-          serverTransport.Close();
         }
-        catch (TTransportException ttx)
+
+
+        public TThreadedServer(TProcessor processor,
+                     TServerTransport serverTransport,
+                     TTransportFactory transportFactory,
+                     TProtocolFactory protocolFactory)
+            : this(new TSingletonProcessorFactory(processor), serverTransport,
+             transportFactory, transportFactory,
+             protocolFactory, protocolFactory,
+             DEFAULT_MAX_THREADS, DefaultLogDelegate)
         {
-          logDelegate("TServeTransport failed on close: " + ttx.Message);
         }
-        stop = false;
-      }
-    }
 
-    /// <summary>
-    /// Loops on processing a client forever
-    /// threadContext will be a TTransport instance
-    /// </summary>
-    /// <param name="threadContext"></param>
-    private void Execute()
-    {
-      while (!stop)
-      {
-        TTransport client;
-        Thread t;
-        lock (clientLock)
+        public TThreadedServer(TProcessorFactory processorFactory,
+               TServerTransport serverTransport,
+               TTransportFactory transportFactory,
+               TProtocolFactory protocolFactory)
+            : this(processorFactory, serverTransport,
+             transportFactory, transportFactory,
+             protocolFactory, protocolFactory,
+             DEFAULT_MAX_THREADS, DefaultLogDelegate)
         {
-          //don't dequeue if too many connections
-          while (clientThreads.Count >= maxThreads)
-          {
-            Monitor.Wait(clientLock);
-          }
-
-          while (clientQueue.Count == 0)
-          {
-            Monitor.Wait(clientLock);
-          }
-
-          client = clientQueue.Dequeue();
-          t = new Thread(new ParameterizedThreadStart(ClientWorker));
-          clientThreads.Add(t);
         }
-        //start processing requests from client on new thread
-        t.Start(client);
-      }
-    }
-
-    private void ClientWorker(Object context)
-    {
-      using( TTransport client = (TTransport)context)
-      { 
-        TProcessor processor = processorFactory.GetProcessor(client);
-        TTransport inputTransport = null;
-        TTransport outputTransport = null;
-        TProtocol inputProtocol = null;
-        TProtocol outputProtocol = null;
-        Object connectionContext = null;
-        try
+        public TThreadedServer(TProcessorFactory processorFactory,
+                     TServerTransport serverTransport,
+                     TTransportFactory inputTransportFactory,
+                     TTransportFactory outputTransportFactory,
+                     TProtocolFactory inputProtocolFactory,
+                     TProtocolFactory outputProtocolFactory,
+                     int maxThreads, LogDelegate logDel)
+          : base(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
+              inputProtocolFactory, outputProtocolFactory, logDel)
         {
-          try
-          {
-            inputTransport = inputTransportFactory.GetTransport(client);
-            outputTransport = outputTransportFactory.GetTransport(client);
-            inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
-            outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
-  
-            //Recover event handler (if any) and fire createContext server event when a client connects
+            this.maxThreads = maxThreads;
+            clientQueue = new Queue<TTransport>();
+            clientLock = new object();
+            clientThreads = new THashSet<Thread>();
+        }
+
+        /// <summary>
+        /// Use new Thread for each new client connection. block until numConnections &lt; maxThreads.
+        /// </summary>
+        public override void Serve()
+        {
+            try
+            {
+                //start worker thread
+                workerThread = new Thread(new ThreadStart(Execute));
+                workerThread.Start();
+                serverTransport.Listen();
+            }
+            catch (TTransportException ttx)
+            {
+                logDelegate("Error, could not listen on ServerTransport: " + ttx);
+                return;
+            }
+
+            //Fire the preServe server event when server is up but before any client connections
             if (serverEventHandler != null)
-              connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol);
-  
-            //Process client requests until client disconnects
+                serverEventHandler.preServe();
+
             while (!stop)
             {
-              if (!inputTransport.Peek())
-                break;
-  
-              //Fire processContext server event
-              //N.B. This is the pattern implemented in C++ and the event fires provisionally.
-              //That is to say it may be many minutes between the event firing and the client request
-              //actually arriving or the client may hang up without ever makeing a request.
-              if (serverEventHandler != null)
-                serverEventHandler.processContext(connectionContext, inputTransport);
-              //Process client request (blocks until transport is readable)
-              if (!processor.Process(inputProtocol, outputProtocol))
-                break;
+                int failureCount = 0;
+                try
+                {
+                    TTransport client = serverTransport.Accept();
+                    lock (clientLock)
+                    {
+                        clientQueue.Enqueue(client);
+                        Monitor.Pulse(clientLock);
+                    }
+                }
+                catch (TTransportException ttx)
+                {
+                    if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted)
+                    {
+                        ++failureCount;
+                        logDelegate(ttx.ToString());
+                    }
+
+                }
             }
-          }
-          catch (TTransportException)
-          {
-            //Usually a client disconnect, expected
-          }
-          catch (Exception x)
-          {
-            //Unexpected
-            logDelegate("Error: " + x);
-          }
-  
-          //Fire deleteContext server event after client disconnects
-          if (serverEventHandler != null)
-            serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol);
-  
-          lock (clientLock)
-          {
-            clientThreads.Remove(Thread.CurrentThread);
-            Monitor.Pulse(clientLock);
-          }
 
-        } 
-        finally
-        {
-          //Close transports
-          if (inputTransport != null)
-            inputTransport.Close();
-          if (outputTransport != null)
-            outputTransport.Close();
-		
-          // disposable stuff should be disposed
-          if (inputProtocol != null)
-            inputProtocol.Dispose();
-          if (outputProtocol != null)
-            outputProtocol.Dispose();
+            if (stop)
+            {
+                try
+                {
+                    serverTransport.Close();
+                }
+                catch (TTransportException ttx)
+                {
+                    logDelegate("TServeTransport failed on close: " + ttx.Message);
+                }
+                stop = false;
+            }
         }
-      }
-    }
 
-    public override void Stop()
-    {
-      stop = true;
-      serverTransport.Close();
-      //clean up all the threads myself
-      workerThread.Abort();
-      foreach (Thread t in clientThreads)
-      {
-        t.Abort();
-      }
+        /// <summary>
+        /// Loops on processing a client forever
+        /// </summary>
+        private void Execute()
+        {
+            while (!stop)
+            {
+                TTransport client;
+                Thread t;
+                lock (clientLock)
+                {
+                    //don't dequeue if too many connections
+                    while (clientThreads.Count >= maxThreads)
+                    {
+                        Monitor.Wait(clientLock);
+                    }
+
+                    while (clientQueue.Count == 0)
+                    {
+                        Monitor.Wait(clientLock);
+                    }
+
+                    client = clientQueue.Dequeue();
+                    t = new Thread(new ParameterizedThreadStart(ClientWorker));
+                    clientThreads.Add(t);
+                }
+                //start processing requests from client on new thread
+                t.Start(client);
+            }
+        }
+
+        private void ClientWorker(object context)
+        {
+            using (TTransport client = (TTransport)context)
+            {
+                TProcessor processor = processorFactory.GetProcessor(client);
+                TTransport inputTransport = null;
+                TTransport outputTransport = null;
+                TProtocol inputProtocol = null;
+                TProtocol outputProtocol = null;
+                object connectionContext = null;
+                try
+                {
+                    try
+                    {
+                        inputTransport = inputTransportFactory.GetTransport(client);
+                        outputTransport = outputTransportFactory.GetTransport(client);
+                        inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
+                        outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
+
+                        //Recover event handler (if any) and fire createContext server event when a client connects
+                        if (serverEventHandler != null)
+                            connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol);
+
+                        //Process client requests until client disconnects
+                        while (!stop)
+                        {
+                            if (!inputTransport.Peek())
+                                break;
+
+                            //Fire processContext server event
+                            //N.B. This is the pattern implemented in C++ and the event fires provisionally.
+                            //That is to say it may be many minutes between the event firing and the client request
+                            //actually arriving or the client may hang up without ever makeing a request.
+                            if (serverEventHandler != null)
+                                serverEventHandler.processContext(connectionContext, inputTransport);
+                            //Process client request (blocks until transport is readable)
+                            if (!processor.Process(inputProtocol, outputProtocol))
+                                break;
+                        }
+                    }
+                    catch (TTransportException)
+                    {
+                        //Usually a client disconnect, expected
+                    }
+                    catch (Exception x)
+                    {
+                        //Unexpected
+                        logDelegate("Error: " + x);
+                    }
+
+                    //Fire deleteContext server event after client disconnects
+                    if (serverEventHandler != null)
+                        serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol);
+
+                    lock (clientLock)
+                    {
+                        clientThreads.Remove(Thread.CurrentThread);
+                        Monitor.Pulse(clientLock);
+                    }
+
+                }
+                finally
+                {
+                    //Close transports
+                    if (inputTransport != null)
+                        inputTransport.Close();
+                    if (outputTransport != null)
+                        outputTransport.Close();
+
+                    // disposable stuff should be disposed
+                    if (inputProtocol != null)
+                        inputProtocol.Dispose();
+                    if (outputProtocol != null)
+                        outputProtocol.Dispose();
+                }
+            }
+        }
+
+        public override void Stop()
+        {
+            stop = true;
+            serverTransport.Close();
+            //clean up all the threads myself
+            workerThread.Abort();
+            foreach (Thread t in clientThreads)
+            {
+                t.Abort();
+            }
+        }
     }
-  }
 }