New classes and conceptual grouper

src/Unosquare.DateTimeExt/BaseGrouper.cs

@@ -0,0 +1,20 @@
+using Unosquare.DateTimeExt.Interfaces;
+
+namespace Unosquare.DateTimeExt;
+
+public abstract class BaseGrouper<T, TConcrete> : IGrouper<T, TConcrete>
+{
+    public abstract IEnumerable<IGrouping<TConcrete, T>> GroupByDateRange();
+
+    public IDictionary<string, List<T>> GroupByLabel() =>
+        GroupByDateRange()
+            .ToDictionary(x => x.Key!.ToString()!, x => x.ToList());
+
+    public IDictionary<string, List<TResult>> GroupByLabel<TResult>(Func<T, TResult> selector) =>
+        GroupByDateRange()
+            .ToDictionary(x => x.Key!.ToString()!, x => x.Select(selector).ToList());
+
+    public IDictionary<string, int> GroupCount() =>
+        GroupByDateRange()
+            .ToDictionary(x => x.Key!.ToString()!, x => x.Count());
+}

src/Unosquare.DateTimeExt/DateOnlyRange.cs

@@ -6,7 +6,7 @@ namespace Unosquare.DateTimeExt;
 /// <summary>
 /// Represents a range of dates with only the date component (no time component).
 /// </summary>
