下面是我解决的方法：首先，我确定ReadingSession是否跨越多天。如果它跨越了几天，我会把它分开。剩下的就和你已经做的差不多了。

internal class Program
    {
        static void Main(string[] args)
        {
            List<ReadingSession> readingSessions = new List<ReadingSession>()
            {
                new ()
                { 
                    StartAt = new DateTime(2023, 5, 1, 23, 0, 0),
                    EndAt = new DateTime(2023, 5, 2, 1, 0, 0)
                },
                new ()
                {
                    StartAt = new DateTime(2023, 5, 1, 22, 0, 0),
                    EndAt = new DateTime(2023, 5, 1, 23, 0, 0)
                },
            };

            var dailyDurations = readingSessions
                .SelectMany(rs => 
                {
                    if (rs.SingleDay)
                    { 
                        return new[] { rs };
                    }
                    else
                    {
                        // split it into two sessions,
                        // one for each day
                        return new[]
                        {
                            new ReadingSession { StartAt = rs.StartAt, EndAt = rs.StartAt.Date.AddDays(1) },
                            new ReadingSession { StartAt = rs.EndAt.Date, EndAt = rs.EndAt }
                        };
                    }
                })
                .GroupBy(rs => rs.StartAt.Date)
                .Select(g => new
                {
                    Date = g.Key, Sum = g.Sum(rs => (rs.EndAt - rs.StartAt).TotalMinutes)
                })
                .ToList();
        }

        public class ReadingSession
        {
            public DateTime StartAt { get; set; }
            public DateTime EndAt { get; set; }
            public bool SingleDay => EndAt.Date == StartAt.Date;
        }

以下是我的解决方案：

var readingSessions = new List<ReadingSession>()
        {
            new ReadingSession(){StartAt = DateTime.Parse("2023-05-01 10:22:59 PM"), EndAt = DateTime.Parse("2023-05-02 01:00:00 AM")},
            new ReadingSession(){StartAt = DateTime.Parse("2023-05-01 10:22:59 PM"), EndAt = DateTime.Parse("2023-05-01 11:00:00 PM")}
        };

        IEnumerable <(int DayOfYear,TimeSpan TotalDuration)> result = readingSessions.Select(session => 
        (
            session.EndAt.DayOfYear,
            new TimeSpan(
                            readingSessions.Where(r => r.EndAt.DayOfYear == session.EndAt.DayOfYear)
                                           .Sum(rs => rs.EndAt.DayOfYear == session.StartAt.DayOfYear?
                                                        rs.EndAt.Subtract(rs.StartAt).Ticks :
                                                        rs.EndAt.TimeOfDay.Ticks)
                        )
        ));
        result.ToList()
              .ForEach(r => Console.WriteLine($"DayOfYear: {r.DayOfYear} TotalDuration: {r.TotalDuration}"));

有几点需要考虑：
1.最好是将和提取到不同的函数中
1.如果阅读会话的持续时间超过2天，则代码将仅对开始日期和结束日期的持续时间求和

谢谢你澄清你的问题。我认为你想要的是一种方法，将一个单一的ReadingSession和分裂成 * 每日 * 阅读会话。这将为您提供仅在一天内发生的会话列表。
例如，如果一个阅读会话持续了5天，下面将返回5个单独的阅读会话的列表，每天一个，第一个在开始时间开始，最后一个在结束时间结束，其他的都在一天的开始/结束：

static List<ReadingSession> SplitIntoDailySessions(ReadingSession session)
{
    if (session == null) return null;

    // Capture initial start value (so as not to modify 'session' later)
    var start = session.StartAt;
    var result = new List<ReadingSession>();

    // While the end date is greater than the start date, create a new session 
    // from the start date until the beginning of the next day and add it to
    // our reault, then reset the start date to the beginning of the next day.
    while(session.EndAt.Date > start.Date)
    {
        result.Add(new ReadingSession { StartAt = start, 
            EndAt = start.Date.AddDays(1) });

        start = start.Date.AddDays(1);
    }

    // Now our start and end are on the same date, so we can add the final result
    result.Add(new ReadingSession { StartAt = start, EndAt = session.EndAt });

    return result;
}

现在，我们可以把我们最初的阅读课程列表，分成每天的课程，就像这样：

List<ReadingSession> dailyReadingSessions = readingSessions
    .SelectMany(rs => SplitIntoDailySessions(rs))
    .ToList();

现在，您的原始代码应该可以正常工作了，因为dailyReadingSessions中的每个阅读会话只跨越一个Date。

假设阅读会话总是少于24小时（例如跨度最多两天），那么您可以拆分跨越午夜的任何阅读会话，然后使用代码对结果进行分组和计算。我省略了Where方法，因为我不确定你希望最终的过滤器是什么：

var result = readingSessions
                .SelectMany(r => r.EndAt.Date > r.StartAt.Date // spans two days?
                                ? new[] { // reading time on first day
                                          new ReadingSession { StartAt = r.StartAt, EndAt = r.EndAt.Date },
                                          // reading time on second day
                                          new ReadingSession { StartAt = r.EndAt.Date, EndAt = r.EndAt }
                                        }
                                : new[] { r })
                .GroupBy(x => x.StartAt.Date) // group all reading time for each day
                .Select(x => new {
                    Date = x.Key,
                    Sum = TimeSpan.FromSeconds(x.Sum(y => (y.EndAt - y.StartAt).TotalSeconds))
                })
                .ToList();

注意：这不是非常有效，因为它为每一天的阅读会话生成一个数组，然后将其丢弃-您可以通过扫描列表两次并使用union将一天的会话与两天的会话合并，以牺牲时间为代价提高空间效率，但这可能不值得复杂性。这让我觉得SplitUnion方法可能很好。