C# 如何使用大型集合提高linq性能（代码优先的POCO类）

我想计算一个最佳预订

当我在PL/SQL中执行此操作时，速度非常慢，成本也非常高。所以我尝试使用LINQ。我有两个系列，订单和库存。但是它也很慢。对我来说还不够快

我不能使用编译后的查询。我不能使用数据字典索引（我不使用唯一数据）

aspallel（）

不起作用（至少对我来说不是）

如何提高代码的性能

var orders = deserialize<Order>(@"C:\orders.bin");
  var stocks = deserialize<Stock>(@"C:\Stocks.bin");
for (int i = 0; i < 1000; i++)
{

  var order1 = (from p in orders
                where p.QTY_DEMAND > 0
                group p by new { p.OUTER_GROUP_ID, p.ORG_CODE, p.ARTICLE_CODE, p.FROM_ACCOUNTNO, p.AVAILABILITY_STATE } into g
                select new
                {
                    OUTER_GROUP_ID = g.Key.OUTER_GROUP_ID,
                    ORG_CODE = g.Key.ORG_CODE,
                    Article_code = g.Key.ARTICLE_CODE,
                    FROM_ACCOUNTNO = g.Key.FROM_ACCOUNTNO,
                    AVAILABILITY_STATE = g.Key.AVAILABILITY_STATE,
                    QUANTITY = g.Sum(p => p.QTY_DEMAND)
                });
  var order2 = from p in order1
                join vw1 in stocks on new { org_code = p.ORG_CODE, article_code = p.Article_code, account_no = p.FROM_ACCOUNTNO, av_state = p.AVAILABILITY_STATE }
                equals new { org_code = vw1.ORG_CODE, article_code = vw1.ARTICLE_CODE, account_no = vw1.ACCOUNTNO, av_state = vw1.AVAILABILITY_STATE }
                where vw1.QTY_STOCK > 0
                group new { p, o = vw1 } by new { baseValue, vw1.LOCATION_TYPE, vw1.PLACE_TYPE, p.Article_code, p.QUANTITY, vw1.STANDS_ON_THM } into g
                let SumQTY_STOCK = g.Sum(o => o.o.QTY_STOCK)
                select new
                {
                    BASE_VALUE = g.Key.baseValue,
                    g.Key.Article_code,
                    ...
                }
   var order3 = from p in order2
                group p by new { p.BASE_VALUE, p.LOCATION_TYPE, p.PLACE_TYPE } into g
                select new
                {
                    ...
                }
   var order4 = from a in order3
                ...
   foreach (var item in order4)
   {
       //doing somethings
   }
}

public List<T> deserialize<T>(string path)
        {
            using (var file = File.OpenRead(path))
            {
                BinaryFormatter ser = new BinaryFormatter();
                return (List<T>)ser.Deserialize(file);
            }
        }

var orders=反序列化（@“C:\orders.bin”）；
var stocks=反序列化（@“C:\stocks.bin”）；
对于（int i=0；i<1000；i++）
{
var order1=（从订单中的p开始）
其中p.QTY\U需求>0
按新的{p.OUTER_group_ID，p.ORG_CODE，p.ARTICLE_CODE，p.FROM_ACCOUNTNO，p.AVAILABILITY_STATE}将p分组到g中
选择新的
{
外部组ID=g.Key.OUTER组ID，
组织代码=g.Key.ORG代码，
Article_code=g.Key.Article_code，
FROM_ACCOUNTNO=g.Key.FROM_ACCOUNTNO，
可用性状态=g.Key.AVAILABILITY状态，
数量=总金额（p=>p.QTY\U需求）
});
var order2=从p到order1
在新的{org_code=p.org_code，article_code=p.article_code，account_no=p.FROM_ACCOUNTNO，av_state=p.AVAILABILITY_state}
等于新{org_code=vw1.org_code，article_code=vw1.article_code，account_no=vw1.ACCOUNTNO，av_state=vw1.AVAILABILITY_state}
其中vw1.QTY\U库存>0
将新的{p，o=vw1}按新的{baseValue，vw1.LOCATION_TYPE，vw1.PLACE_TYPE，p.Article_code，p.QUANTITY，vw1.STANDS_ON_THM}分组到g中
让总数量=总数量（o=>o.o.QTY\U库存）
选择新的
{
基本值=g.Key.baseValue，
g、 Key.Article_代码，
...
}
var order3=从p到order2
按新的{p.BASE_值，p.LOCATION_类型，p.PLACE_类型}将p分组到g中
选择新的
{
...
}
var order4=来自订单3中的
...
foreach（order4中的var项）
{
//做事
}
}
公共列表反序列化（字符串路径）
{
使用（var file=file.OpenRead（path））
{
BinaryFormatter ser=新的BinaryFormatter（）；
返回（列表）序列反序列化（文件）；
}
}

对于初学者

将对象初始值设定项移出循环。您不需要加载集合1000次

改变

for (int i = 0; i < 1000; i++)
{
   var orders = deserialize<Order>(@"C:\orders.bin");
   var stocks = deserialize<Stock>(@"C:\Stocks.bin");

for（int i=0；i<1000；i++）
{
var orders=反序列化（@“C:\orders.bin”）；
var stocks=反序列化（@“C:\stocks.bin”）；

到

var orders=反序列化（@“C:\orders.bin”）；
var stocks=反序列化（@“C:\stocks.bin”）；
对于（int i=0；i<1000；++i）
{
...

---

我之所以认识到这一点，是因为每次都要加载相同的文件，这很昂贵。每次只需加载一次。

问题不在于查询本身，而在于您执行了1000次。您说您尝试过LINQ和PL/SQL，但都很慢。我想您应该量化“慢”的程度是针对您的情况，以及您希望看到的性能类型。此外，您需要注意您在这里处理的数据量，因为这将改变最佳答案。为什么要在for循环中执行此操作（如Servy所述）我必须执行很多次。因为我想要最佳保留。请分析代码。然后告诉我们哪些部分对优化实际有意义。@Ademsis-您可以发布用于反序列化的代码吗？如果您在>1个CPU上运行，您还应该能够通过使用

并行。for

而不是

for

获得一些性能增益。如果这些对象延迟执行（如果它们返回

IEnumerable

或

IQueryable

，这是非常合理的），那么这不会改变任何事情。@Servy、我的答案或Eric的注释？将加载移出循环肯定会改变很多。除非反序列化（）..在内部缓存它，并在每次重复调用时返回访问器，我对此表示怀疑。@Ryios我指的是您的答案。如果延迟执行，将调用移出循环将不会有任何作用。每次迭代它时，它仍然会做所有的工作。谢谢Ryios，但很抱歉我在论坛中写错了它。已经这样做了。

var orders = deserialize<Order>(@"C:\orders.bin");
var stocks = deserialize<Stock>(@"C:\Stocks.bin");
for (int i = 0; i < 1000; ++i)
{
    ...