-public sealed class DateOnlyRange : RangeBase<DateOnly>, IReadOnlyDateOnlyRange, IComparable<DateOnlyRange>,
+public sealed class DateOnlyRange : RangeBase<DateOnly, DateOnly>, IReadOnlyDateOnlyRange, IComparable<DateOnlyRange>,
     IEnumerable<DateOnly>, IHasBusinessDaysDateOnly
 {
     /// <summary>
@@ -25,7 +25,7 @@ public DateOnlyRange()
     /// <param name="endDate">The end date (optional).</param>
     /// <exception cref="ArgumentOutOfRangeException">Thrown when the end date is before the start date.</exception>
     public DateOnlyRange(DateOnly startDate, DateOnly? endDate = null)
-        : base(startDate, endDate)
+        : base(startDate, endDate ?? startDate)
     {
         if (EndDate < StartDate)
             throw new ArgumentOutOfRangeException(nameof(endDate), "End Date should be after Start Date");

src/Unosquare.DateTimeExt/DateRange.cs

@@ -6,7 +6,7 @@ namespace Unosquare.DateTimeExt;
 /// <summary>
 /// Represents a range of dates with a start and end date.
 /// </summary>
-public class DateRange : RangeBase<DateTime>, IReadOnlyDateRange, IHasReadOnlyMidnightEndDate, IComparable<DateRange>, IEnumerable<DateTime>, IHasBusinessDays
+public class DateRange : RangeBase<DateTime, DateTime>, IReadOnlyDateRange, IHasReadOnlyMidnightEndDate, IComparable<DateRange>, IEnumerable<DateTime>, IHasBusinessDays
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="DateRange"/> class with the current UTC date and time.
@@ -22,7 +22,7 @@ public DateRange(IReadOnlyDateRange range)
     }
 
     public DateRange(DateTime startDate, DateTime? endDate = null)
-    : base(startDate, endDate)
+    : base(startDate, endDate ?? startDate)
     {
         if (EndDate < StartDate)
             throw new ArgumentOutOfRangeException(nameof(endDate), "End Date should be after Start Date");

src/Unosquare.DateTimeExt/Interfaces/ICanHaveReadOnlyEndDate.cs

@@ -0,0 +1,6 @@
+namespace Unosquare.DateTimeExt.Interfaces;
+
+public interface ICanHaveReadOnlyEndDate
+{
+    DateTime? EndDate { get; }
+}

src/Unosquare.DateTimeExt/Interfaces/IGrouper.cs

@@ -0,0 +1,12 @@
+namespace Unosquare.DateTimeExt.Interfaces;
+
+public interface IGrouper<T, out TConcrete>
+{
+    IEnumerable<IGrouping<TConcrete, T>> GroupByDateRange();
+
+    IDictionary<string, List<T>> GroupByLabel();
+
+    IDictionary<string, List<TResult>> GroupByLabel<TResult>(Func<T, TResult> selector);
+
+    IDictionary<string, int> GroupCount();
+}

src/Unosquare.DateTimeExt/Interfaces/IReadOnlyOpenDateRange.cs

@@ -0,0 +1,5 @@
+namespace Unosquare.DateTimeExt.Interfaces;
+
+public interface IReadOnlyOpenDateRange : IHasReadOnlyStartDate, ICanHaveReadOnlyEndDate
+{
+}

src/Unosquare.DateTimeExt/OpenDateRange.cs

@@ -0,0 +1,46 @@
+using System.Collections;
+using Unosquare.DateTimeExt.Interfaces;
+
+namespace Unosquare.DateTimeExt;
+
+public class OpenDateRange(DateTime startDate, DateTime? endDate = null) : RangeBase<DateTime, DateTime?>(startDate, endDate), IReadOnlyOpenDateRange, IComparable<OpenDateRange>, IEnumerable<DateTime>, IHasBusinessDays
+{
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public override IEnumerator<DateTime> GetEnumerator()
+    {
+        if (EndDate is not null)
+        {
+            var daysInBetween = (EndDate.Value - StartDate).Days;
+            for (var i = 0; i <= daysInBetween; i++)
+                yield return StartDate.AddDays(i);
+        }
+        else
+        {
+            var i = 0;
+
+            while (DateTime.MaxValue != StartDate.AddDays(i))
+                yield return StartDate.AddDays(++i);
+        }
+    }
+
+    public int CompareTo(OpenDateRange? other)
+    {
+        if (ReferenceEquals(this, other))
+            return 0;
+
+        if (other is null)
+            return 1;
+
+        var startDateComparison = StartDate.CompareTo(other.StartDate);
+
+        return startDateComparison != 0 ? startDateComparison : (EndDate?.CompareTo(other.EndDate) ?? 0);
+    }
+
+    public override string ToString() => $"{StartDate.ToShortDateString()} - {EndDate?.ToShortDateString()}";
+
+    public override int GetHashCode() => StartDate.GetHashCode() + EndDate.GetHashCode();
+
+    public DateTime FirstBusinessDay => StartDate.GetFirstBusinessDayOfMonth();
+    public DateTime LastBusinessDay => (EndDate ?? DateTime.Now).GetLastBusinessDayOfMonth();
+}

src/Unosquare.DateTimeExt/RangeBase.cs

@@ -1,28 +1,28 @@
 namespace Unosquare.DateTimeExt;
 
-public abstract class RangeBase<T> where T : struct
+public abstract class RangeBase<TStart, TEnd> where TStart : struct
 {
-    protected RangeBase(T startDate, T? endDate = default)
+    protected RangeBase(TStart startDate, TEnd endDate)
     {
         StartDate = startDate;
-        EndDate = endDate ?? startDate;
+        EndDate = endDate;
     }
 
-    public T StartDate { get; }
+    public TStart StartDate { get; }
 
-    public T EndDate { get; }
+    public TEnd EndDate { get; }
 
-    public IEnumerable<TK> Select<TK>(Func<T, TK> selector)
+    public IEnumerable<TK> Select<TK>(Func<TStart, TK> selector)
     {
         using var enumerator = GetEnumerator();
 
         while (enumerator.MoveNext())
             yield return selector(enumerator.Current);
     }
 
-    public abstract IEnumerator<T> GetEnumerator();
+    public abstract IEnumerator<TStart> GetEnumerator();
 
-    public void Deconstruct(out T startDate, out T endDate)
+    public void Deconstruct(out TStart startDate, out TEnd endDate)
     {
         startDate = StartDate;
         endDate = EndDate;

src/Unosquare.DateTimeExt/Unosquare.DateTimeExt.csproj

@@ -4,9 +4,10 @@
 		<TargetFrameworks>net8.0;net6.0</TargetFrameworks>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
+		<LangVersion>preview</LangVersion>
 		<AnalysisLevel>latest</AnalysisLevel>
 		<CodeAnalysisRuleSet>..\..\StyleCop.Analyzers.ruleset</CodeAnalysisRuleSet>
-		<Version>1.2.1</Version>
+		<Version>1.3.0</Version>
 	</PropertyGroup>
 
 </Project>

src/Unosquare.DateTimeExt/YearMonthGrouper.cs

@@ -0,0 +1,8 @@
+using Unosquare.DateTimeExt.Interfaces;
+
+namespace Unosquare.DateTimeExt;
+
+public class YearMonthGrouper<T>(IEnumerable<T> query) : BaseGrouper<T, YearMonth> where T : IYearMonth
+{
+    public override IEnumerable<IGrouping<YearMonth, T>> GroupByDateRange() => query.GroupBy(x => new YearMonth(x.Month, x.Year));
+}

src/Unosquare.DateTimeExt/YearMonthRecordGrouper.cs

@@ -0,0 +1,8 @@
+using Unosquare.DateTimeExt.Interfaces;
+
+namespace Unosquare.DateTimeExt;
+
+public class YearMonthRecordGrouper<T>(IEnumerable<T> query) : BaseGrouper<T, YearMonthRecord> where T : IYearMonth
+{
+    public override IEnumerable<IGrouping<YearMonthRecord, T>> GroupByDateRange() => query.GroupBy(x => new YearMonthRecord { Month = x.Month, Year = x.Year });
+}

src/Unosquare.DateTimeExt/YearQuarterGrouper.cs

@@ -0,0 +1,8 @@
+using Unosquare.DateTimeExt.Interfaces;
+
+namespace Unosquare.DateTimeExt;
+
+public class YearQuarterGrouper<T>(IEnumerable<T> query) : BaseGrouper<T, YearQuarter> where T : IYearQuarter
+{
+    public override IEnumerable<IGrouping<YearQuarter, T>> GroupByDateRange() => query.GroupBy(x => new YearQuarter(x.Quarter, x.Year));
+}

src/Unosquare.DateTimeExt/YearQuarterRecordGrouper.cs

@@ -0,0 +1,8 @@
+using Unosquare.DateTimeExt.Interfaces;
+
+namespace Unosquare.DateTimeExt;
+
+public class YearQuarterRecordGrouper<T>(IEnumerable<T> query) : BaseGrouper<T, YearQuarterRecord> where T : IYearQuarter
+{
+    public override IEnumerable<IGrouping<YearQuarterRecord, T>> GroupByDateRange() => query.GroupBy(x => new YearQuarterRecord { Year = x.Year, Quarter = x.Quarter });
+}