Add new enumerable extensions Chunked

Author: I-RzR-I

src/DomainCommonExtensions/ArraysExtensions/EnumerableExtensions.cs

@@ -14,17 +14,17 @@
 //  </summary>
 // ***********************************************************************
 
+using DomainCommonExtensions.CommonExtensions;
+using DomainCommonExtensions.CommonExtensions.TypeParam;
+using DomainCommonExtensions.DataTypeExtensions;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
+using System.Data;
 using System.Diagnostics.Contracts;
 using System.Linq;
 using System.Text;
-using DomainCommonExtensions.CommonExtensions;
-using System.Data;
-using DomainCommonExtensions.CommonExtensions.TypeParam;
-using DomainCommonExtensions.DataTypeExtensions;
 
 // ReSharper disable UnusedParameter.Local
 // ReSharper restore PossibleMultipleEnumeration
@@ -519,5 +519,38 @@ public static IEnumerable<T> ForEachAndReturn<T>(this IEnumerable<T> list, Actio
 
             return list;
         }
+
+        /// <summary>
+        ///     Chunk source array of data by size.
+        /// </summary>
+        /// <param name="source">Source list/array.</param>
+        /// <param name="chunkSize">The chunk size. Default value is 100.</param>
+        /// <typeparam name="T">Type of list</typeparam>
+        /// <returns></returns>
+        /// <remarks></remarks>
+        public static IEnumerable<IEnumerable<T>> Chunked<T>(this IEnumerable<T> source, int chunkSize = 100)
+        {
+            if (source.IsNullOrEmptyEnumerable())
+                return new List<IEnumerable<T>>();
+            if (chunkSize.IsNull() || chunkSize.IsLessOrEqualZero())
+                return new List<IEnumerable<T>>(1) { source };
+
+            var chunkArray = source.ToArray();
+            var chunksCount = (int)Math.Ceiling((double)source.Count() / chunkSize);
+            var chunks = new List<IEnumerable<T>>(chunksCount);
+
+            for (var chunkIndex = 0; chunkIndex < chunksCount; chunkIndex++)
+            {
+                var newChunkSize = chunkIndex == chunksCount - 1 ? chunkArray.Length - (chunkSize * chunkIndex) : chunkSize;
+                var newChunkSourceIndex = chunkIndex.IsZero() ? chunkIndex : (chunkSize * chunkIndex) - 1;
+
+                var chunk = new T[newChunkSize];
+                Array.Copy(chunkArray, newChunkSourceIndex, chunk, 0, newChunkSize);
+
+                chunks.Add(chunk);
+            }
+
+            return chunks;
+        }
     }
 }

src/tests/DataTypeTests/DataTests/EnumerableTests.cs

@@ -0,0 +1,69 @@
+// ***********************************************************************
+//  Assembly         : RzR.Shared.Extensions.DataTypeTests
+//  Author           : RzR
+//  Created On       : 2025-06-27 08:10
+// 
+//  Last Modified By : RzR
+//  Last Modified On : 2025-06-27 08:10
+// ***********************************************************************
+//  <copyright file="EnumerableTests.cs" company="RzR SOFT & TECH">
+//   Copyright © RzR. All rights reserved.
+//  </copyright>
+// 
+//  <summary>
+//  </summary>
+// ***********************************************************************
+
+using System.Linq;
+using DomainCommonExtensions.ArraysExtensions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace DataTypeTests.DataTests
+{
+    [TestClass]
+    public class EnumerableTests
+    {
+        [TestMethod]
+        public void ChunkArray_Chunked_5_Test()
+        {
+            var arrInput = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+
+            var chunks = arrInput.Chunked(5).ToArray();
+
+            Assert.IsNotNull(chunks);
+            Assert.AreEqual(3, chunks.Count());
+            Assert.AreEqual(5, chunks[0].Count());
+            Assert.AreEqual(5, chunks[1].Count());
+            Assert.AreEqual(2, chunks[2].Count());
+        }
+
+        [TestMethod]
+        public void ChunkArray_Chunked_2_Test()
+        {
+            var arrInput = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+
+            var chunks = arrInput.Chunked(2).ToArray();
+
+            Assert.IsNotNull(chunks);
+            Assert.AreEqual(6, chunks.Count());
+            Assert.AreEqual(2, chunks[0].Count());
+            Assert.AreEqual(2, chunks[1].Count());
+            Assert.AreEqual(2, chunks[2].Count());
+            Assert.AreEqual(2, chunks[3].Count());
+            Assert.AreEqual(2, chunks[4].Count());
+            Assert.AreEqual(2, chunks[5].Count());
+        }
+
+        [TestMethod]
+        public void ChunkArray_Chunked_20_Test()
+        {
+            var arrInput = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+
+            var chunks = arrInput.Chunked(20).ToArray();
+
+            Assert.IsNotNull(chunks);
+            Assert.AreEqual(1, chunks.Count());
+            Assert.AreEqual(12, chunks[0].Count());
+        }
+    }
+}