用LINQ求边界

这段代码工作正常，但我想知道是否有某种方法可以在一个LINQ表达式中编写它，这样数据库服务器就可以完成一次传递，而不是实现一个结果集，然后在其中循环，这就是我的代码将生成的

  var logs = from AssetLog log in dc.AssetLogs
             where log.AssetId == assetId && log.Recorded >= start && log.Recorded <= finish
             select log;
  return new GetInteractionBoundsResult()
  {
    N = logs.Max(log => log.Latitude),
    S = logs.Min(log => log.Latitude),
    W = logs.Min(log => log.Longitude),
    E = logs.Max(log => log.Longitude)
  };

---

当然，只需欺骗您的LINQ提供者，使其认为它仍在处理查询，直到最后：

  var logs = from asset in dc.Assets
             where asset.AssetId == assetId 
             let g = asset.AssetLogs
                 .Where(log => log.Recorded >= start && log.Recorded <= finish)
             select new GetInteractionBoundsResult
                 {
                     N = g.Max(log => log.Latitude),
                     S = g.Min(log => log.Latitude),
                     W = g.Min(log => log.Longitude),
                     E = g.Max(log => log.Longitude)
                 };
  return logs.Single();

var logs=来自dc.Assets中的资产
其中asset.AssetId==AssetId
设g=asset.AssetLogs
.Where（log=>log.Recorded>=start&&log.Recorded log.Latitude），
S=g.Min（对数=>log.Latitude），
W=g.Min（log=>log.Longitude），
E=g.Max（log=>log.Longitude）
};
返回logs.Single（）；

Group By的性能可能比上述查询生成的联接更好：

  var logs = from log in dc.AssetLogs
             where log.AssetId == assetId &&
                 log.Recorded >= start && log.Recorded <= finish
             group log by log.AssetId into g
             select new GetInteractionBoundsResult
                 {
                     N = g.Max(log => log.Latitude),
                     S = g.Min(log => log.Latitude),
                     W = g.Min(log => log.Longitude),
                     E = g.Max(log => log.Longitude)
                 };
  return logs.Single();

var logs=来自dc.AssetLogs中的日志
其中log.AssetId==AssetId&&
log.Recorded>=开始和&log.Recorded log.Latitude），
S=g.Min（对数=>log.Latitude），
W=g.Min（log=>log.Longitude），
E=g.Max（log=>log.Longitude）
};
返回logs.Single（）；

当然，只要欺骗您的LINQ提供商，使其认为它仍然在处理查询，直到最后：

  var logs = from asset in dc.Assets
             where asset.AssetId == assetId 
             let g = asset.AssetLogs
                 .Where(log => log.Recorded >= start && log.Recorded <= finish)
             select new GetInteractionBoundsResult
                 {
                     N = g.Max(log => log.Latitude),
                     S = g.Min(log => log.Latitude),
                     W = g.Min(log => log.Longitude),
                     E = g.Max(log => log.Longitude)
                 };
  return logs.Single();

var logs=来自dc.Assets中的资产
其中asset.AssetId==AssetId
设g=asset.AssetLogs
.Where（log=>log.Recorded>=start&&log.Recorded log.Latitude），
S=g.Min（对数=>log.Latitude），
W=g.Min（log=>log.Longitude），
E=g.Max（log=>log.Longitude）
};
返回logs.Single（）；

Group By的性能可能比上述查询生成的联接更好：

  var logs = from log in dc.AssetLogs
             where log.AssetId == assetId &&
                 log.Recorded >= start && log.Recorded <= finish
             group log by log.AssetId into g
             select new GetInteractionBoundsResult
                 {
                     N = g.Max(log => log.Latitude),
                     S = g.Min(log => log.Latitude),
                     W = g.Min(log => log.Longitude),
                     E = g.Max(log => log.Longitude)
                 };
  return logs.Single();

var logs=来自dc.AssetLogs中的日志
其中log.AssetId==AssetId&&
log.Recorded>=开始和&log.Recorded log.Latitude），
S=g.Min（对数=>log.Latitude），
W=g.Min（log=>log.Longitude），
E=g.Max（log=>log.Longitude）
};
返回logs.Single（）；

这需要一个非常复杂的LINQ提供程序，但子查询可能会起作用：

  var res = from asset in dc.Assets
            where log.AssetId == assetId 
            let logs = (from AssetLog log in asset.AssetLogs
                        where log.Recorded >= start && log.Recorded <= finish
                        select log)
            select new GetInteractionBoundsResult()
            {
              N = logs.Max(log => log.Latitude),
              S = logs.Min(log => log.Latitude),
              W = logs.Min(log => log.Longitude),
              E = logs.Max(log => log.Longitude)
            };
  return res.Single();

var res=来自dc.Assets中的资产
其中log.AssetId==AssetId
让日志=（来自asset.AssetLogs中的AssetLog日志
其中log.Recorded>=开始和&log.Recorded log.Latitude），
S=logs.Min（log=>log.Latitude），
W=logs.Min（log=>log.Longitude），
E=logs.Max（log=>log.Longitude）
};
返回res.Single（）；

这需要一个非常复杂的LINQ提供程序，但子查询可能会起作用：

  var res = from asset in dc.Assets
            where log.AssetId == assetId 
            let logs = (from AssetLog log in asset.AssetLogs
                        where log.Recorded >= start && log.Recorded <= finish
                        select log)
            select new GetInteractionBoundsResult()
            {
              N = logs.Max(log => log.Latitude),
              S = logs.Min(log => log.Latitude),
              W = logs.Min(log => log.Longitude),
              E = logs.Max(log => log.Longitude)
            };
  return res.Single();

var res=来自dc.Assets中的资产
其中log.AssetId==AssetId
让日志=（来自asset.AssetLogs中的AssetLog日志
其中log.Recorded>=开始和&log.Recorded log.Latitude），
S=logs.Min（log=>log.Latitude），
W=logs.Min（log=>log.Longitude），
E=logs.Max（log=>log.Longitude）
};
返回res.Single（）；

@dahlbyk:有一些输入错误，对不起。@dahlbyk:有一些输入错误，对不起。它是一个非常复杂的提供程序：Linq2Sql。也谢谢你。groupby是我一直在想的，它是一个非常复杂的提供者：Linq2Sql。也谢谢你。groupby就是我一直在想的。