Updated to 2.7.0

Author: Oren (electricessence)

source/Open.Collections.csproj

@@ -15,9 +15,9 @@ Part of the "Open" set of libraries.</Description>
     <PackageProjectUrl>https://github.com/electricessence/Open.Collections/</PackageProjectUrl>
     <RepositoryUrl>https://github.com/electricessence/Open.Collections/</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <Version>2.6.2</Version>
-    <AssemblyVersion>2.6.2.0</AssemblyVersion>
-    <FileVersion>2.6.2.0</FileVersion>
+    <Version>2.7.0</Version>
+    <AssemblyVersion>2.7.0.0</AssemblyVersion>
+    <FileVersion>2.7.0.0</FileVersion>
     <PackageReleaseNotes></PackageReleaseNotes>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>

source/Synchronized/LockSynchronizedList.cs

@@ -3,42 +3,9 @@
 
 namespace Open.Collections.Synchronized
 {
-	public sealed class LockSynchronizedList<T> : LockSynchronizedCollectionWrapper<T, List<T>>, IList<T>
+	public sealed class LockSynchronizedList<T> : LockSynchronizedListWrapper<T>
 	{
-
 		public LockSynchronizedList() : base(new List<T>()) { }
 		public LockSynchronizedList(IEnumerable<T> collection) : base(new List<T>(collection)) { }
-
-		// This is a simplified version.
-		// It could be possible to allow indexed values to change independently of one another.
-		// If that fine grained of read-write control is necessary, then use the ThreadSafety utility and extensions.
-
-		/// <inheritdoc />
-		public T this[int index]
-		{
-			// ReSharper disable once InconsistentlySynchronizedField
-			get => InternalSource[index];
-			// ReSharper disable once InconsistentlySynchronizedField
-			set => InternalSource[index] = value;
-		}
-
-		/// <inheritdoc />
-		public int IndexOf(T item)
-		{
-			lock (Sync) return InternalSource.IndexOf(item);
-		}
-
-		/// <inheritdoc />
-		public void Insert(int index, T item)
-		{
-			lock (Sync) InternalSource.Insert(index, item);
-		}
-
-		/// <inheritdoc />
-		public void RemoveAt(int index)
-		{
-			lock (Sync) InternalSource.RemoveAt(index);
-		}
-
 	}
 }

source/Synchronized/LockSynchronizedListWrapper.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+
+namespace Open.Collections.Synchronized
+{
+	public class LockSynchronizedListWrapper<T> : LockSynchronizedCollectionWrapper<T, IList<T>>, IList<T>
+	{
+
+		public LockSynchronizedListWrapper(IList<T> list) : base(list) { }
+
+		// This is a simplified version.
+		// It could be possible to allow indexed values to change independently of one another.
+		// If that fine grained of read-write control is necessary, then use the ThreadSafety utility and extensions.
+
+		/// <inheritdoc />
+		public T this[int index]
+		{
+			// ReSharper disable once InconsistentlySynchronizedField
+			get => InternalSource[index];
+			// ReSharper disable once InconsistentlySynchronizedField
+			set => InternalSource[index] = value;
+		}
+
+		/// <inheritdoc />
+		public int IndexOf(T item)
+		{
+			lock (Sync) return InternalSource.IndexOf(item);
+		}
+
+		/// <inheritdoc />
+		public void Insert(int index, T item)
+		{
+			lock (Sync) InternalSource.Insert(index, item);
+		}
+
+		/// <inheritdoc />
+		public void RemoveAt(int index)
+		{
+			lock (Sync) InternalSource.RemoveAt(index);
+		}
+
+	}
+}

source/Synchronized/ReadWriteSynchronizedList.cs

@@ -1,36 +1,10 @@
-using Open.Threading;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 namespace Open.Collections.Synchronized
 {
-	public sealed class ReadWriteSynchronizedList<T> : ReadWriteSynchronizedCollectionWrapper<T, List<T>>, IList<T>
+	public sealed class ReadWriteSynchronizedList<T> : ReadWriteSynchronizedListWrapper<T>
 	{
-
 		public ReadWriteSynchronizedList() : base(new List<T>()) { }
 		public ReadWriteSynchronizedList(IEnumerable<T> collection) : base(new List<T>(collection)) { }
-
-		// This is a simplified version.
-		// It could be possible to allow indexed values to change independently of one another.
-		// If that fine grained of read-write control is necessary, then use the ThreadSafety utility and extensions.
-
-		/// <inheritdoc />
-		public T this[int index]
-		{
-			get => InternalSource[index];
-			set => InternalSource[index] = value;
-		}
-
-		/// <inheritdoc />
-		public int IndexOf(T item)
-			=> Sync.ReadValue(() => InternalSource.IndexOf(item));
-
-		/// <inheritdoc />
-		public void Insert(int index, T item)
-			=> Sync.Write(() => InternalSource.Insert(index, item));
-
-		/// <inheritdoc />
-		public void RemoveAt(int index)
-			=> Sync.Write(() => InternalSource.RemoveAt(index));
-
 	}
 }

source/Synchronized/ReadWriteSynchronizedListWrapper.cs

@@ -0,0 +1,34 @@
+using Open.Threading;
+using System.Collections.Generic;
+
+namespace Open.Collections.Synchronized
+{
+	public class ReadWriteSynchronizedListWrapper<T> : ReadWriteSynchronizedCollectionWrapper<T, IList<T>>, IList<T>
+	{
+		public ReadWriteSynchronizedListWrapper(IList<T> list) : base(list) { }
+
+		// This is a simplified version.
+		// It could be possible to allow indexed values to change independently of one another.
+		// If that fine grained of read-write control is necessary, then use the ThreadSafety utility and extensions.
+
+		/// <inheritdoc />
+		public T this[int index]
+		{
+			get => InternalSource[index];
+			set => InternalSource[index] = value;
+		}
+
+		/// <inheritdoc />
+		public int IndexOf(T item)
+			=> Sync.ReadValue(() => InternalSource.IndexOf(item));
+
+		/// <inheritdoc />
+		public void Insert(int index, T item)
+			=> Sync.Write(() => InternalSource.Insert(index, item));
+
+		/// <inheritdoc />
+		public void RemoveAt(int index)
+			=> Sync.Write(() => InternalSource.RemoveAt(index));
+
+	}
+}