3

我有一个大约 7000 个对象的循环，在循环中我需要获取结构列表的不同计数。目前我正在使用 -

foreach (var product in productsToSearch)
{
    Console.WriteLine("Time elapsed: {0} start", stopwatch.Elapsed);
    var cumulativeCount = 0;
    productStore.Add(product);
    var orderLinesList = totalOrderLines
        .Where(myRows => productStore.Contains(myRows.Sku))
        .Select(myRows => new OrderLineStruct
        {
            OrderId = myRows.OrderId,
            Sku = myRows.Sku
        });
    var differences = totalOrderLines.Except(orderLinesList);
    cumulativeCount = totalOrderLinsCount - differences.Select(x => x.OrderId).Distinct().Count();
    cumulativeStoreTable.Rows.Add(product, cumulativeCount);      
    Console.WriteLine("Time elapsed: {0} end", stopwatch.Elapsed);
}

public struct OrderLineStruct
{
    public string OrderId { get; set; }
    public string Sku { get; set; }
}

获取不同计数时，这非常慢。有人知道这样做的更有效方法吗？我曾尝试使用 MoreLinq，它有一个用于 Linq 的 DisctintBy 方法，但它并不高效，因为我已经计时了。我玩过 PLinq，但我有点不确定在哪里并行化这个查询。

因此，循环的每次迭代都在 - 经过的
时间：00:00:37.1142047 开始 经过的
时间：00:00:37.8310148 结束

= 0.7168101 秒 * 7000 = 5017.6707（83.627845 分钟）

它的 Distinct() Count() 行处理时间最长（大约 0.5 秒）。变量差异有几十万个 OrderLineStruct，因此对此进行任何 linq 查询都很慢。

更新

我对循环进行了一些修改，现在它运行了大约 10 分钟而不是超过 1 小时

foreach (var product in productsToSearch)
{
    var cumulativeCount = 0;
    productStore.Add(product);
    var orderLinesList = totalOrderLines
        .Join(productStore, myRows => myRows.Sku, p => p, (myRows, p) => myRows)
        .Select(myRows => new OrderLineStruct
        {
            OrderId = myRows.OrderId,
            Sku = myRows.Sku
        });
    totalOrderLines = totalOrderLines.Except(orderLinesList).ToList();
    cumulativeCount = totalOrderLinesCount - totalOrderLines.Select(x => x.OrderId).Distinct().Count();
    cumulativeStoreTable.Rows.Add(product, cumulativeCount);
}

在 except 上有一个 .ToList() 似乎有所作为，现在我在每次迭代后删除已经处理的订单，这提高了每次迭代的性能。

4

4 回答 4

2

你在错误的地方寻找问题。

和只是 LINQ to Objects具有延迟执行的链式查询方法orderLinesList，differences并且该方法正在执行所有这些方法。differences.Select(x => x.OrderId).Distinct()Count()

您的处理算法非常低效。瓶颈是为每个orderLinesList迭代整个totalOrderLines列表的查询product，并且它被链接（包含）在Except等中Distinct- 再次，在循环内部，即 7000+ 次。

这是 IMO 执行相同操作的示例高效算法：

Console.WriteLine("Time elapsed: {0} start", stopwatch.Elapsed);
var productInfo =
(
    from product in productsToSearch
    join line in totalOrderLines on product equals line.Sku into orderLines
    select new { Product = product, OrderLines = orderLines }
).ToList();
var lastIndexByOrderId = new Dictionary<string, int>();
for (int i = 0; i < productInfo.Count; i++)
{
    foreach (var line in productInfo[i].OrderLines)
        lastIndexByOrderId[line.OrderId] = i; // Last wins
}
int cumulativeCount = 0;
for (int i = 0; i < productInfo.Count; i++)
{
    var product = productInfo[i].Product;
    foreach (var line in productInfo[i].OrderLines)
    {
        int lastIndex;
        if (lastIndexByOrderId.TryGetValue(line.OrderId, out lastIndex) && lastIndex == i)
        {
            cumulativeCount++;
            lastIndexByOrderId.Remove(line.OrderId);
        }
    }
    cumulativeStoreTable.Rows.Add(item.Product, cumulativeCount);
    // Remove the next if it was just to support your processing
    productStore.Add(item.Product);
}
Console.WriteLine("Time elapsed: {0} end", stopwatch.Elapsed);
于 2016-02-23T19:03:09.763 回答
1

在您的情况下，正如 Jon Hanna 所提到的，瓶颈是Except方法。
Distinct并Count具有第二优先权。
您可以通过对方法的每个部分执行枚举并放置秒表来验证这一点。

foreach (var product in productsToSearch)
{
    var cumulativeCount = 0;
    productStore.Add(product);

    olSw.Start();
    var orderLinesList = totalOrderLines
        .Where(myRows => productStore.Contains(myRows.Sku))
        .Select(myRows => new OrderLineStruct
        {
            OrderId = myRows.OrderId,
            Sku = myRows.Sku
        }).ToList();
    olSw.Stop();

    exSw.Start();
    var differences = totalOrderLines.Except(orderLinesList).ToList();
    exSw.Stop();

    dcSw.Start();
    cumulativeCount = totalOrderLinsCount - differences.Select(x => x.OrderId).Distinct().Count();
    dcSw.Stop();
}

测量：
productsToSearchcount 100
totalOrderLinescount300 000

Total olSw time: 00:00:01.3583340
Total exSw time: 00:00:14.3304959
Total dcSw time: 00:00:04.1986018

exSw时间可以通过显式实现GetHashCodeat来减少OrderLineStruct

显式GetHashCode：

Total olSw time: 00:00:01.4045676
Total exSw time: 00:00:08.4691066
Total dcSw time: 00:00:03.9439711

没有冗余枚举的总时间变化：
默认GetHashCode Total time: 00:00:18.9649790
显式GetHashCode Total time: 00:00:12.7736320

更新：
您也可以通过更改方法逻辑来优化它。

例如，您可以HashSet从 totalOrderLines 创建，然后从中删除项目。

var orderLinesList = totalOrderLines
    ... 
    .ToList();

orderLinesList.ForEach(item => totalOrderLines.Remove(item));

cumulativeCount = totalOrderLinsCount - totalOrderLines.Select(x => x.OrderId).Distinct().Count();

就我而言，它将总时间减少到 7 秒。
Total time: 00:00:07.0851111

TotalOrderLines在这种情况下，通过with枚举Dictinct是一个瓶颈，但它需要O(N)时间，这没关系。

于 2016-02-23T17:35:18.793 回答
1

我会建议更改您的 LINQ 查询的这一部分

totalOrderLines.Where(myRows => productStore.Contains(myRows.Sku))

加入一个这样的阅读：

totalOrderLines.Join(productStore, myRows => myRows.Sku, p => p, (myRows, p) => myRows)

这样，您只需支付一次成本，而不是让 Contains 遍历您的产品商店列表 7,000 次，这是非常低效的。此外，如果可以使您的 id 成为整数数据类型（int、long）而不是字符串，那么您也应该有更快的搜索和比较。但我猜你的模型的结构已经设置好了。

于 2016-02-23T17:26:58.570 回答
0

totalOrderLines 来自哪里？一个 MSSQL 数据库可能吗？如果是这样，您必须在 OrderId 列上有一个索引。在此列上执行不带索引的 Distinct() 会强制数据库引擎遍历所有行以识别不同的值。

于 2016-02-23T16:48:45.350 回答