--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Net/ConnectionList.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,133 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UCIS.Net {
+	public class NetworkConnectionList : ICollection<INetworkConnection> {
+		List<INetworkConnection> _list = new List<INetworkConnection>();
+
+		public ulong BytesWritten {
+			get {
+				ulong sum = 0;
+				lock (_list) foreach (INetworkConnection c in _list) sum += c.BytesWritten;
+				return sum;
+			}
+		}
+		public ulong BytesRead {
+			get {
+				ulong sum = 0;
+				lock (_list) foreach (INetworkConnection c in _list) sum += c.BytesRead;
+				return sum;
+			}
+		}
+		public NetworkConnectionList FindByHandler(Object Handler) {
+			NetworkConnectionList l = new NetworkConnectionList();
+			lock (_list) foreach (INetworkConnection c in _list) if (c.Handler == Handler) l.Add(c);
+			return l;
+		}
+		public NetworkConnectionList FindByHandlerType(Type HandlerType) {
+			NetworkConnectionList l = new NetworkConnectionList();
+			lock (_list) foreach (INetworkConnection c in _list) if (c.Handler.GetType() == HandlerType) l.Add(c);
+			return l;
+		}
+		public void CloseAll() {
+			foreach (INetworkConnection c in ToArray()) c.Close();
+		}
+
+		public void Add(INetworkConnection item) {
+			if (item == null) throw new ArgumentNullException("item");
+			lock (_list) _list.Add(item);
+			item.Closed += _ConnectionClosed;
+			if (!item.Connected) Remove(item);
+		}
+		public void Insert(int index, INetworkConnection item) {
+			throw new NotSupportedException();
+		}
+		public bool Remove(INetworkConnection item) {
+			if (item == null) throw new ArgumentNullException("item");
+			item.Closed -= _ConnectionClosed;
+			lock (_list) return _list.Remove(item);
+		}
+		public void RemoveAt(int index) {
+			lock (_list) {
+				INetworkConnection item = _list[index];
+				item.Closed -= _ConnectionClosed;
+				_list.Remove(item);
+			}
+		}
+		public int Count { get { lock (_list) return _list.Count; } }
+		public bool IsReadOnly { get { return false; } }
+		public bool Contains(INetworkConnection item) {
+			lock (_list) return _list.Contains(item);
+		}
+		public void Clear() {
+			lock (_list) {
+				foreach (INetworkConnection c in _list) c.Closed -= _ConnectionClosed;
+				_list.Clear();
+			}
+		}
+		public INetworkConnection this[int index] {
+			get { return _list[index]; }
+			set { throw new NotSupportedException(); }
+		}
+		public int IndexOf(INetworkConnection item) {
+			lock (_list) return _list.IndexOf(item);
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return new Enumerator(_list);
+		}
+		public IEnumerator<INetworkConnection> GetEnumerator() {
+			return new Enumerator(_list);
+		}
+
+		public void CopyTo(INetworkConnection[] array, int offset) {
+			lock (_list) _list.CopyTo(array, offset);
+		}
+
+		public INetworkConnection[] ToArray() {
+			lock (_list) return _list.ToArray();
+		}
+
+		private void _ConnectionClosed(Object sender, EventArgs e) {
+			if (sender == null || !(sender is INetworkConnection)) return;
+			Remove((INetworkConnection)sender);
+		}
+
+		private class Enumerator : IEnumerator<INetworkConnection> {
+			int index = 0;
+			INetworkConnection current = null;
+			IList<INetworkConnection> list;
+
+			public Enumerator(IList<INetworkConnection> list) {
+				this.list = list;
+			}
+
+			public void Reset() {
+				index = 0;
+			}
+			public bool MoveNext() {
+				lock (list) {
+					if (index < list.Count) {
+						current = list[index];
+						index++;
+						return true;
+					} else {
+						current = null;
+						return false;
+					}
+				}
+			}
+			public INetworkConnection Current {
+				get { return current; } 
+			}
+			object IEnumerator.Current {
+				get { return current; }
+			}
+			public void Dispose() {
+				current = null;
+				list = null;
+			}
+		}
+	}
+}