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

我有一个实体列表，其中包含我循环浏览的约137000条记录 然后我需要linq到一个包含~150000个额外参数的元组列表

为什么它持续花费的时间越长，迭代次数越多？ 这是秒表上的 找到：136770个符合条件的项目

处理的10000项EllapsedTime:5473即：0.09121667分钟

处理20000项EllapsedTime:15307即：0.2551166667分钟

30000件已处理邮件时间：30065即：0.501083333分钟

50000件物品处理时间：74507即：1.24178333分钟

75000件物品处理时间：157836即：2.6306分钟

100000件物品处理时间：272495即：4.5415833333333分钟

EllapsedTime:499663也就是说：8.3277166667分钟

有什么方法可以优化这一点吗

 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;
                }

            }

列表匹配
List lsItems=新列表（）；
IEnumerable enumThingy=lsItems；
for（intz=0；zd.First==a.ID）.First（）；
if（newRepl！=null）
{
}
开关（z）
{
案例10000：
调试.打印（“处理10000个项目”+ElapsedTime（sw.ElapsedMills））；
打破
案例20000：
调试.打印（“已处理20000个项目”+ElapsedTime（sw.ElapsedMilliseconds））；
打破
案例30000：
调试.打印（“处理30000个项目”+ElapsedTime（sw.ElapsedMilliseconds））；
打破
案例50000：
调试.打印（“处理50000个项目”+ElapsedTime（sw.ElapsedMilliseconds））；
打破
案例75000：
调试.打印（“处理75000个项目”+ElapsedTime（sw.ElapsedMilliseconds））；
打破
案例100000：
调试.打印（“已处理100000个项目”+ElapsedTime（sw.ElapsedMills））；
打破
}
}

问候

_Eric看看下面的代码：

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

for（intz=0；zd.First==a.ID）.First（）；

在本例中（我怀疑您的“真实”案例），

enumThingy

和

alMatched

枚举表的顺序相同

因此，在案例1中，对

enumThingy.Where

的调用在第一次迭代时返回。在案例100中，需要100次迭代来匹配您的条件，然后退出。在案例10000中，需要10000次迭代

基本上，你走得越远，情况就越糟。您的算法是O（N^2），但LINQ是捷径，因为您使用的是同一个列表，并且排序帮助您“捷径”走出where fast。

查看以下代码：

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

for（intz=0；zd.First==a.ID）.First（）；

在本例中（我怀疑您的“真实”案例），

enumThingy

和

alMatched

枚举表的顺序相同

因此，在案例1中，对

enumThingy.Where

的调用在第一次迭代时返回。在案例100中，需要100次迭代来匹配您的条件，然后退出。在案例10000中，需要10000次迭代

---

基本上，你走得越远，情况就越糟。您的算法是O（N^2），但LINQ是捷径，因为您使用的是同一个列表，并且排序可以帮助您“捷径”走出where fast。

当然。试试字典而不是列表

    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>>();

List lsItems=new List（）；
//应该是
var lsItems=新字典（）；

/参考以下项目：

---

var newRepl=lsItems[a.ID]

当然。试试字典而不是列表

    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>>();

List lsItems=new List（）；
//应该是
var lsItems=新字典（）；

/参考以下项目：

---

var newRepl=lsItems[a.ID]

在这里，您可以使用不同的方法来获得速度增益

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

另一个选项是对枚举项进行排序，同时对alMatched项进行排序，然后使用“滑动aproach”查找您需要的所有项

---

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

您可以使用不同的方法在此处实现速度增益

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

另一个选项是对枚举项进行排序，同时对alMatched项进行排序，然后使用“滑动aproach”查找您需要的所有项

---

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

是的，问题实际上归结为“为什么此O（n^2）算法的行为与O（n^2）相同？”！…；）是的，问题真的可以归结为“为什么这个O（n^2）算法的行为就好像它是O（n^2）”？！…；）是的！谢谢找到：136770个符合条件的项目。处理10000项EllapsedTime:2974即：0.04956667分钟。处理20000件物品时间：5445即：0.09075分钟。30000件物品处理时间：7911即：0.13185分钟。处理50000项EllapsedTime:12883即：0.214716667分钟。处理75000件物品时间：19127即：0.31878333分钟。处理100000件物品EllapsedTime:25280即：0.42133333分钟。EllapsedTime:34449也就是说：0.57415分钟。是的！谢谢找到：136770个符合条件的项目。每次处理10000件物品