每当我试图解决这样的问题时，我发现将问题可视化非常有用。像这样的东西：

如您所见，我们知道新区块只能在预订的开始时间或结束时间开始。因此，代码可以简单地遍历所有时间，以您需要的任何粒度，查找预订的开始或结束时间，并根据需要进行计算。

代码可以写成这样（假设是分钟粒度）：

var startTimes = reservations.GroupBy(x => x.StartTime).ToDictionary(k => k.Key, v => v.Count());
var endTimes = reservations.GroupBy(x => x.EndTime).ToDictionary(k => k.Key, v => v.Count());
    
var dayStart = TimeSpan.FromHours(8);
var dayEnd = TimeSpan.FromHours(18);
    
var currentCount = 0;
var result = new List<TimeLineItem>();
var currentStart = dayStart;
var currentEnd = dayEnd;
for(var time = dayStart; time <= dayEnd;time = time.Add(TimeSpan.FromMinutes(1)))
{           
    if(startTimes.TryGetValue(time, out var numStart))
    {               
        if(currentCount>0)
        {   
            result.Add(CreateItem(currentStart, time, currentCount));
            currentStart = time;                
        }   
        currentCount += numStart;   
    }
    if(endTimes.TryGetValue(time, out var numEnd))
    {
        if(currentCount>1)
        {   
            result.Add(CreateItem(currentStart, time, currentCount));
            currentStart = time;
        }
        currentCount -= numEnd;
    }
}   
result.Add(CreateItem(currentStart, dayEnd, currentCount));

这将产生您期望的确切输出：

08:00:00 - 10:00:00 (Success)
10:00:00 - 11:00:00 (Warning)
11:00:00 - 12:00:00 (Error)
12:00:00 - 18:00:00 (Success)

现场示例：https://dotnetfiddle.net/WLomdH

肯定有一些边缘情况没有涵盖，但这应该为你提供了一个良好的测试基础。

功能改进和全面工作

我没有使用分钟粒度并循环遍历每一分钟，而是决定采用一种不同的、更有效的方法，即使用 .Aggregate（） 和其他一些 LINQ 方法。最终结果效果非常好，除了由于某种原因开始项目时间是 00：00。我通过检查项目开始时间是否早于允许的开始时间，如果是，则将其设置为开始时间来解决这个问题。

下面的代码块组合在一起，给出了最终结果的工作函数。

主要功能

public async Task<List<TimeLineItem>> GetTimeLineItems()
{
    var reservations = await _reservationCollection.GetReservations();
    if (reservations.Count < 1)
    {
        return new List<TimeLineItem>();
    }

    var processedReservations = reservations.Where(r => r.Date.Date == DateTime.Today)
        .OrderBy(r => r.StartTime).ToArray();
    var mergedReservations = new List<Reservation>();
    if (processedReservations.Length < 1) return new List<TimeLineItem>();
    var currentReservation = processedReservations[0];
    for (var i = 1; i < processedReservations.Length; i++)
    {
        var nextReservation = processedReservations[i];
        if ((nextReservation.StartTime - currentReservation.EndTime).TotalMinutes <= _timeMarginInMinutes * 2 &&
            currentReservation.Charger == nextReservation.Charger)
        {
            currentReservation.EndTime = nextReservation.EndTime;
        }
        else
        {
            mergedReservations.Add(currentReservation);
            currentReservation = nextReservation;
        }
    }

    var reservationEvents = processedReservations
        .SelectMany(r => new List<ReservationEvent>
            { new(r.StartTime, -1), new(r.EndTime, 1) })
        .OrderBy(r => r.Moment).ToArray();
    var chargers = await _chargerCollection.GetChargers();
    var chargerAmount = chargers.Count;
    var result = reservationEvents
        .Prepend(new ReservationEvent(_startTime,  chargerAmount)) // Add initial state
        .GroupBy(r => r.Moment)
        .Select(group => new
        {
            Moment = group.Key,
            Action = group.Sum(r => r.Action)
        })
        .Where(r => r.Action != 0)
        .OrderBy(r => r.Moment)
        .Aggregate(
            new DayAccumulator
            {
                Availability = 0, // Will be set to 3 by first ReservationEvent
                States = new List<TimelineState> { new() { Color = Color.Success }}
            },
            (acc, r) =>
            {
                acc.Availability += r.Action;

                var lastState = acc.States.Last();
                if (lastState.Color != GetAvailabilityColor(acc.Availability))
                {
                    acc.States.Add(new TimelineState
                    {
                        Moment = r.Moment,
                        Color = GetAvailabilityColor(acc.Availability)
                    });
                }
                return acc;
            }).States;
    var lastItem = result.Last();
    var timeLineItems = new List<TimeLineItem>();
    for (var i = 0; i < result.Count - 1; i++)
    {
        if (result[i].Moment < _startTime) result[i].Moment = _startTime;
        timeLineItems.Add(new TimeLineItem(result[i].Color, $"{result[i].Moment:hh\\:mm} - {result[i + 1].Moment:hh\\:mm}"));
    }

    if (lastItem.Moment < _endTime)
    {
        timeLineItems.Add(new TimeLineItem(lastItem.Color, $"{lastItem.Moment:hh\\:mm} - {_endTime:hh\\:mm}"));
    }
    return timeLineItems;
}

辅助函数，从可用性中获取正确的颜色

private Color GetAvailabilityColor(int availability)
{
    if (availability >= _okAvailabilityAmount)
    {
        return Color.Success;
    }
    if (availability >= _warningAvailabilityAmount)
    {
        return Color.Warning;
    }
    return Color.Error;
}

帮助程序类和记录

internal class DayAccumulator
{
    public int Availability { get; set; }
    public List<TimelineState> States { get; init; } = new();
}

internal class TimelineState
{
    public TimeSpan Moment { get; set; }
    public Color Color { get; set; }
}

internal record ReservationEvent(TimeSpan Moment, int Action);

所有这些代码组合在一起完全符合我的要求。