1

我有一个在具有 5,00,000 多条记录的数据表上运行的 LINQ 查询。此查询仅返回一行，但运行几乎需要 30 秒。这是我的查询

  var callDetailsForNodes = from records in dtRowForNode.Select().Select(dr =>
    new
    {
        caller1 = StringComparer.CurrentCultureIgnoreCase.Compare(dr["F1"], dr["F2"]) < 0 ? dr["F1"] : dr["F2"],
        caller2 = StringComparer.CurrentCultureIgnoreCase.Compare(dr["F1"], dr["F2"]) < 0 ? dr["F2"] : dr["F1"],
        time = dr["F3"],
        filters = dr.Field<string>("F9")
    }).Where(dr => (dtMin <= Convert.ToDateTime(dr.time)) && (dtMax >= Convert.ToDateTime(dr.time)) && (lstCallType.Contains(dr.filters))
             && (dtMinTime <= Convert.ToDateTime(dr.time).TimeOfDay) && (dtMaxTime >= Convert.ToDateTime(dr.time).TimeOfDay))
    .GroupBy(drg => new { drg.caller1, drg.caller2 })
    .Select(drg => new { drg.Key.caller1, drg.Key.caller2, count = drg.Count() }).AsEnumerable()
                                  where (records.caller1.ToString() == VerSelected || records.caller2.ToString() == VerSelected)
                                  select records;

我再次运行查询以重新排列数据从上面的查询中获取

 var callDetailsForNodes_ReArrange = from records in callDetailsForNodes.Select(r => new
        {
            caller1 = r.caller1.ToString() == VerSelected ? r.caller1 : r.caller2,
            caller2 = r.caller1.ToString() != VerSelected ? r.caller1 : r.caller2,
            count = r.count
        })
        select records;

然后我只是将此集合绑定到gridview。有没有什么有效的方法来查询这么大的数据集

编辑

我尝试逐步调试程序，发现这两个查询实际上运行得很快，并且在我将此查询的结果集添加到 ObservableCollection 以将其绑定到 gridview 的步骤中花费了时间。这是代码

foreach (var callDetailsForNode_ReArrange in callDetailsForNodes_ReArrange)
        {

                _CallForNodes.Add(new CallForNodeData
                {
                    Caller1 = callDetailsForNode_ReArrange.caller1.ToString(),
                    Caller2 = callDetailsForNode_ReArrange.caller2.ToString(),
                    Count = callDetailsForNode_ReArrange.count
                });

        }

这里 callDetailsForNodes_ReArrange 的结果集计数 = 1

4

2 回答 2

0

我已经稍微整理了您的查询（尽管这不会对性能产生很大影响，并且可能存在拼写错误，因为我手头没有 VS）。从您的编辑看来，您对 LINQ 中的延迟执行感到有些困惑。callDetailsForNodes不代表您的结果 - 它是一个查询，一旦执行就会提供您的结果。

如果您必须在过程中进行所有这些查询，我建议您ToList在第一次选择之后添加一个并单独运行它。然后添加ToList到Where子句中。调用ToList将强制执行您的查询，您将看到延迟在哪里。

最后一点 - 您应该将记录直接传递给ObservableCollection构造函数，而不是调用Add每个项目。调用Add将（我认为）导致集合引发更改通知，这对于小列表来说没什么大不了的，但对于较大的列表会减慢速度。

var callDetailsForNodes = dtRowForNode.AsEnumerable()
                              .Select(dr => new {
                                                    caller1 = StringComparer.CurrentCultureIgnoreCase.Compare(dr["F1"], dr["F2"]) < 0 ? dr["F1"] : dr["F2"],
                                                    caller2 = StringComparer.CurrentCultureIgnoreCase.Compare(dr["F1"], dr["F2"]) < 0 ? dr["F2"] : dr["F1"],
                                                    time = Convert.ToDateTime(dr["F3"]),
                                                    filters = dr.Field<string>("F9")})
                              .Where(dr => (dtMin <= dr.time) 
                                        && (dtMax >= dr.time) 
                                        && (lstCallType.Contains(dr.filters))
                                        && (dtMinTime <= dr.time.TimeOfDay) 
                                        && (dtMaxTime >= dr.time.TimeOfDay)
                                        && caller1 == VerSelected || caller2 == VerSelected))
                              .GroupBy(drg => new { drg.caller1, drg.caller2 })
                              .Select(drg => new { drg.Key.caller1, drg.Key.caller2, count = drg.Count());
于 2013-02-07T11:55:09.337 回答
0

有帮助的一件事是将调用之前的 dtMin、dtMax 和 dtMinTime 转换为数据单位 (dr.time)。然后，您可以摆脱在每条记录上多次发生的 Convert.ToDateTime 。

于 2013-02-07T10:50:40.263 回答