Add enumerable method SelectWithIsLast and WithObservable

Author: I-RzR-I

src/DomainCommonExtensions/ArraysExtensions/EnumerableExtensions.cs

@@ -856,5 +856,78 @@ public static bool HasAny<TSource>(this IEnumerable<TSource> source, Func<TSourc
 
             return false;
         }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Is last.
+        /// </summary>
+        /// <typeparam name="T">Generic type parameter.</typeparam>
+        /// <param name="source">The source enumerator.</param>
+        /// <remarks>
+        ///     Using this method, the enumerator will advance.
+        /// </remarks>
+        /// <returns>
+        ///     True if last, false if not.
+        /// </returns>
+        /// =================================================================================================
+        public static bool IsLast<T>(this IEnumerator<T> source)
+        {
+            if (source.IsNull())
+                return true;
+
+            return source.MoveNext().IsFalse();
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Is last.
+        /// </summary>
+        /// <typeparam name="TKey">Type of the key.</typeparam>
+        /// <typeparam name="TValue">Type of the value.</typeparam>
+        /// <param name="source">The source enumerator.</param>
+        /// <remarks>
+        ///     Using this method, the enumerator will advance.
+        /// </remarks>
+        /// <returns>
+        ///     True if last, false if not.
+        /// </returns>
+        /// =================================================================================================
+        public static bool IsLast<TKey, TValue>(
+            this IEnumerator<KeyValuePair<TKey, TValue>> source)
+        {
+            if (source.IsNull())
+                return true;
+
+            return source.MoveNext().IsFalse();
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Enumerates select with is last in this collection.
+        /// </summary>
+        /// <typeparam name="T">Generic type parameter.</typeparam>
+        /// <param name="source">The source for this extension method.</param>
+        /// <returns>
+        ///     An enumerator that allows foreach to be used to process select with is last in this
+        ///     collection.
+        /// </returns>
+        /// =================================================================================================
+        public static IEnumerable<TupleResult<T, bool>> SelectWithIsLast<T>(
+            this IEnumerable<T> source)
+        {
+            using var e = source.GetEnumerator();
+            if (e.MoveNext().IsFalse())
+                yield break;
+
+            var current = e.Current;
+
+            while (e.MoveNext())
+            {
+                yield return TupleResult.Create(current, false);
+                current = e.Current;
+            }
+
+            yield return TupleResult.Create(current, true);
+        }
     }
 }

src/DomainCommonExtensions/ArraysExtensions/ObservableEnumeratorExtensions.cs

