C# 如何从循环中的列表中删除范围？

问候语请记住，没有数据库，这些都是假的函数，使组件能够进行测试，我有一个列表，它根据

15分钟
比例制作
24小时
，并由此方法生成：

    public List<ScaleLine> GetHoursAndScales(ScaleLine.Scales scale = ScaleLine.Scales.Fiftheen)
    {
        int _scale = Convert.ToInt32(scale);
        int _count = _scale * 24;
        int _scaleCount = 60 / _scale;

        List<ScaleLine> _list = new List<ScaleLine>();

        var start = DateTime.Today;
        var clockQuery = from offset in Enumerable.Range(1, _count)
                         select TimeSpan.FromMinutes(_scaleCount * offset);
        foreach (var time in clockQuery)
        {
            _list.Add(new ScaleLine() { Id = _list.Count, Hours = (start + time).ToString("HH:mm"), Scale = _scale });
        }
        return _list;
    }

public List GetHoursAndScales（ScaleLine.Scales scale=ScaleLine.Scales.Fiftheen）
{
int _scale=转换为32（比例）；
整数计数=_刻度*24；
int _scaleCount=60/_scale；
列表_List=新列表（）；
var start=DateTime.Today；
var clockQuery=可枚举范围中的自偏移量（1，_count）
选择TimeSpan.FromMinutes（\u scaleCount*offset）；
foreach（clockQuery中的变量时间）
{
_添加（新的ScaleLine（）{Id=\u list.Count，Hours=（开始+时间）.ToString（“HH:mm”），Scale=\u Scale}）；
}
返回列表；
}

我还有另一个列表，叫做保留时间，它是通过这个方法生成的：

    public List<Reservedhours> AllReservedHours()
    {
        return new List<Reservedhours>
        {
            new Reservedhours() { Id = 1, Date = DateTime.Now, StartPoint = "08:00", EndPoint = "10:00" },
            new Reservedhours() { Id = 2, Date = DateTime.Now, StartPoint = "14:00", EndPoint = "16:00" },
            new Reservedhours() { Id = 3, Date = DateTime.Now, StartPoint = "20:00", EndPoint = "22:00" },
            new Reservedhours() { Id = 4, Date = DateTime.Now.AddDays(1), StartPoint = "07:00", EndPoint = "11:00" },
            new Reservedhours() { Id = 5, Date = DateTime.Now.AddDays(1), StartPoint = "13:00", EndPoint = "15:00" },
            new Reservedhours() { Id = 6, Date = DateTime.Now.AddDays(1), StartPoint = "15:00", EndPoint = "18:00" },
            new Reservedhours() { Id = 7, Date = DateTime.Now.AddDays(1), StartPoint = "18:00", EndPoint = "22:00" },

        }; 
    }

public List AllReservedHours（）
{
返回新列表
{
new Reservedhours（）{Id=1，Date=DateTime.Now，StartPoint=“08:00”，EndPoint=“10:00”}，
new Reservedhours（）{Id=2，Date=DateTime.Now，StartPoint=“14:00”，EndPoint=“16:00”}，
new Reservedhours（）{Id=3，Date=DateTime.Now，StartPoint=“20:00”，EndPoint=“22:00”}，
new Reservedhours（）{Id=4，Date=DateTime.Now.AddDays（1），StartPoint=“07:00”，EndPoint=“11:00”}，
new Reservedhours（）{Id=5，Date=DateTime.Now.AddDays（1），StartPoint=“13:00”，EndPoint=“15:00”}，
new Reservedhours（）{Id=6，Date=DateTime.Now.AddDays（1），StartPoint=“15:00”，EndPoint=“18:00”}，
new Reservedhours（）{Id=7，Date=DateTime.Now.AddDays（1），StartPoint=“18:00”，EndPoint=“22:00”}，
}; 
}

