LINQ Left Join with Grouping and have Convert this TSQL

Question

以下 TSQL 提供了一个示例，说明如何使用 SQL 解决此问题。目标是从左表中为每个 OID 返回 1 行，其中左表中的记录计数等于右表中匹配行的计数。

SELECT cs.OID, Count(cs.OID) AS CarCount, Sum(RS.Check) AS RoadCount  
   FROM Cars AS cs  
LEFT JOIN Roads AS RS  
  ON CS.oid = RS.OID  
   AND cs.RID = RS.RID  
  GROUP BY cs.OID  
  HAVING Count(cs.OID) = Sum(RS.Check)  

使用下面的对象设置，是否可以构造等效的 LINQ 查询，或者这不可能？请注意在 Road 类的声明中为 check 提供的默认值。在下面的设置示例中，结果应该是零匹配。再添加一条具有适当值的道路将使其仅返回一条。至少那是最理想的。

我遇到的问题是这种类型的 TSQL 代码对于 LINQ 来说似乎太复杂了。我还没有找到一个明显或不明显的解决方案来实现类似的行为。因此，我相信也许解决方案是停止尝试复制 SQL 并做一些不同的事情。由于没有足够的 LINQ 经验，我不知道从哪里开始。

public class Roads : List<Road>{}  
public class Road  
{  
    public int RID;  
    public int OID;  
    public int check = 1;  
}  
public class Cars : List<Car> { }  
public class Car  
{  
    public int RID;  
    public int OID;  
}  

private void CheckCheck()  
{  
    Roads rs = new Roads();  
    Cars cs = new Cars();  

    Car c = new Car();  
    c.OID = 1;  
    c.RID = 1;  
    cs.Add(c);  
    c = new Car();  
    c.OID = 1;  
    c.RID = 2;  
    cs.Add(c);  
    c = new Car();  
    c.OID = 1;  
    c.RID = 3;  
    cs.Add(c);  

    Road r = new Road();  
    r.OID = 1;  
    r.RID = 1;  
    rs.Add(r);  
    r = new Road();  
    r.OID = 1;  
    r.RID = 2;  
    rs.Add(r);  

    // Results should be :  
    // OID where Count of OID from C = Count of OID from R  
}  

Answer 1

• 您的 HAVING 子句将过滤掉任何与道路不匹配的汽车。这使得左连接变成了内连接。
• 你有COUNT(cs.OID)，它说它正在计算汽车，但它没有。你的意思可能是COUNT(DISTINCT cs.OID)

这里是直译：

from c in Cars
join r in Roads on new {c.OID, c.RID} equals new {r.OID, r.RID}
group new {Car = c, Road = r} by c.OID into g
let carCount = g.Count()  //did you mean g.Select(x => x.Car.OID).Distinct().Count()
let roadCount = g.Sum(x => x.Road.Check)
where carCount = roadCount
select new {OID = g.Key, CarCount = carCount, RoadCount = roadCount}

---

目标是从左表中为每个 OID 返回 1 行，其中左表中的记录计数等于右表中匹配行的计数。

根据这个描述，我会写：

var carLookup = Cars.ToLookup(c => c.OID);
var roadLookup = Roads.ToLookup(r => r.OID);

from x in carLookup
let carCount = x.Count()
let roadCount = roadLookup[x.Key].Count()
where carCount = roadCount
select new {OID = g.Key, CarCount = carCount, RoadCount = roadCount}

Answer 2

我不确定我是否完全理解所需的结果，但这是我的尝试。 check 字段对于 LINQ 来说并不是必需的，因为它除了用于计数之外没有任何用途。

我误解了连接的重要性以及HAVING 子句对查询的作用。它现在又回到了原来的 TSQL 版本，但 RoadCount 计算发生了变化。我相信这就是您所要求的。

var results = from Car in cs
              join road in rs
                  on new { Car.OID, Car.RID } equals new { road.OID, road.RID }
                  into Roads
              group roads by Car.OID into cars
              let CarCount = cars.Count()
              let RoadCount = cars.Sum(roads => roads.Count())
              where CarCount == RoadCount
              select new
              {
                  OID = cars.Key,
                  CarCount,
                  RoadCount
              };