diff --git a/src/Qoollo.Turbo/Threading/QueueProcessing/DelegateQueueAsyncProcessor.cs b/src/Qoollo.Turbo/Threading/QueueProcessing/DelegateQueueAsyncProcessor.cs
index fd35f26..2dc61bc 100644
--- a/src/Qoollo.Turbo/Threading/QueueProcessing/DelegateQueueAsyncProcessor.cs
+++ b/src/Qoollo.Turbo/Threading/QueueProcessing/DelegateQueueAsyncProcessor.cs
@@ -9,14 +9,13 @@
 namespace Qoollo.Turbo.Threading.QueueProcessing
 {
     /// <summary>
-    /// Асинхронная обработка на делегатах.
-    /// Лучше не использовать, а самостоятельно наследоваться от QueueAsyncProcessor
+    /// Asynchronous items processor with queue. Concrete processing action passed as delegate.
     /// </summary>
-    /// <typeparam name="T">Тип обрабатываемого элемента</typeparam>
+    /// <typeparam name="T">Type of the elements processed by this <see cref="DelegateQueueAsyncProcessor{T}"/></typeparam>
     public class DelegateQueueAsyncProcessor<T> : QueueAsyncProcessor<T>
     {
         /// <summary>
-        /// Контракты
+        /// Code contracts
         /// </summary>
         [ContractInvariantMethod]
         private void Invariant()
@@ -29,82 +28,83 @@ private void Invariant()
 
 
         /// <summary>
-        /// Конструктор DelegateQueueAsyncProcessor
+        /// DelegateQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="processorCount">Число потоков</param>
-        /// <param name="maxQueueSize">Максимальный размер очереди</param>
-        /// <param name="name">Имя для потоков</param>
-        /// <param name="isBackground">Будут ли потоки работать в фоновом режиме</param>
-        /// <param name="processing">Делегат обработки элементов</param>
-        /// <param name="exceptionAct">Делегат обработки исключений</param>
+        /// <param name="processorCount">Number of processing threads</param>
+        /// <param name="maxQueueSize">The bounded size of the queue (if less or equeal to 0 then no limitation)</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        /// <param name="isBackground">Whether or not processing threads are background threads</param>
+        /// <param name="processing">Delegate that will be invoked to process every item</param>
+        /// <param name="exceptionAct">Delegate that will be invoked to process unhandled exception (null is possible value)</param>
         public DelegateQueueAsyncProcessor(int processorCount, int maxQueueSize, string name, bool isBackground, Action<T, CancellationToken> processing, Action<Exception> exceptionAct)
             : base(processorCount, maxQueueSize, name, isBackground)
         {
-            Contract.Requires<ArgumentNullException>(processing != null, "processing");
+            if (processing == null)
+                throw new ArgumentNullException(nameof(processing));
 
             _processing = processing;
             _exceptionProc = exceptionAct;
         }
         /// <summary>
-        /// Конструктор DelegateQueueAsyncProcessor
+        /// DelegateQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="processorCount">Число потоков</param>
-        /// <param name="maxQueueSize">Максимальный размер очереди</param>
-        /// <param name="name">Имя для потоков</param>
-        /// <param name="processing">Делегат обработки элементов</param>
-        /// <param name="exceptionAct">Делегат обработки исключений</param>
+        /// <param name="processorCount">Number of processing threads</param>
+        /// <param name="maxQueueSize">The bounded size of the queue (if less or equeal to 0 then no limitation)</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        /// <param name="processing">Delegate that will be invoked to process every item</param>
+        /// <param name="exceptionAct">Delegate that will be invoked to process unhandled exception (null is possible value)</param>
         public DelegateQueueAsyncProcessor(int processorCount, int maxQueueSize, string name, Action<T, CancellationToken> processing, Action<Exception> exceptionAct)
             : this(processorCount, maxQueueSize, name, false, processing, exceptionAct)
         {
         }
         /// <summary>
-        /// Конструктор DelegateQueueAsyncProcessor
+        /// DelegateQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="processorCount">Число потоков</param>
-        /// <param name="maxQueueSize">Максимальный размер очереди</param>
-        /// <param name="name">Имя для потоков</param>
-        /// <param name="processing">Делегат обработки элементов</param>
+        /// <param name="processorCount">Number of processing threads</param>
+        /// <param name="maxQueueSize">The bounded size of the queue (if less or equeal to 0 then no limitation)</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        /// <param name="processing">Delegate that will be invoked to process every item</param>
         public DelegateQueueAsyncProcessor(int processorCount, int maxQueueSize, string name, Action<T, CancellationToken> processing)
             : this(processorCount, maxQueueSize, name, false, processing, null)
         {
         }
         /// <summary>
-        /// Конструктор DelegateQueueAsyncProcessor
+        /// DelegateQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="processorCount">Число потоков</param>
-        /// <param name="name">Имя для потоков</param>
-        /// <param name="processing">Делегат обработки элементов</param>
-        /// <param name="exceptionAct">Делегат обработки исключений</param>
+        /// <param name="processorCount">Number of processing threads</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        /// <param name="processing">Delegate that will be invoked to process every item</param>
+        /// <param name="exceptionAct">Delegate that will be invoked to process unhandled exception (null is possible value)</param>
         public DelegateQueueAsyncProcessor(int processorCount, string name, Action<T, CancellationToken> processing, Action<Exception> exceptionAct)
             : this(processorCount, -1, name, false, processing, exceptionAct)
         {
         }
         /// <summary>
-        /// Конструктор DelegateQueueAsyncProcessor
+        /// DelegateQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="processorCount">Число потоков</param>
-        /// <param name="name">Имя для потоков</param>
-        /// <param name="processing">Делегат обработки элементов</param>
+        /// <param name="processorCount">Number of processing threads</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        /// <param name="processing">Delegate that will be invoked to process every item</param>
         public DelegateQueueAsyncProcessor(int processorCount, string name, Action<T, CancellationToken> processing)
             : this(processorCount, -1, name, false, processing, null)
         {
         }
         /// <summary>
-        /// Конструктор DelegateQueueAsyncProcessor
+        /// DelegateQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="processorCount">Число потоков</param>
-        /// <param name="processing">Делегат обработки элементов</param>
+        /// <param name="processorCount">Number of processing threads</param>
+        /// <param name="processing">Delegate that will be invoked to process every item</param>
         public DelegateQueueAsyncProcessor(int processorCount, Action<T, CancellationToken> processing)
             : this(processorCount, -1, null, false, processing, null)
         {
         }
 
         /// <summary>
-        /// Основной метод обработки элементов
+        /// Processes a single item taken from the processing queue.
         /// </summary>
-        /// <param name="element">Элемент</param>
-        /// <param name="state">Объект состояния, инициализированный в методе Prepare()</param>
-        /// <param name="token">Токен для отмены обработки</param>
+        /// <param name="element">Item to be processed</param>
+        /// <param name="state">Thread specific state object</param>
+        /// <param name="token">Cancellation token that will be cancelled when the immediate stop is requested</param>
         protected override void Process(T element, object state, CancellationToken token)
         {
             _processing(element, token);
@@ -112,11 +112,11 @@ protected override void Process(T element, object state, CancellationToken token
 
 
         /// <summary>
-        /// Обработка исключений. 
-        /// Чтобы исключение было проброшено наверх, нужно выбросить новое исключение внутри метода.
+        /// Method that allows to process unhandled exceptions (e.g. logging).
+        /// Default behaviour - throws <see cref="QueueAsyncProcessorException"/>.
         /// </summary>
-        /// <param name="ex">Исключение</param>
-        /// <returns>Игнорировать ли исключение (false - поток завершает работу)</returns>
+        /// <param name="ex">Catched exception</param>
+        /// <returns>Whether the current exception can be safely skipped (false - the thread will retrow the exception)</returns>
         protected override bool ProcessThreadException(Exception ex)
         {
             if (_exceptionProc != null)
diff --git a/src/Qoollo.Turbo/Threading/QueueProcessing/InterfaceQueueAsyncProcessor.cs b/src/Qoollo.Turbo/Threading/QueueProcessing/InterfaceQueueAsyncProcessor.cs
index bb8426c..14baa6c 100644
--- a/src/Qoollo.Turbo/Threading/QueueProcessing/InterfaceQueueAsyncProcessor.cs
+++ b/src/Qoollo.Turbo/Threading/QueueProcessing/InterfaceQueueAsyncProcessor.cs
@@ -9,13 +9,13 @@
 namespace Qoollo.Turbo.Threading.QueueProcessing
 {
     /// <summary>
-    /// Асинхронная обработка на интерфейсе.
+    /// Asynchronous items processor with queue. Concrete processing action passed by interface <see cref="IQueueAsyncProcessorLogic{T}"/>.
     /// </summary>
-    /// <typeparam name="T">Тип обрабатываемого элемента</typeparam>
+    /// <typeparam name="T">Type of the elements processed by this <see cref="InterfaceQueueAsyncProcessor{T}"/></typeparam>
     public class InterfaceQueueAsyncProcessor<T> : QueueAsyncProcessor<T>
     {
         /// <summary>
-        /// Контракты
+        /// Code contracts
         /// </summary>
         [ContractInvariantMethod]
         private void Invariant()
@@ -26,56 +26,56 @@ private void Invariant()
         private readonly IQueueAsyncProcessorLogic<T> _logic;
 
         /// <summary>
-        /// Конструктор InterfaceQueueAsyncProcessor
+        /// InterfaceQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="logic">Интерфейс с логикой обработки данных</param>
-        /// <param name="processorCount">Число потоков обработки</param>
-        /// <param name="maxQueueSize">Максимальный размер очереди</param>
-        /// <param name="name">Имя, присваемое потокам</param>
-        /// <param name="isBackground">Будут ли потоки работать в фоновом режиме</param>
-        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int processorCount, int maxQueueSize, string name, bool isBackground)
-            : base(processorCount, maxQueueSize, name, isBackground)
+        /// <param name="logic">Implementation of the item processing logic</param>
+        /// <param name="threadCount">Number of processing threads</param>
+        /// <param name="maxQueueSize">The bounded size of the queue (if less or equeal to 0 then no limitation)</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        /// <param name="isBackground">Whether or not processing threads are background threads</param>
+        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int threadCount, int maxQueueSize, string name, bool isBackground)
+            : base(threadCount, maxQueueSize, name, isBackground)
         {
-            Contract.Requires<ArgumentNullException>(logic != null, "logic");
+            if (logic == null)
+                throw new ArgumentNullException(nameof(logic));
 
             _logic = logic;
         }
         /// <summary>
-        /// Конструктор InterfaceQueueAsyncProcessor
+        /// InterfaceQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="logic">Интерфейс с логикой обработки данных</param>
-        /// <param name="processorCount">Число потоков обработки</param>
-        /// <param name="maxQueueSize">Максимальный размер очереди</param>
-        /// <param name="name">Имя, присваемое потокам</param>
-        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int processorCount, int maxQueueSize, string name)
-            : this(logic, processorCount, maxQueueSize, name, false)
+        /// <param name="logic">Implementation of the item processing logic</param>
+        /// <param name="threadCount">Number of processing threads</param>
+        /// <param name="maxQueueSize">The bounded size of the queue (if less or equeal to 0 then no limitation)</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int threadCount, int maxQueueSize, string name)
+            : this(logic, threadCount, maxQueueSize, name, false)
         {
         }
         /// <summary>
-        /// Конструктор InterfaceQueueAsyncProcessor
+        /// InterfaceQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="logic">Интерфейс с логикой обработки данных</param>
-        /// <param name="processorCount">Число потоков обработки</param>
-        /// <param name="name">Имя, присваемое потокам</param>
-        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int processorCount, string name)
-            : this(logic, processorCount, -1, name, false)
+        /// <param name="logic">Implementation of the item processing logic</param>
+        /// <param name="threadCount">Number of processing threads</param>
+        /// <param name="name">The name for this instance of <see cref="QueueAsyncProcessor{T}"/> and its threads</param>
+        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int threadCount, string name)
+            : this(logic, threadCount, -1, name, false)
         {
         }
         /// <summary>
-        /// Конструктор InterfaceQueueAsyncProcessor
+        /// InterfaceQueueAsyncProcessor constructor
         /// </summary>
-        /// <param name="logic">Интерфейс с логикой обработки данных</param>
-        /// <param name="processorCount">Число потоков обработки</param>
-        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int processorCount)
-            : this(logic, processorCount, -1, null, false)
+        /// <param name="logic">Implementation of the item processing logic</param>
+        /// <param name="threadCount">Number of processing threads</param>
+        public InterfaceQueueAsyncProcessor(IQueueAsyncProcessorLogic<T> logic, int threadCount)
+            : this(logic, threadCount, -1, null, false)
         {
         }
 
         /// <summary>
-        /// Создание объекта состояния на поток.
-        /// Вызывается при старте для каждого потока
+        /// Creates the state that is specific for every processing thread. Executes once for every thread during start-up.
         /// </summary>
-        /// <returns>Объект состояния</returns>
+        /// <returns>Created thread-specific state object</returns>
         protected override object Prepare()
         {
             if (_logic is IQueueAsyncProcessorLogicExt<T>)
@@ -85,9 +85,9 @@ protected override object Prepare()
         }
 
         /// <summary>
-        /// Освобождение объекта состояния потока
+        /// Release the thread specific state object when the thread is about to exit
         /// </summary>
-        /// <param name="state">Объект состояния</param>
+        /// <param name="state">Thread-specific state object</param>
         protected override void Finalize(object state)
         {
             if (_logic is IQueueAsyncProcessorLogicExt<T>)
@@ -97,22 +97,22 @@ protected override void Finalize(object state)
         }
 
         /// <summary>
-        /// Основной метод обработки элементов
+        /// Processes a single item taken from the processing queue.
         /// </summary>
-        /// <param name="element">Элемент</param>
-        /// <param name="state">Объект состояния, инициализированный в методе Prepare()</param>
-        /// <param name="token">Токен для отмены обработки</param>
+        /// <param name="element">Item to be processed</param>
+        /// <param name="state">Thread specific state object</param>
+        /// <param name="token">Cancellation token that will be cancelled when the immediate stop is requested</param>
         protected override void Process(T element, object state, CancellationToken token)
         {
             _logic.Process(element, state, token);
         }
 
         /// <summary>
-        /// Обработка исключений. 
-        /// Чтобы исключение было проброшено наверх, нужно выбросить новое исключение внутри метода.
+        /// Method that allows to process unhandled exceptions (e.g. logging).
+        /// Default behaviour - throws <see cref="QueueAsyncProcessorException"/>.
         /// </summary>
-        /// <param name="ex">Исключение</param>
-        /// <returns>Игнорировать ли исключение (false - поток завершает работу)</returns>
+        /// <param name="ex">Catched exception</param>
+        /// <returns>Whether the current exception can be safely skipped (false - the thread will retrow the exception)</returns>
         protected override bool ProcessThreadException(Exception ex)
         {
             if (!_logic.ProcessThreadException(ex))
@@ -124,48 +124,47 @@ protected override bool ProcessThreadException(Exception ex)
 
 
     /// <summary>
-    /// Интерфейс с логикой асинхронной обработки данных
+    /// Specifies methods required to process the items
     /// </summary>
-    /// <typeparam name="T">Тип обрабатываемого элемента</typeparam>
+    /// <typeparam name="T">Type of the items</typeparam>
     [ContractClass(typeof(IQueueAsyncProcessorLogicCodeContractCheck<>))]
     public interface IQueueAsyncProcessorLogic<T>
     {
         /// <summary>
-        /// Основной метод обработки элементов
+        /// Processes a single item taken from the processing queue.
         /// </summary>
-        /// <param name="element">Элемент</param>
-        /// <param name="state">Объект состояния, инициализированный в методе Prepare()</param>
-        /// <param name="token">Токен для отмены обработки</param>
+        /// <param name="element">Item to be processed</param>
+        /// <param name="state">Thread specific state object</param>
+        /// <param name="token">Cancellation token that will be cancelled when the immediate stop is requested</param>
         void Process(T element, object state, CancellationToken token);
 
         /// <summary>
-        /// Обработка исключений. 
-        /// Чтобы исключение было проброшено наверх, нужно вернуть false, либо самостоятельно выбросить новое исключение внутри метода.
+        /// Method that allows to process unhandled exceptions (e.g. logging).
+        /// Default behaviour - throws <see cref="QueueAsyncProcessorException"/>.
         /// </summary>
-        /// <param name="ex">Исключение</param>
-        /// <returns>Игнорировать ли исключение (false - поток завершает работу)</returns>
+        /// <param name="ex">Catched exception</param>
+        /// <returns>Whether the current exception can be safely skipped (false - the thread will retrow the exception)</returns>
         bool ProcessThreadException(Exception ex);
     }
 
 
 
     /// <summary>
-    /// Интерфейс с расширенной логикой асинхронной обработки данных
+    /// Extended methods to process the items by <see cref="InterfaceQueueAsyncProcessor{T}"/>
     /// </summary>
-    /// <typeparam name="T">Тип обрабатываемого элемента</typeparam>
+    /// <typeparam name="T">Type of the items</typeparam>
     [ContractClass(typeof(IQueueAsyncProcessorLogicExtCodeContractCheck<>))]
     public interface IQueueAsyncProcessorLogicExt<T> : IQueueAsyncProcessorLogic<T>
     {
         /// <summary>
-        /// Создание объекта состояния на поток.
-        /// Вызывается при старте для каждого потока
+        /// Creates the state that is specific for every processing thread. Executes once for every thread during start-up.
         /// </summary>
-        /// <returns>Объект состояния</returns>
+        /// <returns>Created thread-specific state object</returns>
         object Prepare();
         /// <summary>
-        /// Освобождение объекта состояния потока
+        /// Release the thread specific state object when the thread is about to exit
         /// </summary>
-        /// <param name="state">Объект состояния</param>
+        /// <param name="state">Thread-specific state object</param>
         void Finalize(object state);
     }
 
@@ -175,22 +174,22 @@ public interface IQueueAsyncProcessorLogicExt<T> : IQueueAsyncProcessorLogic<T>
 
 
     /// <summary>
-    /// Контракты
+    /// Code contracts
     /// </summary>
     [ContractClassFor(typeof(IQueueAsyncProcessorLogic<>))]
     abstract class IQueueAsyncProcessorLogicCodeContractCheck<T> : IQueueAsyncProcessorLogic<T>
     {
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         private IQueueAsyncProcessorLogicCodeContractCheck() { }
 
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         public bool ProcessThreadException(Exception ex)
         {
             Contract.Requires(ex != null);
 
             throw new NotImplementedException();
         }
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         public void Process(T element, object state, CancellationToken token)
         {
             throw new NotImplementedException();
@@ -201,31 +200,31 @@ public void Process(T element, object state, CancellationToken token)
 
 
     /// <summary>
-    /// Контракты
+    /// Code contracts
     /// </summary>
     [ContractClassFor(typeof(IQueueAsyncProcessorLogicExt<>))]
     abstract class IQueueAsyncProcessorLogicExtCodeContractCheck<T> : IQueueAsyncProcessorLogicExt<T>
     {
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         private IQueueAsyncProcessorLogicExtCodeContractCheck() { }
 
 
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         public object Prepare()
         {
             throw new NotImplementedException();
         }
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         public void Finalize(object state)
         {
             throw new NotImplementedException();
         }
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         public void Process(T element, object state, CancellationToken token)
         {
             throw new NotImplementedException();
         }
-        /// <summary>Контракты</summary>
+        /// <summary>Code contracts</summary>
         public bool ProcessThreadException(Exception ex)
         {
             throw new NotImplementedException();
diff --git a/src/Qoollo.Turbo/Threading/QueueProcessing/QueueAsyncProcessor.cs b/src/Qoollo.Turbo/Threading/QueueProcessing/QueueAsyncProcessor.cs
index 1f1b7aa..0055c82 100644
--- a/src/Qoollo.Turbo/Threading/QueueProcessing/QueueAsyncProcessor.cs
+++ b/src/Qoollo.Turbo/Threading/QueueProcessing/QueueAsyncProcessor.cs
@@ -33,7 +33,7 @@ private void Invariant()
         private readonly bool _isBackground;
 
         private readonly Thread[] _procThreads;
-        private int _activeThreadCount;
+        private volatile int _activeThreadCount;
 
         private readonly Collections.Concurrent.BlockingQueue<T> _queue;
         private readonly int _maxQueueSize;
@@ -134,7 +134,7 @@ protected bool IsStopped
             get { return State == QueueAsyncProcessorState.Stopped; }
         }
         /// <summary>
-        /// Whether the stop was requested
+        /// Whether the stop was requested or already stopped
         /// </summary>
         protected bool IsStopRequestedOrStopped
         {
@@ -145,14 +145,14 @@ protected bool IsStopRequestedOrStopped
             }
         }
         /// <summary>
-        /// Запрещено ли добавление новых задач в пул
+        /// Is items queue marked as Completed for Adding (no new item can be added)
         /// </summary>
         public bool IsAddingCompleted
         {
             get { return _completeAdding; }
         }
         /// <summary>
-        /// Можно ли закончить обработку существующих задач
+        /// Whether the user specified that all existed items should be processed before stop
         /// </summary>
         protected bool LetFinishedProcess
         {
@@ -160,7 +160,7 @@ protected bool LetFinishedProcess
         }
 
         /// <summary>
-        /// Имя обработчика
+        /// The name for this instance of <see cref="QueueAsyncProcessor{T}"/>
         /// </summary>
         public string Name
         {
@@ -168,21 +168,21 @@ public string Name
         }
 
         /// <summary>
-        /// Работают ли потоки в фоновом режиме
+        /// Whether or not processing threads are background threads
         /// </summary>
         public bool IsBackground
         {
             get { return _isBackground; }
         }
         /// <summary>
-        /// Число работающих потоков
+        /// Number of processing threads running right now
         /// </summary>
         protected internal int ActiveThreadCount
         {
-            get { return Volatile.Read(ref _activeThreadCount); }
+            get { return _activeThreadCount; }
         }
         /// <summary>
-        /// Число потоков обработки
+        /// Number of processing threads
         /// </summary>
         public int ThreadCount
         {
@@ -190,7 +190,7 @@ public int ThreadCount
         }
 
         /// <summary>
-        /// Число элементов в очереди
+        /// Number of items inside processing queue
         /// </summary>
         public int ElementCount
         {
@@ -198,7 +198,7 @@ public int ElementCount
         }
 
         /// <summary>
-        /// Ограничения на размер очереди
+        /// The bounded size of the queue (if less or equeal to 0 then no limitation)
         /// </summary>
         public int QueueCapacity
         {
@@ -209,11 +209,11 @@ public int QueueCapacity
 
 
         /// <summary>
-        /// Допустима ли смена состояния
+        /// Verifies that state transition is possible
         /// </summary>
-        /// <param name="oldState">Старое состояние</param>
-        /// <param name="newState">Новое состояние</param>
-        /// <returns>Допустим ли переход</returns>
+        /// <param name="oldState">Current state</param>
+        /// <param name="newState">New state</param>
+        /// <returns>True when state transition can be performed</returns>
         private bool IsValidStateTransition(QueueAsyncProcessorState oldState, QueueAsyncProcessorState newState)
         {
             switch (oldState)
@@ -233,11 +233,11 @@ private bool IsValidStateTransition(QueueAsyncProcessorState oldState, QueueAsyn
             }
         }
         /// <summary>
-        /// Безопасно сменить состояние
+        /// Safely changes the current state
         /// </summary>
-        /// <param name="newState">Новое состояние</param>
-        /// <param name="prevState">Состояние, которое было до смены</param>
-        /// <returns>Произошла ли смена</returns>
+        /// <param name="newState">New state</param>
+        /// <param name="prevState">Previously observed state</param>
+        /// <returns>Was state changed (false means that the state transition is not valid)</returns>
         private bool ChangeStateSafe(QueueAsyncProcessorState newState, out QueueAsyncProcessorState prevState)
         {
             prevState = (QueueAsyncProcessorState)Volatile.Read(ref _state);
@@ -258,7 +258,7 @@ private bool ChangeStateSafe(QueueAsyncProcessorState newState, out QueueAsyncPr
         }
 
         /// <summary>
-        /// Проверить, освобождён ли объект и если да, то вызвать исключение ObjectDisposedException
+        /// Checks whether the current instance is in Stopped state and throws ObjectDisposedException when it is
         /// </summary>
         protected void CheckDisposed()
         {
@@ -266,7 +266,7 @@ protected void CheckDisposed()
                 throw new ObjectDisposedException(this.GetType().Name, "QueueAsyncProcessor is Stopped");
         }
         /// <summary>
-        /// Проверить, освобождён ли объект и если да, то вызвать исключение ObjectDisposedException
+        /// Checks whether the current instance is in Stopped or StopRequested state and throws ObjectDisposedException when it is
         /// </summary>
         protected void CheckPendingDisposeOrDisposed()
         {
@@ -276,9 +276,9 @@ protected void CheckPendingDisposeOrDisposed()
         }
 
         /// <summary>
-        /// Форсированно добавить элемент в очередь (игнорирует ограничения вместимости и текущее состояние)
+        /// Adds new item to the processing queue, even when the bounded capacity reached
         /// </summary>
-        /// <param name="element">Элемент</param>
+        /// <param name="element">New item</param>
         protected void AddForced(T element)
         {
             _queue.AddForced(element);
@@ -286,12 +286,14 @@ protected void AddForced(T element)
         }
 
         /// <summary>
-        /// Добавить элемент на обработку
+        /// Attempts to add new item to processing queue
         /// </summary>
-        /// <param name="element">Элемент</param>
-        /// <param name="timeout">Таймаут добавления в миллисекундах</param>
-        /// <param name="token">Токен отмены</param>
-        /// <returns>Успешность (удалось ли добавить до истечения таймаута)</returns>
+        /// <param name="element">New item</param>
+        /// <param name="timeout">Adding timeout in milliseconds</param>
+        /// <param name="token">Cancellation token</param>
+        /// <returns>True if item was added, otherwise false</returns>
+        /// <exception cref="ObjectDisposedException"></exception>
+        /// <exception cref="InvalidOperationException"></exception>
         public override bool Add(T element, int timeout, CancellationToken token)
         {
             CheckDisposed();
@@ -309,8 +311,10 @@ public override bool Add(T element, int timeout, CancellationToken token)
 
 
         /// <summary>
-        /// Запуск обработчиков
+        /// Starts all processing threads and changes state to <see cref="QueueAsyncProcessorState.Running"/>
         /// </summary>
+        /// <exception cref="ObjectDisposedException">Object was disposed</exception>
+        /// <exception cref="WrongStateException">Can't start processor because it is not in <see cref="QueueAsyncProcessorState.Created"/> state</exception>
         public virtual void Start()
         {
             QueueAsyncProcessorState prevState;
@@ -357,9 +361,9 @@ public virtual void Start()
         }
 
         /// <summary>
-        /// Получить токен отмены, срабатывающий при запросе остановки (в том числе и отложенной)
+        /// Gets the CancellationToken that will be cancelled when a stop is requested 
         /// </summary>
-        /// <returns>Токен отмены</returns>
+        /// <returns>Cancellation token</returns>
         protected CancellationToken GetStopRequestedCancellationToken()
         {
             var tokenSrc = this._stopRequestedCancelation;
@@ -368,9 +372,9 @@ protected CancellationToken GetStopRequestedCancellationToken()
             return new CancellationToken(true);
         }
         /// <summary>
-        /// Получить токен отмены, срабатывающий при запросе немеделнной остановки
+        /// Gets the CancellationToken that will be cancelled when a stop should be completed immediately (without <see cref="LetFinishedProcess"/> flag)
         /// </summary>
-        /// <returns>Токен отмены</returns>
+        /// <returns>Cancellation token</returns>
         protected CancellationToken GetStoppedCancellationToken()
         {
             var tokenSrc = this._stoppedCancelation;
@@ -381,7 +385,7 @@ protected CancellationToken GetStoppedCancellationToken()
 
 
         /// <summary>
-        /// Основная функция, выполняемая потоками
+        /// Main thread procedure
         /// </summary>
         [System.Diagnostics.DebuggerNonUserCode]
         private void ThreadProcFunc()
@@ -505,11 +509,11 @@ private void ThreadProcFunc()
 
 
         /// <summary>
-        /// Обработка исключений. 
-        /// Чтобы исключение было проброшено наверх, нужно выбросить новое исключение внутри метода.
+        /// Method that allows to process unhandled exceptions (e.g. logging).
+        /// Default behaviour - throws <see cref="QueueAsyncProcessorException"/>.
         /// </summary>
-        /// <param name="ex">Исключение</param>
-        /// <returns>Игнорировать ли исключение (false - поток завершает работу)</returns>
+        /// <param name="ex">Catched exception</param>
+        /// <returns>Whether the current exception can be safely skipped (false - the thread will retrow the exception)</returns>
         protected virtual bool ProcessThreadException(Exception ex)
         {
             Contract.Requires(ex != null);
@@ -518,35 +522,36 @@ protected virtual bool ProcessThreadException(Exception ex)
         }
 
         /// <summary>
-        /// Создание объекта состояния на поток.
-        /// Вызывается при старте для каждого потока
+        /// Creates the state that is specific for every processing thread. Executes once for every thread during start-up.
         /// </summary>
-        /// <returns>Объект состояния</returns>
+        /// <returns>Created thread-specific state object</returns>
         protected virtual object Prepare()
         {
             return null;
         }
         /// <summary>
-        /// Основной метод обработки элементов.
-        /// Токен отменяется только при запросе немедленной остановки. 
-        /// Остановка может быть отложенной, тогда нужно проверять текущее состояние.
+        /// Processes a single item taken from the processing queue.
         /// </summary>
-        /// <param name="element">Элемент</param>
-        /// <param name="state">Объект состояния, инициализированный в методе Prepare()</param>
-        /// <param name="token">Токен для отмены обработки при вызове Stop</param>
+        /// <remarks>
+        /// Cancellation token is cancelled only when immediate stop is requested (LetFinishProcess is false).
+        /// For that case it is improtant to manually check for <see cref="QueueAsyncProcessorState.StartRequested"/> state or use token from <see cref="GetStopRequestedCancellationToken"/>.
+        /// </remarks>
+        /// <param name="element">Item to be processed</param>
+        /// <param name="state">Thread specific state object initialized by <see cref="Prepare"/> method</param>
+        /// <param name="token">Cancellation token that will be cancelled when the immediate stop is requested (see <see cref="GetStoppedCancellationToken"/>)</param>
         protected abstract void Process(T element, object state, CancellationToken token);
 
         /// <summary>
-        /// Освобождение объекта состояния потока
+        /// Release the thread specific state object when the thread is about to exit
         /// </summary>
-        /// <param name="state">Объект состояния</param>
+        /// <param name="state">Thread-specific state object</param>
         protected virtual void Finalize(object state)
         {
         }
 
 
         /// <summary>
-        /// Запретить добавление элементов
+        /// Marks that new items cannot be added to processing queue
         /// </summary>
         public void CompleteAdding()
         {
@@ -554,7 +559,7 @@ public void CompleteAdding()
         }
 
         /// <summary>
-        /// Ожидание полной остановки
+        /// Blocks the current thread and waits for all processing threads to complete
         /// </summary>
         public void WaitUntilStop()
         {
@@ -565,10 +570,10 @@ public void WaitUntilStop()
         }
 
         /// <summary>
-        /// Ожидание полной остановки с таймаутом
+        /// Blocks the current thread and waits for all processing threads to complete
         /// </summary>
-        /// <param name="timeout">Таймаут ожидания в миллисекундах</param>
-        /// <returns>true - дождались, false - вышли по таймауту</returns>
+        /// <param name="timeout">Waiting timeout in milliseconds</param>
+        /// <returns>True when all threads completed in time</returns>
         public bool WaitUntilStop(int timeout)
         {
             if (State == QueueAsyncProcessorState.Stopped)
@@ -579,12 +584,12 @@ public bool WaitUntilStop(int timeout)
 
 
         /// <summary>
-        /// Остановка работы асинхронного обработчика
+        /// Stops processing of items and changes state to <see cref="QueueAsyncProcessorState.StopRequested"/>
         /// </summary>
-        /// <param name="waitForStop">Ждать ли завершения всех потоков</param>
-        /// <param name="letFinishProcess">Позволить закончить обработку того, что есть в очереди</param>
-        /// <param name="completeAdding">Заблокировать добавление новых элементов</param>
-        /// <returns>Запущен ли процесс остановки</returns>
+        /// <param name="waitForStop">Whether the current thread should be blocked until all processing threads are be completed</param>
+        /// <param name="letFinishProcess">Whether all items that have already been added must be processed before stopping</param>
+        /// <param name="completeAdding">Marks that new items cannot be added to processing queue</param>
+        /// <returns>Is stopping process triggered</returns>
         private bool StopProcessor(bool waitForStop, bool letFinishProcess, bool completeAdding)
         {
             if (this.IsStopRequestedOrStopped)
@@ -670,11 +675,11 @@ private bool StopProcessor(bool waitForStop, bool letFinishProcess, bool complet
 
 
         /// <summary>
-        /// Остановка и освобождение ресурсов
+        /// Stops processing of items and changes state to <see cref="QueueAsyncProcessorState.StopRequested"/>
         /// </summary>
-        /// <param name="waitForStop">Ожидать остановки</param>
-        /// <param name="letFinishProcess">Позволить обработать всю очередь</param>
-        /// <param name="completeAdding">Запретить добавление новых элементов</param>
+        /// <param name="waitForStop">Whether the current thread should be blocked until all processing threads are be completed</param>
+        /// <param name="letFinishProcess">Whether all items that have already been added must be processed before stopping</param>
+        /// <param name="completeAdding">Marks that new items cannot be added to processing queue</param>
         public virtual void Stop(bool waitForStop, bool letFinishProcess, bool completeAdding)
         {
             StopProcessor(waitForStop, letFinishProcess, completeAdding);
@@ -682,7 +687,7 @@ public virtual void Stop(bool waitForStop, bool letFinishProcess, bool completeA
         }
 
         /// <summary>
-        /// Остановка и освобождение ресурсов
+        /// Stops processing of items and changes state to <see cref="QueueAsyncProcessorState.StopRequested"/>
         /// </summary>
         public void Stop()
         {
@@ -690,14 +695,14 @@ public void Stop()
         }
 
         /// <summary>
-        /// Основной код освобождения ресурсов
+        /// Cleans-up resources
         /// </summary>
-        /// <param name="isUserCall">Вызвано ли освобождение пользователем. False - деструктор</param>
+        /// <param name="isUserCall">Is it called explicitly by user (False - from finalizer)</param>
         protected override void Dispose(bool isUserCall)
         {
             if (!this.IsStopRequestedOrStopped)
             {
-                Debug.Assert(isUserCall, "QueueAsyncProcessor destructor: Better to dispose by user. Закомментируй, если не нравится.");
+                Debug.Assert(isUserCall, "QueueAsyncProcessor destructor: Better to dispose by user");
 
                 if (isUserCall)
                     StopProcessor(true, false, true);
@@ -717,12 +722,14 @@ protected override void Dispose(bool isUserCall)
             base.Dispose(isUserCall);
         }
 
+#if DEBUG
         /// <summary>
-        /// Финализатор
+        /// Finalizer
         /// </summary>
         ~QueueAsyncProcessor()
         {
             Dispose(false);
         }
+#endif
     }
 }