现在我有了另一个列表，它根据保留的小时数生成可用的小时数，第一个列表生成24小时：

    public List<ScaleLine> GetAvailableHours(DateTime date, ScaleLine.Scales scale = ScaleLine.Scales.Fiftheen)
    {
        List<Reservedhours> _timeLine = AllReservedHours().Where(x => x.Date.Date == date.Date)
            .Select( a => new Reservedhours {StartPoint = a.StartPoint, EndPoint = a.EndPoint } )
            .ToList();
        List<ScaleLine> _available = GetHoursAndScales();

        //scale convert:
        int _scale = Convert.ToInt32(scale);

        foreach (var _item in _timeLine)
        {
            int index = _available.Where(x => x.Hours == _item.StartPoint)
                .SingleOrDefault().Id;

            //Convert to datetime
            DateTime _opening = DateTime.ParseExact(_item.StartPoint, "HH:mm", System.Globalization.CultureInfo.InvariantCulture);
            DateTime _closing = DateTime.ParseExact(_item.EndPoint, "HH:mm", System.Globalization.CultureInfo.InvariantCulture);
            //Getting duration time
            TimeSpan duration = _closing.Subtract(_opening);
            double _duration = duration.TotalMinutes;
            //getting coverage
            int timeScale = 60 / _scale;
            int coverage = Convert.ToInt32(_duration) / timeScale;

            //remove unavailable timespots
            _available.RemoveRange(index, coverage);
        }
        return _available; 
    }

public List GetAvailableHours（日期时间日期，ScaleLine.Scales scale=ScaleLine.Scales.Fiftheen）
{
列表_timeLine=AllReservedHours（）。其中（x=>x.Date.Date==Date.Date）
.Select（a=>newreservedhours{StartPoint=a.StartPoint，EndPoint=a.EndPoint}）
.ToList（）；
列表_available=GetHoursAndScales（）；
//比例转换：
int _scale=转换为32（比例）；
foreach（变量项目在时间线中）
{
int index=\u可用。其中（x=>x.Hours==\u item.StartPoint）
.SingleOrDefault（）.Id；
//转换为日期时间
DateTime _opening=DateTime.ParseExact（_item.StartPoint，“HH:mm”，System.Globalization.CultureInfo.InvariantCulture）；
DateTime _closing=DateTime.ParseExact（_item.EndPoint，“HH:mm”，System.Globalization.CultureInfo.InvariantCulture）；
//获取持续时间
时间跨度持续时间=_关闭。减去（_打开）；
double _duration=duration.TotalMinutes；
//获得保险
int时间刻度=60/_刻度；
int覆盖率=转换为32（_持续时间）/时间刻度；
//删除不可用的时间点
_可用。删除范围（索引、覆盖范围）；
}
返回可用；
}

但问题是当
Foreach
循环启动时，它会根据其索引正确删除第一个范围，假设
\u available
列表中有
96个
成员，它会删除其中的
8个
，因此，第二次它应该有
88个
成员，并在这些
88个
成员中找到
索引，但它没有，并且索引错误（它将索引视为列表仍然有
96个
成员），循环中的每个其他操作也是如此。如何解决此问题？有没有一种方法可以在不进行foreach循环的情况下获取可用列表
 问题在于你对指数的确定。您可以询问对象的属性值并将其用作索引，而不是询问列表中所需对象的索引：

int index = _available.Where(x => x.Hours == _item.StartPoint)
                      .SingleOrDefault()
                      .Id;

您可以通过调用
IndexOf（）
来请求索引：

或者用其他东西替换你的<代码> .ReleVangeEnter（）/Cux>，这真的删除了你想要的元素。
当你从一个数组中删除项目时，删除中间的一个项目会影响删除项目之后的所有项目的索引。解决方案是从列表的末尾开始，然后像这样向开头移动：for（int i=\u timeLine.Count（）-1；i>=0；i--）{var\u item=\u timeLine[i]；}@Valkyriee:作为旁注：如果在使用之前不检查空值（如
.SingleOrDefault（）.Id
），那么使用
OrDefault（）
是没有意义的。还要确保理解
.First（）
和
.Single（）
之间的区别。
var matchingItem = _available.Where(x => x.Hours == _item.StartPoint)
                             .First();
var index = _available.IndexOf(matchingItem);