wasSharp – Diff between revs 40 and 44

Subversion Repositories:
Rev:
Only display areas with differences – Ignore whitespace
Rev 40 Rev 44
1 /////////////////////////////////////////////////////////////////////////// 1 ///////////////////////////////////////////////////////////////////////////
2 // Copyright (C) Wizardry and Steamworks 2017 - License: GNU GPLv3 // 2 // Copyright (C) Wizardry and Steamworks 2017 - License: GNU GPLv3 //
3 // Please see: http://www.gnu.org/licenses/gpl.html for legal details, // 3 // Please see: http://www.gnu.org/licenses/gpl.html for legal details, //
4 // rights of fair usage, the disclaimer and warranty conditions. // 4 // rights of fair usage, the disclaimer and warranty conditions. //
5 /////////////////////////////////////////////////////////////////////////// 5 ///////////////////////////////////////////////////////////////////////////
6   6  
7 using System.Collections; 7 using System.Collections;
8 using System.Collections.Generic; 8 using System.Collections.Generic;
9 using System.Threading; 9 using System.Threading;
10   10  
11 namespace wasSharp.Collections.Specialized 11 namespace wasSharp.Collections.Specialized
12 { 12 {
13 public static class ConcurrentListExtensions 13 public static class ConcurrentListExtensions
14 { 14 {
15 public static ConcurrentList<T> ToConcurrentList<T>(this IEnumerable<T> enumerable) 15 public static ConcurrentList<T> ToConcurrentList<T>(this IEnumerable<T> enumerable)
16 { 16 {
17 return new ConcurrentList<T>(enumerable); 17 return new ConcurrentList<T>(enumerable);
18 } 18 }
19 } 19 }
20   20  
21 public class ConcurrentList<T> : IList<T> 21 public class ConcurrentList<T> : IList<T>
22 { 22 {
23 private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion); 23 private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
24 private readonly List<T> _list = null; 24 private readonly List<T> _list;
25   25  
26 public ConcurrentList(IEnumerable<T> v) 26 public ConcurrentList(IEnumerable<T> v)
27 { 27 {
-   28 _lock.EnterWriteLock();
28 try 29 try
29 { 30 {
30 _lock.EnterWriteLock(); -  
31 _list = new List<T>(); 31 _list = new List<T>();
32 foreach (var i in v) 32 foreach (var i in v)
33 { 33 {
34 _list.Add(i); 34 _list.Add(i);
35 } 35 }
36 } 36 }
37 finally 37 finally
38 { 38 {
39 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 39 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
40 } 40 }
41 } 41 }
42   42  
43 public ConcurrentList() 43 public ConcurrentList()
44 { 44 {
-   45 _lock.EnterWriteLock();
45 try 46 try
46 { 47 {
47 _lock.EnterWriteLock(); -  
48 _list = new List<T>(); 48 _list = new List<T>();
49 } 49 }
50 finally 50 finally
51 { 51 {
52 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 52 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
53 } 53 }
54 } 54 }
55   55  
56 public int Count 56 public int Count
57 { 57 {
58 get 58 get
59 { 59 {
60 _lock.EnterReadLock(); 60 _lock.EnterReadLock();
-   61 try
-   62 {
61 var c = _list.Count; 63 return _list.Count;
-   64 }
-   65 finally
-   66 {
62 _lock.ExitReadLock(); 67 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
63 return c; 68 }
-   69
64 } 70 }
65 } 71 }
66   72  
67 public bool IsReadOnly 73 public bool IsReadOnly
68 { 74 {
69 get 75 get
70 { 76 {
-   77 _lock.EnterReadLock();
71 try 78 try
72 { 79 {
73 _lock.EnterReadLock(); -  
74 return ((IList<T>)_list).IsReadOnly; 80 return ((IList<T>)_list).IsReadOnly;
75 } 81 }
76 finally 82 finally
77 { 83 {
78 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 84 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
79 } 85 }
80 } 86 }
81 } 87 }
82   88  
83 public T this[int index] 89 public T this[int index]
84 { 90 {
85 get 91 get
86 { 92 {
-   93 _lock.EnterReadLock();
87 try 94 try
88 { 95 {
89 _lock.EnterReadLock(); -  
90 return _list[index]; 96 return _list[index];
91 } 97 }
92 finally 98 finally
93 { 99 {
94 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 100 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
95 } 101 }
96 } 102 }
97   103  
98 set 104 set
99 { 105 {
-   106 _lock.EnterWriteLock();
100 try 107 try
101 { 108 {
102 _lock.EnterWriteLock(); -  
103 _list[index] = value; 109 _list[index] = value;
104 } 110 }
105 finally 111 finally
106 { 112 {
107 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 113 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
108 } 114 }
109 } 115 }
110 } 116 }
111   117  
112 public int IndexOf(T item) 118 public int IndexOf(T item)
113 { 119 {
-   120 _lock.EnterReadLock();
114 try 121 try
115 { 122 {
116 _lock.EnterReadLock(); -  
117 return _list.IndexOf(item); 123 return _list.IndexOf(item);
118 } 124 }
119 finally 125 finally
120 { 126 {
121 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 127 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
122 } 128 }
123 } 129 }
124   130  
125 public void Insert(int index, T item) 131 public void Insert(int index, T item)
126 { 132 {
-   133 _lock.EnterWriteLock();
127 try 134 try
128 { 135 {
129 _lock.EnterWriteLock(); -  
130 _list.Insert(index, item); 136 _list.Insert(index, item);
131 } 137 }
132 finally 138 finally
133 { 139 {
134 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 140 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
135 } 141 }
136 } 142 }
137   143  
138 public void RemoveAt(int index) 144 public void RemoveAt(int index)
139 { 145 {
-   146 _lock.EnterWriteLock();
140 try 147 try
141 { 148 {
142 _lock.EnterWriteLock(); -  
143 _list.RemoveAt(index); 149 _list.RemoveAt(index);
144 } 150 }
145 finally 151 finally
146 { 152 {
147 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 153 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
148 } 154 }
149 } 155 }
150   156  
151 public void Add(T item) 157 public void Add(T item)
152 { 158 {
-   159 _lock.EnterWriteLock();
153 try 160 try
154 { 161 {
155 _lock.EnterWriteLock(); -  
156 _list.Add(item); 162 _list.Add(item);
157 } 163 }
158 finally 164 finally
159 { 165 {
160 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 166 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
161 } 167 }
162 } 168 }
163   169  
164 public void Clear() 170 public void Clear()
165 { 171 {
-   172 _lock.EnterWriteLock();
166 try 173 try
167 { 174 {
168 _lock.EnterWriteLock(); -  
169 _list.Clear(); 175 _list.Clear();
170 } 176 }
171 finally 177 finally
172 { 178 {
173 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 179 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
174 } 180 }
175 } 181 }
176   182  
177 public bool Contains(T item) 183 public bool Contains(T item)
178 { 184 {
-   185 _lock.EnterReadLock();
179 try 186 try
180 { 187 {
181 _lock.EnterReadLock(); -  
182 return _list.Contains(item); 188 return _list.Contains(item);
183 } 189 }
184 finally 190 finally
185 { 191 {
186 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 192 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
187 } 193 }
188 } 194 }
189   195  
190 public void CopyTo(T[] array, int arrayIndex) 196 public void CopyTo(T[] array, int arrayIndex)
191 { 197 {
-   198 _lock.EnterReadLock();
192 try 199 try
193 { 200 {
194 _lock.EnterReadLock(); -  
195 _list.CopyTo(array, arrayIndex); 201 _list.CopyTo(array, arrayIndex);
196 } 202 }
197 finally 203 finally
198 { 204 {
199 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 205 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
200 } 206 }
201 } 207 }
202   208  
203 public bool Remove(T item) 209 public bool Remove(T item)
204 { 210 {
-   211 _lock.EnterWriteLock();
205 try 212 try
206 { 213 {
207 _lock.EnterWriteLock(); -  
208 return _list.Remove(item); 214 return _list.Remove(item);
209 } 215 }
210 finally 216 finally
211 { 217 {
212 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 218 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
213 } 219 }
214 } 220 }
215   221  
216 public IEnumerator<T> GetEnumerator() 222 public IEnumerator<T> GetEnumerator()
217 { 223 {
-   224 _lock.EnterReadLock();
218 try 225 try
219 { 226 {
-   227 using (var enumerator = _list.GetEnumerator())
-   228 {
220 _lock.EnterReadLock(); 229 while (enumerator.MoveNext())
221 return ((IList<T>)_list).GetEnumerator(); 230 yield return enumerator.Current;
-   231 }
222 } 232 }
223 finally 233 finally
224 { 234 {
225 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 235 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
226 } 236 }
227 } 237 }
228   238  
229 IEnumerator IEnumerable.GetEnumerator() 239 IEnumerator IEnumerable.GetEnumerator()
230 { 240 {
-   241 _lock.EnterReadLock();
231 try 242 try
232 { 243 {
-   244 using (var enumerator = _list.GetEnumerator())
-   245 {
233 _lock.EnterReadLock(); 246 while (enumerator.MoveNext())
234 return ((IList<T>)_list).GetEnumerator(); 247 yield return enumerator.Current;
-   248 }
235 } 249 }
236 finally 250 finally
237 { 251 {
238 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 252 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
239 } 253 }
240 } 254 }
241 } 255 }
242 } 256 }
243   257