C#Linq查询以查找无效条目

我正在尝试对列表中的数据进行一些手动验证

我有一个MachineryRecord类，我对它进行排序，然后根据作业编号进行分组，现在我需要在每个分组列表中找到任何有重叠时间的结果，例如开始时间到结束时间与另一个记录开始时间到结束时间重叠

到目前为止，我得到的是：

int invalidCount = 0;
var sorted = _machineRecords.OrderBy(x => x.StartTime).ToList();
var grouped = sorted.GroupBy(x => x.JobNumber).ToList();
foreach(IGrouping<int,MachineryRecord> mac in grouped)     
{
   var queryResults = mac.//Linq query to find overlapping times
   invalidCount += queryResults.Count;
}
if(invalidCount > 0)
    return false;
else
    return true;

所以我的问题是linq查询是如何实现这一点的

---

谢谢您的帮助。

如果

a.StartTime

和

a.EndTime>b.StartTime

假设开始时间总是在结束时间之前，则两个间隔

a

和

b.StartTime

重叠。因此，这可以表示如下

var invalidCount = _machineRecords.Count(a =>
                       _machineRecords.Any(b =>
                           (a.ID != b.ID) &&
                           (a.JobNumber == b.JobNumber) &&
                           (a.StartTime < b.EndTime) &&
                           (a.EndTime > b.StartTime)));

---

这是一个非LINQ版本，将使用集合按开始日期排序的事实：

    List<Tuple<MachineryRecord,MachineryRecord>> OverlapingRecords(IEnumerable<MachineryRecord> sortedRecords)
    {
        var result = new List<Tuple<MachineryRecord, MachineryRecord>>();
        MachineryRecord prev = null;
        foreach (var current in sortedRecords)
        {
            if (prev != null)
            {
                if (current.StartTime < prev.EndTime) { result.Add(new Tuple<MachineryRecord, MachineryRecord>(prev,current)); }
            }
            prev = current;
        }
        return result;
    }

列出重叠记录（IEnumerable sortedRecords）
{
var result=新列表（）；
MachineryRecord prev=空；
foreach（分拣记录中的无功电流）
{
如果（上一个！=null）
{
if（current.StartTime

---

我还没有测试过；）

时间的格式是什么？你为什么用浮球？是24小时制吗？你能出示开始和结束时间的样本吗？对不起，忘了说开始时间和结束时间是从机器的计数器中提取的，类似于汽车里的里程表，但计算小时数。因此，在时间上使用float这有一个小错误，当检查同一台机器记录时，它返回true。我如何修改它来修复它？已经修复了-只需比较ID或引用

a！=b

.Nice，但它没有利用集合被排序的事实（我假设是按开始日期排序的）。我不认为记录被排序（按开始时间），因为问题中有一个明确的

OrderBy

。优化方法并不是那么简单——如果有很多违规行为，那么如果你先对其进行排序，可能会减慢整个过程，因为你无论如何都会提前发现违规行为。如果违规情况很少，那么对数据进行预排序可能会有所帮助。同样，按照问题中的作业编号对数据进行分组似乎是个好主意。但我决定采用一种相对简单的解决方案——如果存在性能问题，了解实际数据就很容易调整。

return !_machineRecords.Any(a =>
           _machineRecords.Any(b =>
               (a.ID != b.ID) &&
               (a.JobNumber == b.JobNumber) &&
               (a.StartTime < b.EndTime) &&
               (a.EndTime > b.StartTime)));

    List<Tuple<MachineryRecord,MachineryRecord>> OverlapingRecords(IEnumerable<MachineryRecord> sortedRecords)
    {
        var result = new List<Tuple<MachineryRecord, MachineryRecord>>();
        MachineryRecord prev = null;
        foreach (var current in sortedRecords)
        {
            if (prev != null)
            {
                if (current.StartTime < prev.EndTime) { result.Add(new Tuple<MachineryRecord, MachineryRecord>(prev,current)); }
            }
            prev = current;
        }
        return result;
    }