@@ -0,0 +1,77 @@
+// ***********************************************************************
+//  Assembly         : RzR.Shared.Extensions.DomainCommonExtensions
+//  Author           : RzR
+//  Created On       : 2026-01-28 22:01
+// 
+//  Last Modified By : RzR
+//  Last Modified On : 2026-02-11 20:07
+// ***********************************************************************
+//  <copyright file="ObservableEnumeratorExtensions.cs" company="RzR SOFT & TECH">
+//   Copyright © RzR. All rights reserved.
+//  </copyright>
+// 
+//  <summary>
+//  </summary>
+// ***********************************************************************
+
+#region U S A G E S
+
+using System;
+using System.Collections.Generic;
+using DomainCommonExtensions.Collections;
+using DomainCommonExtensions.Utilities.Ensure;
+
+#endregion
+
+namespace DomainCommonExtensions.ArraysExtensions
+{
+    /// -------------------------------------------------------------------------------------------------
+    /// <summary>
+    ///     An observable enumerator extensions.
+    /// </summary>
+    /// =================================================================================================
+    public static class ObservableEnumeratorExtensions
+    {
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     An IEnumerable&lt;T&gt; extension method that convert to observable.
+        /// </summary>
+        /// <exception cref="ArgumentNullException">
+        ///     Thrown when one or more required arguments are null.
+        /// </exception>
+        /// <typeparam name="T">Generic type parameter.</typeparam>
+        /// <param name="source">The source to act on.</param>
+        /// <returns>
+        ///     An ObservableEnumerator&lt;T&gt;
+        /// </returns>
+        /// =================================================================================================
+        public static ObservableEnumerator<T> WithObservable<T>(
+            this IEnumerable<T> source)
+        {
+            DomainEnsure.IsNotNull(source, nameof(source));
+
+            return new ObservableEnumerator<T>(source);
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     An IEnumerable&lt;T&gt; extension method that convert to observable.
+        /// </summary>
+        /// <exception cref="ArgumentNullException">
+        ///     Thrown when one or more required arguments are null.
+        /// </exception>
+        /// <typeparam name="T">Generic type parameter.</typeparam>
+        /// <param name="enumerator">The enumerator to act on.</param>
+        /// <returns>
+        ///     An ObservableEnumerator&lt;T&gt;
+        /// </returns>
+        /// =================================================================================================
+        public static ObservableEnumerator<T> WithObservable<T>(
+            this IEnumerator<T> enumerator)
+        {
+            DomainEnsure.IsNotNull(enumerator, nameof(enumerator));
+
+            return new ObservableEnumerator<T>(enumerator);
+        }
+    }
+}

src/DomainCommonExtensions/Collections/IndexableEnumerable.cs

@@ -113,6 +113,16 @@ public IndexableEnumerable(List<T> list)
             : this((IList<T>)list)
         { }
 
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="IndexableEnumerable{T}"/> class.
+        /// </summary>
+        /// <param name="list">(Immutable) the list.</param>
+        /// =================================================================================================
+        public IndexableEnumerable(IEnumerable<T> list)
+            : this((IList<T>)list)
+        { }
+
         /// -------------------------------------------------------------------------------------------------
         /// <summary>
         ///     Initializes the index enumerable.
@@ -145,6 +155,17 @@ public IndexableEnumerable(List<T> list)
         /// </returns>
         /// =================================================================================================
         public static IIndexableEnumerable<T> Initialize(List<T> list) => new IndexableEnumerable<T>(list);
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Initializes the index enumerable.
+        /// </summary>
+        /// <param name="list">(Immutable) the list.</param>
+        /// <returns>
+        ///     An IIndexableEnumerable&lt;T&gt;
+        /// </returns>
+        /// =================================================================================================
+        public static IIndexableEnumerable<T> Initialize(IEnumerable<T> list) => new IndexableEnumerable<T>(list);
 
         /// <inheritdoc />
         public T this[int index] => _list[index];

src/DomainCommonExtensions/Collections/ObservableEnumerator.cs

@@ -0,0 +1,202 @@
+// ***********************************************************************
+//  Assembly         : RzR.Shared.Extensions.DomainCommonExtensions
+//  Author           : RzR
+//  Created On       : 2026-01-28 22:01
+// 
+//  Last Modified By : RzR
+//  Last Modified On : 2026-01-28 22:52
+// ***********************************************************************
+//  <copyright file="ObservableEnumerator.cs" company="RzR SOFT & TECH">
+//   Copyright © RzR. All rights reserved.
+//  </copyright>
+// 
+//  <summary>
+//  </summary>
+// ***********************************************************************
+
+#region U S A G E S
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using DomainCommonExtensions.CommonExtensions;
+
+// ReSharper disable PossibleMultipleEnumeration
+
+#endregion
+
+namespace DomainCommonExtensions.Collections
+{
+    /// -------------------------------------------------------------------------------------------------
+    /// <summary>
+    ///     An observable enumerator. This class cannot be inherited.
+    /// </summary>
+    /// <typeparam name="T">Generic type parameter.</typeparam>
+    /// <seealso cref="T:System.Collections.Generic.IEnumerator{T}"/>
+    /// =================================================================================================
+    public sealed class ObservableEnumerator<T> : IEnumerator<T>
+    {
+        private readonly IEnumerable<T> _source;
+
+        private T _current = default;
+        private T _peek = default;
+
+        private bool _hasCurrent, _hasPeek;
+
+        private IEnumerator<T> _inner;
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="ObservableEnumerator{T}"/> class.
+        /// </summary>
+        /// <param name="source">The source data.</param>
+        /// =================================================================================================
+        internal ObservableEnumerator(IEnumerable<T> source)
+        {
+            _source = source;
+            _inner = source.GetEnumerator();
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="ObservableEnumerator{T}"/> class.
+        /// </summary>
+        /// <param name="inner">The inner.</param>
+        /// =================================================================================================
+        internal ObservableEnumerator(IEnumerator<T> inner)
+        {
+            _inner = inner;
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Gets a value indicating whether this object is last.
+        /// </summary>
+        /// <value>
+        ///     True if this object is last, false if not.
+        /// </value>
+        /// =================================================================================================
+        public bool IsLast
+        {
+            get
+            {
+                EnsureStarted();
+                EnsurePeeked();
+
+                return !_hasPeek;
+            }
+        }
+
+        /// <inheritdoc />
+        public T Current
+        {
+            get
+            {
+                EnsureStarted();
+
+                return _current;
+            }
+        }
+
+        /// <inheritdoc />
+        object IEnumerator.Current => Current;
+
+        /// <inheritdoc />
+        public bool MoveNext()
+        {
+            if (_hasPeek)
+            {
+                _current = _peek;
+                _hasPeek = false;
+                _hasCurrent = true;
+
+                return true;
+            }
+
+            if (!_inner.MoveNext())
+            {
+                _hasCurrent = false;
+
+                return false;
+            }
+
+            _current = _inner.Current;
+            _hasCurrent = true;
+
+            return true;
+        }
+
+        /// <inheritdoc />
+        public void Reset()
+        {
+            if (_source.IsNull())
+                throw new NotSupportedException("Reset is not supported.");
+
+            _inner.Dispose();
+            _inner = _source.GetEnumerator();
+
+            _hasCurrent = false;
+            _hasPeek = false;
+        }
+
+        /// <inheritdoc />
+        public void Dispose() => _inner.Dispose();
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Attempts to peek.
+        /// </summary>
+        /// <param name="value">[out] The value.</param>
+        /// <returns>
+        ///     True if it succeeds, false if it fails.
+        /// </returns>
+        /// =================================================================================================
+        public bool TryPeek(out T value)
+        {
+            EnsureStarted();
+            EnsurePeeked();
+
+            if (_hasPeek)
+            {
+                value = _peek;
+
+                return true;
+            }
+
+            value = default;
+
+            return false;
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Ensures that peeked.
+        /// </summary>
+        /// =================================================================================================
+        private void EnsurePeeked()
+        {
+            if (_hasPeek)
+                return;
+
+            if (_inner.MoveNext())
+            {
+                _peek = _inner.Current;
+                _hasPeek = true;
+            }
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Ensures that enumeration started.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        ///     Thrown when the requested operation is invalid.
+        /// </exception>
+        /// =================================================================================================
+        private void EnsureStarted()
+        {
+            if (!_hasCurrent)
+                throw new InvalidOperationException("Enumeration has not started.");
+        }
+    }
+}