RecyclableCollectionsBenchmarks split into multiple files.

Recyclable.Collections.Benchmarks/Benchmarks/Add.cs

@@ -0,0 +1,56 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_Add()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			var list = new List<object>();
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Add()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new PooledList<object>(ClearMode.Always);
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Add()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new RecyclableArrayList<object>();
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Add()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new RecyclableList<object>();
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/AddRangeWhenSourceIsArray.cs

@@ -0,0 +1,40 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_AddRangeWhenSourceIsArray()
+		{
+			var data = TestObjects;
+			var list = new List<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_AddRangeWhenSourceIsArray()
+		{
+			var data = TestObjects;
+			using var list = new PooledList<object>(capacity: checked((int)TestObjectCount), ClearMode.Always);
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_AddRangeWhenSourceIsArray()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableArrayList<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_AddRangeWhenSourceIsArray()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			list.AddRange(data);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/AddRangeWhenSourceIsIEnumerable.cs

@@ -0,0 +1,40 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_AddRangeWhenSourceIsIEnumerable()
+		{
+			var data = TestObjectsAsIEnumerable;
+			var list = new List<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_AddRangeWhenSourceIsIEnumerable()
+		{
+			var data = TestObjectsAsIEnumerable;
+			using var list = new PooledList<object>(capacity: checked((int)TestObjectCount), ClearMode.Always);
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_AddRangeWhenSourceIsIEnumerable()
+		{
+			var data = TestObjectsAsIEnumerable;
+			using var list = new RecyclableArrayList<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_AddRangeWhenSourceIsIEnumerable()
+		{
+			var data = TestObjectsAsIEnumerable;
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			list.AddRange(data);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/AddRangeWhenSourceIsIList.cs

@@ -0,0 +1,40 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_AddRangeWhenSourceIsIList()
+		{
+			var data = (IList<object>)TestObjectsAsRecyclableList;
+			var list = new List<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_AddRangeWhenSourceIsIList()
+		{
+			var data = (IList<object>)TestObjectsAsPooledList;
+			using var list = new PooledList<object>(capacity: checked((int)TestObjectCount), ClearMode.Always);
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_AddRangeWhenSourceIsIList()
+		{
+			var data = (IList<object>)TestObjectsAsRecyclableList;
+			using var list = new RecyclableArrayList<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_AddRangeWhenSourceIsIList()
+		{
+			var data = (IList<object>)TestObjectsAsRecyclableList;
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			list.AddRange(data);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/AddRangeWhenSourceIsList.cs

@@ -0,0 +1,40 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_AddRangeWhenSourceIsList()
+		{
+			var data = TestObjectsAsList;
+			var list = new List<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_AddRangeWhenSourceIsList()
+		{
+			var data = TestObjectsAsList;
+			using var list = new PooledList<object>(capacity: checked((int)TestObjectCount), ClearMode.Always);
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_AddRangeWhenSourceIsList()
+		{
+			var data = TestObjectsAsList;
+			using var list = new RecyclableArrayList<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_AddRangeWhenSourceIsList()
+		{
+			var data = TestObjectsAsList;
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			list.AddRange(data);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/AddRangeWhenSourceIsSameType.cs

@@ -0,0 +1,32 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = true)]
+		public void PooledList_AddRangeWhenSourceIsPooledList()
+		{
+			var data = TestObjectsAsPooledList;
+			using var list = new PooledList<object>(capacity: checked((int)TestObjectCount), ClearMode.Always);
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_AddRangeWhenSourceIsRecyclableArrayList()
+		{
+			var data = TestObjectsAsRecyclableArrayList;
+			using var list = new RecyclableArrayList<object>();
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_AddRangeWhenSourceIsRecyclableArrayList()
+		{
+			var data = TestObjectsAsRecyclableArrayList;
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			list.AddRange(data);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/AddRange_WithCapacity.cs

@@ -0,0 +1,44 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_AddRange_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			var list = new List<object>(checked((int)dataCount));
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_AddRange_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new PooledList<object>(capacity: checked((int)TestObjectCount), ClearMode.Always);
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_AddRange_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new RecyclableArrayList<object>(checked((int)dataCount));
+			list.AddRange(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_AddRange_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			list.AddRange(data);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Add_WithCapacity.cs

@@ -0,0 +1,56 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_Add_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			var list = new List<object>(checked((int)dataCount));
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Add_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new PooledList<object>(capacity: checked((int)dataCount), ClearMode.Always);
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Add_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new RecyclableArrayList<object>(checked((int)dataCount));
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Add_WithCapacity()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: dataCount);
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.Add(data[i]);
+			}
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Contains_FirstItems.cs

@@ -0,0 +1,67 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_Contains_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjects;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(Array.IndexOf(list, data[i]) >= 0);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void List_Contains_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Contains_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsPooledList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Contains_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableArrayList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Contains_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[i]));
+			}
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Contains_LastItems.cs

@@ -0,0 +1,68 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_Contains_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjects;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void List_Contains_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Contains_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsPooledList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Contains_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableArrayList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Contains_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Contains(data[^(i + 1)]));
+			}
+		}
+
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Count.cs

@@ -0,0 +1,43 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_Count()
+		{
+			var data = _testArray;
+			DoNothing(data.Length);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void List_Count()
+		{
+			var data = TestObjectsAsList;
+			DoNothing(data.Count);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Count()
+		{
+			var data = _testPooledList;
+			DoNothing(data.Count);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Count()
+		{
+			var data = TestObjectsAsRecyclableArrayList;
+			DoNothing(data.Count);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Count()
+		{
+			var data = _testRecyclableList;
+			DoNothing(data.Count);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Create.cs

@@ -0,0 +1,36 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_Create()
+		{
+			var list = new List<object>();
+			DoNothing(list);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Create()
+		{
+			using var list = new PooledList<object>(ClearMode.Always);
+			DoNothing(list);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Create()
+		{
+			using var list = new RecyclableArrayList<object>();
+			DoNothing(list);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Create()
+		{
+			using var list = new RecyclableList<object>();
+			DoNothing(list);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Create_WithCapacity.cs

@@ -0,0 +1,43 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_Create_WithCapacity()
+		{
+			var data = new object[TestObjectCount];
+			DoNothing(data);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void List_Create_WithCapacity()
+		{
+			var list = new List<object>(checked((int)TestObjectCount));
+			DoNothing(list);
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Create_WithCapacity()
+		{
+			using var list = new PooledList<object>(capacity: checked((int)TestObjectCount), ClearMode.Always);
+			DoNothing(list);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Create_WithCapacity()
+		{
+			using var list = new RecyclableArrayList<object>(checked((int)TestObjectCount));
+			DoNothing(list);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Create_WithCapacity()
+		{
+			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			DoNothing(list);
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/GetItem..cs

@@ -0,0 +1,174 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		[Benchmark(Baseline = false)]
+		public void Array_GetItem()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(data[i]);
+			}
+		}
+
+		[Benchmark(Baseline = false)]
+		public void List_GetItem()
+		{
+			var data = TestObjectsAsList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(data[i]);
+			}
+		}
+
+		[Benchmark(Baseline = true)]
+		public void PooledList_GetItem()
+		{
+			var data = _testPooledList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(data[i]);
+			}
+		}
+
+		[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_GetItem()
+		{
+			var data = TestObjectsAsRecyclableArrayList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(data[i]);
+			}
+		}
+
+		[Benchmark(Baseline = false)]
+		public void RecyclableList_GetItem()
+		{
+			var data = _testRecyclableList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(data[i]);
+			}
+		}
+
+		[Benchmark(Baseline = false)]
+		public void RecyclableList_GetItem_AsSpan()
+		{
+			var data = _testRecyclableList;
+			var dataCount = TestObjectCount;
+			int blockSize = data.BlockSize;
+			int nextItemBlockIndex = data.NextItemBlockIndex;
+
+			var memoryBlocks = new Span<object[]>(data.MemoryBlocks, 0, data.LastBlockWithData + 1);
+			for (var blockIndex = 0; blockIndex < nextItemBlockIndex; blockIndex++)
+			{
+				var memoryBlock = new Span<object>(memoryBlocks[blockIndex], 0, blockSize);
+				for (var itemIndex = 0; itemIndex < blockSize; itemIndex++)
+				{
+					DoNothing(memoryBlock[itemIndex]);
+				}
+			}
+
+			if (nextItemBlockIndex == data.LastBlockWithData)
+			{
+
+				var memoryBlock = new Span<object>(memoryBlocks[nextItemBlockIndex], 0, data.NextItemIndex);
+				for (var itemIndex = 0; itemIndex < memoryBlock.Length; itemIndex++)
+				{
+					DoNothing(memoryBlock[itemIndex]);
+				}
+			}
+		}
+
+		[Benchmark(Baseline = false)]
+		public void RecyclableList_GetItem_AsArray()
+		{
+			var data = _testRecyclableList;
+			var dataCount = TestObjectCount;
+			int blockSize = data.BlockSize;
+			int nextItemBlockIndex = data.NextItemBlockIndex;
+
+			var memoryBlocks = data.MemoryBlocks;
+			for (var blockIndex = 0; blockIndex < nextItemBlockIndex; blockIndex++)
+			{
+				var memoryBlock = memoryBlocks[blockIndex];
+				for (var itemIndex = 0; itemIndex < blockSize; itemIndex++)
+				{
+					DoNothing(memoryBlock[itemIndex]);
+				}
+			}
+
+			if (nextItemBlockIndex == data.LastBlockWithData)
+			{
+				var memoryBlock = memoryBlocks[nextItemBlockIndex];
+				blockSize = data.NextItemIndex;
+				for (var itemIndex = 0; itemIndex < blockSize; itemIndex++)
+				{
+					DoNothing(memoryBlock[itemIndex]);
+				}
+			}
+		}
+
+		[Benchmark(Baseline = false)]
+		public void RecyclableList_GetItem_AsForEach()
+		{
+			var data = _testRecyclableList;
+			var dataCount = TestObjectCount;
+
+			foreach (var item in data)
+			{
+				DoNothing(item);
+			}
+		}
+
+		[Benchmark(Baseline = false)]
+		public void RecyclableList_GetItem_AsWhile()
+		{
+			var data = _testRecyclableList;
+			long dataCount = TestObjectCount;
+			if (dataCount == 0)
+			{
+				return;
+			}
+
+			int blockSize = data.BlockSize;
+			int nextItemBlockIndex = data.NextItemBlockIndex;
+			int itemIndex = 0;
+			int blockIndex = 0;
+			var memoryBlocks = data.MemoryBlocks;
+			var memoryBlock = memoryBlocks[0];
+			while (blockIndex < nextItemBlockIndex)
+			{
+				DoNothing(memoryBlock[itemIndex]);
+				if (itemIndex + 1 < blockSize)
+				{
+					itemIndex++;
+				}
+				else
+				{
+					blockIndex++;
+					memoryBlock = memoryBlocks[blockIndex];
+					itemIndex = 0;
+				}
+			}
+
+			if (nextItemBlockIndex == data.LastBlockWithData)
+			{
+				memoryBlock = memoryBlocks[nextItemBlockIndex];
+				blockSize = data.NextItemIndex;
+				while (itemIndex < blockSize)
+				{
+					DoNothing(memoryBlock[itemIndex++]);
+				}
+			}
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/IndexOf_FirstItems.cs

@@ -0,0 +1,80 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_IndexOf_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjects;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(Array.IndexOf(list, data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void List_IndexOf_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_IndexOf_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsPooledList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_IndexOf_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableArrayList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_IndexOf_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_LongIndexOf_FirstItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.LongIndexOf(data[i]));
+			}
+		}
+
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/IndexOf_LastItems.cs

@@ -0,0 +1,80 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_IndexOf_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjects;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(Array.IndexOf(list, data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void List_IndexOf_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_IndexOf_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsPooledList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_IndexOf_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableArrayList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_IndexOf_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.IndexOf(data[^(i + 1)]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_LongIndexOf_LastItems()
+		{
+			var data = TestObjects;
+			var list = TestObjectsAsRecyclableList;
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.LongIndexOf(data[^(i + 1)]));
+			}
+		}
+
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/LongCount.cs

@@ -0,0 +1,22 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_LongCount()
+		{
+			var data = _testArray;
+			DoNothing(data.LongLength);
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_LongCount()
+		{
+			var data = _testRecyclableList;
+			DoNothing(data.LongCount);
+		}
+
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/RecyclableCollections.Benchmarks.cs

@@ -0,0 +1,52 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	[MemoryDiagnoser]
+	public partial class RecyclableCollectionsBenchmarks : BenchmarkBase
+	{
+		private object[] _testArray;
+		private RecyclableArrayList<object> _testRecyclableArrayList;
+		private RecyclableList<object> _testRecyclableList;
+		private PooledList<object> _testPooledList;
+
+		public PooledList<object> TestObjectsAsPooledList => _testPooledList ?? throw new NullReferenceException("Something is wrong and the field is not initialized");
+
+		[GlobalSetup]
+		public void Setup()
+		{
+			Console.WriteLine("******* GLOBAL SETUP RAISED *******");
+			_testObjects = EnumerateTestObjects().ToArray();
+			_testRecyclableArrayList = new(TestObjects, initialCapacity: checked((int)TestObjectCount));
+			_testRecyclableList = new(TestObjects, BlockSize, expectedItemsCount: checked((int)TestObjectCount));
+			_testArray = TestObjects.ToArray();
+			_testObjectsAsList = TestObjects.ToList();
+			_testObjectsAsRecyclableArrayList = TestObjects.ToRecyclableArrayList();
+			_testObjectsAsRecyclableList = TestObjects.ToRecyclableList();
+			_testPooledList = new PooledList<object>(TestObjects, ClearMode.Always);
+		}
+
+		private IEnumerable<object> EnumerateTestObjects()
+		{
+			for (long i = 0; i < TestObjectCount; i++)
+			{
+				yield return new object();
+			}
+		}
+
+		[GlobalCleanup]
+		public void Cleanup()
+		{
+			Console.WriteLine("******* GLOBAL CLEANUP *******");
+			_testRecyclableArrayList?.Dispose();
+			_testRecyclableList?.Dispose();
+			_testPooledList?.Dispose();
+			TestObjectsAsRecyclableArrayList?.Dispose();
+			_testObjectsAsRecyclableArrayList = default;
+			_testObjectsAsRecyclableList = default;
+			_testObjectsAsList = default;
+			_testObjects = default;
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/RemoveAt_FirstItems.cs

@@ -0,0 +1,56 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_RemoveAt_FirstItems()
+		{
+			var data = TestObjects;
+			var list = new List<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.RemoveAt(i);
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_RemoveAt_FirstItems()
+		{
+			var data = TestObjects;
+			using var list = new PooledList<object>(data, ClearMode.Always);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.RemoveAt(i);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_RemoveAt_FirstItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableArrayList<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.RemoveAt(i);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_RemoveAt_FirstItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableList<object>(data, minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				list.RemoveAt(i);
+			}
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/RemoveAt_LastItems.cs

@@ -0,0 +1,56 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_RemoveAt_LastItems()
+		{
+			var data = TestObjects;
+			var list = new List<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				list.RemoveAt(i);
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_RemoveAt_LastItems()
+		{
+			var data = TestObjects;
+			using var list = new PooledList<object>(data, ClearMode.Always);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				list.RemoveAt(i);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_RemoveAt_LastItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableArrayList<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				list.RemoveAt(i);
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_RemoveAt_LastItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableList<object>(data, minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				list.RemoveAt(i);
+			}
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Remove_FirstItems.cs

@@ -0,0 +1,57 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_Remove_FirstItems()
+		{
+			var data = TestObjects;
+			var list = new List<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Remove_FirstItems()
+		{
+			var data = TestObjects;
+			using var list = new PooledList<object>(data, ClearMode.Always);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Remove_FirstItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableArrayList<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Remove_FirstItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableList<object>(data, minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/Remove_LastItems.cs

@@ -0,0 +1,57 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void List_Remove_LastItems()
+		{
+			var data = TestObjects;
+			var list = new List<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_Remove_LastItems()
+		{
+			var data = TestObjects;
+			using var list = new PooledList<object>(data, ClearMode.Always);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_Remove_LastItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableArrayList<object>(data);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_Remove_LastItems()
+		{
+			var data = TestObjects;
+			using var list = new RecyclableList<object>(data, minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
+			var dataCount = TestObjectCount / 10 > 0 ? TestObjectCount / 10 : TestObjectCount;
+			for (var i = data.Length - 1; i > data.Length - dataCount - 1; i--)
+			{
+				DoNothing(list.Remove(data[i]));
+			}
+		}
+	}
+}

Recyclable.Collections.Benchmarks/Benchmarks/SetItem.cs

@@ -0,0 +1,64 @@
+using BenchmarkDotNet.Attributes;
+using Collections.Pooled;
+
+namespace Recyclable.Collections.Benchmarks
+{
+	public partial class RecyclableCollectionsBenchmarks
+	{
+		//[Benchmark(Baseline = false)]
+		public void Array_SetItem()
+		{
+			var data = TestObjects;
+			var dataCount = TestObjectCount;
+			long index = 0;
+			for (var i = 0; i < dataCount; i++)
+			{
+				data[index] = TestObjects[index++];
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void List_SetItem()
+		{
+			var data = TestObjectsAsList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				data[i] = TestObjects[i];
+			}
+		}
+
+		//[Benchmark(Baseline = true)]
+		public void PooledList_SetItem()
+		{
+			var data = _testPooledList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				data[i] = TestObjects[i];
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableArrayList_SetItem()
+		{
+			var data = TestObjectsAsRecyclableArrayList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				data[i] = TestObjects[i];
+			}
+		}
+
+		//[Benchmark(Baseline = false)]
+		public void RecyclableList_SetItem()
+		{
+			var data = _testRecyclableList;
+			var dataCount = TestObjectCount;
+			for (var i = 0; i < dataCount; i++)
+			{
+				data[i] = TestObjects[i];
+			}
+		}
+	}
+}