Question

我有一个包含~137000条记录的entites列表然后我需要linq到一个包含~150000

的附加参数的元组列表

为什么它会持续更长时间，迭代次数越多？这是来自秒表找到：136770项符合条件的条目。

已处理10,000件物品EllapsedTime：5473即：0.0912166666666667分钟。

处理20,000件物品EllapsedTime：15307即：0.255116666666667分钟。

处理了30,000件物品EllapsedTime：30065即：0.501083333333333分钟。

处理50,000件物品EllapsedTime：74507即：1.24178333333333分钟。

处理了75,000件物品EllapsedTime：157836即：2.6306分钟。

处理100,000件物品EllapsedTime：272495即：4.54158333333333分钟。

EllapsedTime：499663即：8.32771666666667分钟。

有没有办法优化这个？

 List<Entites> alMatched 
List<Tuple<int, double, int, int>> lsItems = new List<Tuple<int, double, int, int>>();
IEnumerable<Tuple<int, double, int, int>> enumThingy = lsItems;

 for (int z = 0; z <= alMatched.Count() - 1;z++ )
            {
               Entity a = alMatched[z];
               var newRepl = enumThingy.Where(d => d.First == a.ID).First();
               if (newRepl != null)
               {

               }

                switch (z)
                {
                    case 10000:
                        Debug.Print("10,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 20000:
                        Debug.Print("20,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 30000:
                        Debug.Print("30,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 50000:
                        Debug.Print("50,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 75000:
                        Debug.Print("75,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 100000:
                        Debug.Print("100,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                }

            }

此致

_Eric

Answer 1

看看这段代码：

for (int z = 0; z <= alMatched.Count() - 1;z++ )
{
    Entity a = alMatched[z];
    var newRepl = enumThingy.Where(d => d.First == a.ID).First();

在这种情况下（我怀疑你的“真实”情况），enumThingy和alMatched枚举都是相同的顺序。

因此，当您处于案例1时，对enumThingy.Where的调用将在第一次迭代时返回。在案例100中，需要100次迭代才能匹配您的条件，然后退出。在案例10000中，它需要10000次迭代。

基本上，你走得越远，这就越糟糕。你的算法是O（N ^ 2），但是LINQ是短切的，因为你使用相同的列表，而且排序正在帮助你快速“快捷”。

Answer 2

不确定。尝试使用词典而不是列表

    List<Tuple<int, double, int, int>> lsItems = new List<Tuple<int, double, int, int>>();

//should be 

var lsItems = new Dictionary<int, Tuple<int, double, int, int>>();

/引用项目：

var newRepl = lsItems [a.ID];

Answer 3

您可以使用不同的方法来获得速度增益。

一种方法是使用哈希表将项目存储在enumThingy中，并通过您要查找的密钥访问它们。

另一种选择是对enumthingee进行排序并对alMatched进行排序，然后使用“滑动方法”查找所需的所有项目。

目前您正在使用枚举，并且必须检查所有项目以找到您需要的项目，因此您的项目所在链中的后期（或完全丢失）将花费越来越多的时间

Linq到对象的处理时间每x次迭代加倍

3 个答案: