@@ -8,12 +8,17 namespace Implab.Components { | |||
|
8 | 8 | public static class App { |
|
9 | 9 | readonly static ComponentContainer<object> _root = new ComponentContainer<object>(); |
|
10 | 10 | |
|
11 | /// <summary> | |
|
12 | /// The container for application level components. | |
|
13 | /// </summary> | |
|
14 | /// <remarks>Pools of disposable objects can be placed here and they will be automatically | |
|
15 | /// disposed when application domain is unloaded.</remarks> | |
|
11 | 16 | public static ICollection<object> RootContainer { |
|
12 | 17 | get { return _root; } |
|
13 | 18 | } |
|
14 | 19 | |
|
15 | 20 | static App() { |
|
16 |
AppDomain.CurrentDomain. |
|
|
21 | AppDomain.CurrentDomain.DomainUnload += (sender, e) => _root.Dispose(); | |
|
17 | 22 | } |
|
18 | 23 | } |
|
19 | 24 | } |
@@ -4,12 +4,18 using System.Linq; | |||
|
4 | 4 | |
|
5 | 5 | namespace Implab.Components { |
|
6 | 6 | /// <summary> |
|
7 | /// Component container. | |
|
7 | /// Component container, used to store track components in multi-threaded environmment. | |
|
8 | 8 | /// </summary> |
|
9 | 9 | /// <remarks>Instanses of this class are thread safe.</remarks> |
|
10 | 10 | public class ComponentContainer<T> : Disposable, ICollection<T> { |
|
11 | 11 | readonly HashSet<T> m_components = new HashSet<T>(); |
|
12 | 12 | |
|
13 | /// <summary> | |
|
14 | /// Removes currently stored compoenents from the container and disposes them if possible. | |
|
15 | /// </summary> | |
|
16 | /// <remarks> | |
|
17 | /// A new components may be added before this method completes. | |
|
18 | /// </remarks> | |
|
13 | 19 | public void Clear() { |
|
14 | 20 | T[] removed; |
|
15 | 21 | |
@@ -23,21 +29,37 namespace Implab.Components { | |||
|
23 | 29 | item.Dispose(); |
|
24 | 30 | } |
|
25 | 31 | |
|
32 | /// <summary> | |
|
33 | /// Checks whether the specified item in the collection. | |
|
34 | /// </summary> | |
|
35 | /// <param name="item">The item to check.</param> | |
|
26 | 36 | public bool Contains(T item) { |
|
27 | 37 | lock (m_components) |
|
28 | 38 | return m_components.Contains(item); |
|
29 | 39 | } |
|
30 | 40 | |
|
41 | /// <summary> | |
|
42 | /// Copies currently stored components to the specified array. | |
|
43 | /// </summary> | |
|
44 | /// <param name="array">A destination array for components.</param> | |
|
45 | /// <param name="arrayIndex">A starting index in the destination array.</param> | |
|
31 | 46 | public void CopyTo(T[] array, int arrayIndex) { |
|
32 | 47 | lock (m_components) |
|
33 | 48 | m_components.CopyTo(array, arrayIndex); |
|
34 | 49 | } |
|
35 | 50 | |
|
51 | /// <summary> | |
|
52 | /// Remove the specified item from the collection. | |
|
53 | /// </summary> | |
|
54 | /// <param name="item">The item to remove.</param> | |
|
36 | 55 | public bool Remove(T item) { |
|
37 | 56 | lock (m_components) |
|
38 | 57 | return m_components.Remove(item); |
|
39 | 58 | } |
|
40 | 59 | |
|
60 | /// <summary> | |
|
61 | /// Gets the count of components in the collection. | |
|
62 | /// </summary> | |
|
41 | 63 | public int Count { |
|
42 | 64 | get { |
|
43 | 65 | lock (m_components) |
@@ -45,12 +67,22 namespace Implab.Components { | |||
|
45 | 67 | } |
|
46 | 68 | } |
|
47 | 69 | |
|
70 | /// <summary> | |
|
71 | /// Gets a value indicating whether this instance is read only. | |
|
72 | /// </summary> | |
|
73 | /// <remarks> | |
|
74 | /// Always false. | |
|
75 | /// </remarks> | |
|
48 | 76 | public bool IsReadOnly { |
|
49 | 77 | get { |
|
50 | 78 | return false; |
|
51 | 79 | } |
|
52 | 80 | } |
|
53 | 81 | |
|
82 | /// <summary> | |
|
83 | /// Gets the enumerator for components in the collection. | |
|
84 | /// </summary> | |
|
85 | /// <returns>The enumerator.</returns> | |
|
54 | 86 | public IEnumerator<T> GetEnumerator() { |
|
55 | 87 | T[] items; |
|
56 | 88 | lock (m_components) { |
@@ -64,6 +96,13 namespace Implab.Components { | |||
|
64 | 96 | return GetEnumerator(); |
|
65 | 97 | } |
|
66 | 98 | |
|
99 | /// <summary> | |
|
100 | /// Add the specified item to the collection. | |
|
101 | /// </summary> | |
|
102 | /// <param name="item">The item to add.</param> | |
|
103 | /// <remarks> | |
|
104 | /// If the collection is alredy disposed, the item isn't added to the collection and disposed if possible. | |
|
105 | /// </remarks> | |
|
67 | 106 | public void Add(T item) { |
|
68 | 107 | Safe.ArgumentNotNull(item, "item"); |
|
69 | 108 | |
@@ -75,6 +114,10 namespace Implab.Components { | |||
|
75 | 114 | } |
|
76 | 115 | } |
|
77 | 116 | |
|
117 | /// <summary> | |
|
118 | /// Disposes the components stored in the collection. | |
|
119 | /// </summary> | |
|
120 | /// <param name="disposing">If set to <c>true</c> the collection is disposing.</param> | |
|
78 | 121 | protected override void Dispose(bool disposing) { |
|
79 | 122 | base.Dispose(disposing); |
|
80 | 123 | Clear(); |
@@ -4,7 +4,16 using System.Threading; | |||
|
4 | 4 | using System.Diagnostics; |
|
5 | 5 | using System.Diagnostics.CodeAnalysis; |
|
6 | 6 | |
|
7 | namespace Implab { | |
|
7 | namespace Implab.Components { | |
|
8 | /// <summary> | |
|
9 | /// The base class for implementing pools of disposable objects. | |
|
10 | /// </summary> | |
|
11 | /// <remarks> | |
|
12 | /// <para>This class maintains a set of pre-created objects and which are frequently allocated and released | |
|
13 | /// by clients. The pool maintains maximum number of unsued object, any object above this limit is disposed, | |
|
14 | /// if the pool is empty it will create new objects on demand.</para> | |
|
15 | /// <para>Instances of this class are thread-safe.</para> | |
|
16 | /// </remarks> | |
|
8 | 17 | public abstract class DisposablePool<T> : IDisposable { |
|
9 | 18 | readonly int m_size; |
|
10 | 19 | readonly AsyncQueue<T> m_queue = new AsyncQueue<T>(); |
@@ -62,8 +71,9 namespace Implab { | |||
|
62 | 71 | ((IDisposable)instance).Dispose() ; |
|
63 | 72 | |
|
64 | 73 | } else { |
|
65 |
|
|
|
66 |
|
|
|
74 | var disposable = instance as IDisposable; | |
|
75 | if (disposable != null) | |
|
76 | disposable.Dispose(); | |
|
67 | 77 | } |
|
68 | 78 | } |
|
69 | 79 | |
@@ -71,9 +81,11 namespace Implab { | |||
|
71 | 81 | if (disposing) { |
|
72 | 82 | m_disposed = true; |
|
73 | 83 | T instance; |
|
74 | while (m_queue.TryDequeue(out instance)) | |
|
75 |
|
|
|
76 |
|
|
|
84 | while (m_queue.TryDequeue(out instance)) { | |
|
85 | var disposable = instance as IDisposable; | |
|
86 | if (disposable != null) | |
|
87 | disposable.Dispose(); | |
|
88 | } | |
|
77 | 89 | } |
|
78 | 90 | } |
|
79 | 91 |
General Comments 0
You need to be logged in to leave comments.
Login now