implab/ImplabNet Commit - r154:2dcdee4c0810

docs

cin -

r154:2dcdee4c0810 v2

parent child

Context file:

r154:2dcdee4c0810

Collapse all files

Implab/Components/ExecutionState.cs +1 0

              namespace Implab.Components {
                  public enum ExecutionState {
                      Uninitialized,
                      Initial,
                      Starting,
                      Running,
                      Stopping,
                      Stopped,
                      Disposed,
                      Failed
                  }
              }
  No newline at end of file

Implab/Components/ObjectPool.cs +23 -8

              using Implab.Parallels;
              using System;
              using System.Threading;
              namespace Implab.Components {
                  /// <summary>
-                 /// Базовый класс для создания пулов объектов.
+                 /// The base class for creating object pools.
                  /// </summary>
                  /// <remarks>
-                 /// <para>Пул объектов позволяет многократно использовать один и тотже объект,
-                 /// что актуально для объектов, создание которых требует существенных ресурсов.
-                 /// Пул объектов использует слабые ссылки, чтобы не препятствовать освобождению
-                 /// ресурсов и создает новые объекты при необходимости.</para>
+                 /// <para>The objects pool is offers frequently requested objects to be reused, this gives
+                 /// a gool speed improvement for the 'heavy' objects. To avoid memory overhead the pool uses
+                 /// weak references allowing CG to do it's work. If there are no free objects in the pool
+                 /// they are created on demand. </para>
                  /// <para>
-                 /// Наследники должны реализовывать метод <see cref="CreateInstance()"/> для создания
-                 /// новых экземпляров.
+                 /// Implementors need to defined a <see cref="CreateInstance()"/> method
                  /// </para>
-                 /// <para>Пул поддерживает обращения сразу из нескольких потоков.</para>
+                 /// <para>The instances of this class are thred-safe.</para>
                  /// </remarks>
                  public abstract class ObjectPool<T> where T : class {
                      readonly AsyncQueue<WeakReference> m_queue = new AsyncQueue<WeakReference>();
                      readonly int m_size;
                      int m_count = 0;
                      protected ObjectPool() : this(Environment.ProcessorCount+1) {
                      }
                      protected ObjectPool(int size) {
                          Safe.ArgumentInRange(size,1,size,"size");
                          m_size = size;
                      }
+                     /// <summary>
+                     /// Creates the instance if there are no free ones in the pool.
+                     /// </summary>
+                     /// <returns>The new instance.</returns>
                      protected abstract T CreateInstance();
+                     /// <summary>
+                     /// Cleanups the instance.
+                     /// </summary>
+                     /// <param name="instance">The instance to cleanup and prepare it for the next use.</param>
                      protected virtual void CleanupInstance(T instance) {
                      }
+                     /// <summary>
+                     /// Allocate free instance from the pool or reates a new one.
+                     /// </summary>
                      public T Allocate() {
                          WeakReference reference;
                          while (m_queue.TryDequeue(out reference)) {
                              Interlocked.Decrement(ref m_count);
                              object instance = reference.Target;
                              if (instance == null)
                                  continue;
                              return (T)instance;
                          }
                          return CreateInstance();
                      }
+                     /// <summary>
+                     /// Release the specified instance and returns it to the pool of free instances.
+                     /// </summary>
+                     /// <param name="instance">The instance to return to the pool.</param>
+                     /// <remarks>Before the instance is returned to the pool the <see cref="CleanupInstance(T)"/> is called.</remarks>
                      public void Release(T instance) {
                          if (m_count < m_size && instance != null) {
                              Interlocked.Increment(ref m_count);
                              CleanupInstance(instance);
                              m_queue.Enqueue(new WeakReference(instance));
                          }
                      }
                  }
              }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages