C# 实体框架-子查询结果，速度问题？_C#_Linq_Entity Framework_Subquery

C# 实体框架-子查询结果，速度问题？

c# linq entity-framework

C# 实体框架-子查询结果，速度问题？,c#,linq,entity-framework,subquery,C#,Linq,Entity Framework,Subquery,我已经做了一个查询以获得文章列表，每个文章都绑定到一个“标题”，因此，我检索标题、相关文章及其属性。查询可以工作，但在其当前样式中是有效的有点乱（在我看来） .ToList（）所花的时间比我预期的要长有人看到速度问题的明显原因吗 var offerheaders = from o in dbcontext.F_CAB_OFFER_HEADERS where o.OFHD_FK_BUYER == userinfo.org

我已经做了一个查询以获得文章列表，每个文章都绑定到一个“标题”，因此，我检索标题、相关文章及其属性。查询可以工作，但在其当前样式中是有效的

有点乱（在我看来）
```
.ToList（）
```
所花的时间比我预期的要长

有人看到速度问题的明显原因吗

        var offerheaders = 
        from o in dbcontext.F_CAB_OFFER_HEADERS
        where
        o.OFHD_FK_BUYER == userinfo.orgaTypeSequence
        && o.OFHD_VALID_FROM <= userinfo.selectedDate
        && o.OFHD_VALID_TO >= userinfo.selectedDate
        && o.OFHD_DELETED_YN == 0
        && o.OFHD_DELETED_BY_OWNER_YN == false
        && o.OFHD_OFFER_TYPE == userinfo.offerType
        orderby o.OFHD_NO ascending
        select o;

    var offerlist = 
        from ofhd in offerheaders
        select new {
            ofhd = new {
                OfferNo = ofhd.OFHD_NO,
                OfferSequence = ofhd.OFHD_SEQUENCE,
                ValidFrom = ofhd.OFHD_VALID_FROM,
                ValidTo = ofhd.OFHD_VALID_TO,
                OfferType = ofhd.OFHD_OFFER_TYPE,
                Maingroup = new { cdmg_seq = ofhd.F_CAB_CD_MAIN_GROUP_TYPE.CDMG_SEQUENCE, Desc = ofhd.F_CAB_CD_MAIN_GROUP_TYPE.CDMG_DESC },
                Supplier = new {
                    Name = ofhd.F_CAB_GROWER.F_CAB_ORGANISATION.ORGA_NAME,
                    Pic = ofhd.F_CAB_GROWER.F_CAB_ORGANISATION.ORGA_FK_PICTURE,
                    Seq = ofhd.F_CAB_GROWER.GROW_SEQUENCE
                },
                Caption = ofhd.OFHD_CAPTION,
                Seperate = ofhd.OFHD_SHOW_SEPARATE_YN,
                //ofdts = (from ofdt in dbcontext.F_CAB_OFFER_DETAILS.Where(x => x.OFDT_FK_OFFER_HEADER == ofhd.OFHD_SEQUENCE && x.OFDT_NUM_OF_ITEMS > 0 && x.OFDT_LATEST_DELIVERY_DATE_TIME > compareDateTime && x.OFDT_LATEST_ORDER_DATE_TIME > compareDateTime)
                ofdts = from ofdt in dbcontext.F_CAB_OFFER_DETAILS
                        join props in dbcontext.F_CAB_CAB_PROP on ofdt.OFDT_FK_CAB_CODE equals props.PROP_FK_CABC_SEQ
                        join cabcode in dbcontext.F_CAB_CD_CAB_CODE on ofdt.OFDT_FK_CAB_CODE equals cabcode.CABC_SEQUENCE
                        join cabgroup in dbcontext.F_CAB_CD_CAB_GROUP on cabcode.CABC_FK_CAB_GROUP equals cabgroup.CDGR_SEQUENCE
                        join grouptype in dbcontext.F_CAB_CD_GROUP_TYPE on cabgroup.CDGR_FK_GROUP_TYPE equals grouptype.CDGT_SEQUENCE
                        join maingrouptype in dbcontext.F_CAB_CD_MAIN_GROUP_TYPE on grouptype.CDGT_FK_MAIN_GROUP equals maingrouptype.CDMG_SEQUENCE
                        join caca in dbcontext.F_CAB_CAB_CASK_MATRIX on ofdt.OFDT_FK_CACA_SEQ equals caca.CACA_SEQUENCE
                        join cask in dbcontext.F_CAB_CD_CASK on caca.CACA_FK_CASK equals cask.CDCA_SEQUENCE
                        join vbncode in dbcontext.F_CAB_CAB_VBN_MATRIX on cabcode.CABC_SEQUENCE equals vbncode.CVMA_FK_CAB_CODE
                        join grel in dbcontext.F_CAB_GENERAL_RELATIONS on ofdt.OFDT_FK_GREL_SEQ equals grel.GREL_SEQUENCE into greltable
                            from g_loj in greltable.DefaultIfEmpty()
                        where 
                            ofdt.OFDT_FK_OFFER_HEADER == ofhd.OFHD_SEQUENCE 
                            && ofdt.OFDT_NUM_OF_ITEMS > 0
                            && props.PROP_FK_CDLA_SEQ == userinfo.lang.CDLA_SEQUENCE
                        orderby props.PROP_CAB_DESC ascending
                        select new {
                            Desc = props.PROP_CAB_DESC,
                            Group = new { cdgr_seq = cabgroup.CDGR_SEQUENCE, Desc = cabgroup.CDGR_DESC },
                            Grouptype = new { grouptype.CDGT_SEQUENCE, Desc = grouptype.CDGT_DESC },
                            Properties = new CABProperties { props = props },            
                            Price = ofdt.OFDT_ITEM_PRICE,
                            PIC_SEQ = ofdt.OFDT_FK_PICTURE ?? ((cabcode.CABC_FK_PICTURE ?? cabcode.CABC_SEQUENCE)),
                            PIC_URL = ofdt.OFDT_EXT_PICTURE_REF ?? "",
                            Seq = ofdt.OFDT_SEQUENCE,
                            Available = ofdt.OFDT_NUM_OF_ITEMS,
                            CabCode = ofdt.F_CAB_CD_CAB_CODE.CABC_CAB_CODE,
                            VBNCode = vbncode.CVMA_FK_VBN_CODE,
                            Remark = ofdt.OFDT_REMARK,
                            IsSpecial = ofdt.OFDT_SPECIAL_YN,
                            Arrived = inTransit ? ofdt.OFDT_ARRIVAL_DATE < DateTime.Now : true,
                            Cask = new CABCask { cask = cask, caca = caca },                                            
                            Supplier = g_loj == null ? (ofdt.OFDT_SUPPLIER ?? "") : g_loj.GREL_NAME,
                            SupplierWeb = g_loj == null ? "" : g_loj.GREL_WEBSITE_URL,
                            SupplierLogo = g_loj == null ? ofhd.F_CAB_GROWER.F_CAB_ORGANISATION.ORGA_FK_PICTURE : g_loj.GREL_FK_PICT_SEQ,
                            SupplierSeq = g_loj == null ? -1 : g_loj.GREL_SEQUENCE,
                        }
            }
        };
    userinfo.mainofferlist = offerlist.ToList();

var offerheaders=
从dbcontext.F_CAB_OFFER_头中的o开始
哪里
o、 OFHD\U FK\U买方==userinfo.orgaTypeSequence
&&o.OFHD\u VALID\u FROM=userinfo.selectedDate
&&o.OFHD_已删除_YN==0
&&o.OFHD由所有者删除\u\u YN==false
&&o.OFHD\u OFFER\u TYPE==userinfo.offerType
o.OFHD_的订单号不上升
选择o；
var offerlist=
来自ofhd的报价人
选择新的{
ofhd=新{
OfferNo=ofhd.ofhd\U编号，
OfferSequence=ofhd.ofhd\U序列，
ValidFrom=Ohd.Ohd\u有效期从，
ValidTo=ofhd.ofhd有效期至，
OfferType=ofhd.ofhd\U报价类型，
Maingroup=new{cdmg_seq=ofhd.F_CAB_CD_MAIN_GROUP_TYPE.cdmg_序列，Desc=ofhd.F_CAB_CD_MAIN_GROUP_TYPE.cdmg_Desc}，
供应商=新{
名称=ofhd.F_CAB_种植者.F_CAB_组织.ORGA_名称，
Pic=ofhd.F_CAB_种植者.F_CAB_组织.ORGA_FK_图片，
Seq=ofhd.F\U CAB\U种植者.GROW\U序列
},
字幕=ofhd.ofhd\U字幕，
分离=ofhd.ofhd\u SHOW\u SEPARATE\u YN，
//ofdts=（来自dbcontext.F_CAB_OFFER_DETAILS.Where（x=>x.ofdt_FK_OFFER_HEADER==ofhd.ofhd_序列和&x.ofdt_NUM_OF u ITEMS>0和&x.ofdt_最新交货日期时间>比较时间和x.ofdt_最新订单日期时间>比较时间）
ofdts=来自dbcontext.F\u CAB\u OFFER\u详细信息中的ofdt
在dbcontext.F_CAB_CAB_PROP on ofdt.ofdt_FK_CAB_代码中加入props等于props.PROP_FK_CABC_SEQ
在ofdt上的dbcontext.F_CAB_CD_CAB_代码中加入cabcode。ofdt_FK_CAB_代码等于cabcode.CABC_序列
在cabcode.CABC_FK_CAB_组等于cabgroup.CDGR_序列的dbcontext.F_CAB_CD_CAB_组中加入cabgroup
在dbcontext.F_CAB_CD_GROUP_TYPE在cabgroup.CDGR_FK_GROUP_TYPE等于grouptype.CDGT_序列中加入grouptype
在dbcontext.F_CAB_CD_MAIN_GROUP_TYPE on grouptype.CDGT_FK_MAIN_GROUP等于maingrouptype.CDMG_序列
在ofdt.ofdt_FK_caca_SEQ等于caca.caca_序列的dbcontext.F_CAB_CAB_CASK_矩阵中加入caca
在dbcontext.F_CAB_CD_cask上加入cask。caca_FK_cask等于cask.CDCA_序列
在cabcode上的dbcontext.F_CAB_CAB_VBN_矩阵中联接vbncode.CABC_序列等于vbncode.CVMA_FK_CAB_代码
在ofdt上的dbcontext.F_CAB_GENERAL_关系中将grel连接到greltable中。ofdt_FK_grel_SEQ等于grel.grel_序列
来自greltable.DefaultIfEmpty（）中的g_loj
哪里
ofdt.ofdt_FK_OFFER_头==ofhd.ofhd_序列
&&ofdt.ofdt\u项目数>0
&&props.PROP_FK_CDLA_SEQ==userinfo.lang.CDLA_序列
按道具排序。道具驾驶室描述上升
选择新的{
描述=道具。道具驾驶室描述，
Group=new{cdgr_seq=cabgroup.cdgr_序列，Desc=cabgroup.cdgr_Desc}，
Grouptype=new{Grouptype.CDGT_序列，Desc=Grouptype.CDGT_Desc}，
属性=新属性{props=props}，
价格=ofdt.ofdt\U项目价格，
PIC_SEQ=ofdt.ofdt_FK_图片？？（（cabcode.CABC_FK_图片？？cabcode.CABC_序列）），
PIC\u URL=ofdt.ofdt\u EXT\u PICTURE\u REF，
Seq=ofdt.ofdt_序列，
可用=ofdt.ofdt\u数量\u项，
CabCode=ofdt.F_CAB_CD_CAB_CODE.CABC_CAB_CODE，
VBNCode=VBNCode.CVMA_FK_VBN_代码，
备注=ofdt.ofdt_备注，
IsSpecial=ofdt.ofdt_SPECIAL_YN，
到达=在途？ofdt.ofdt\u到达日期<日期时间。现在：true，
木桶=新木桶{Cask=木桶，caca=caca}，
Supplier=g_loj==null？（ofdt.ofdt_Supplier？？）：g_loj.GREL_名称，
SupplierWeb=g_loj==null？“：g_loj.GREL_网站\u URL，
供应商logo=g_loj==null？of hd.F_CAB_GROWER.F_CAB_organization.ORGA_FK_图片：g_loj.GREL_FK_PICT，
SupplierSeq=g_loj==null？-1:g_loj.GREL_序列，
}
}
};
userinfo.mainofferlist=offerlist.ToList（）；

正如Daniel Kelly提到的，ToList函数是执行查询的地方，因为这些LinqToEntities查询是在第一次枚举时执行的，ToList这样做是为了能够创建一个列表

基本上，查询花费这么多时间的原因可以分为两个不同的原因：

你使用了太多的投影，我使用了新的{ })

您的查询包含数量惊人的join子句

我建议将您的查询分为子查询，并像中的第一部分那样分别运行它们

...
select o

使用

通过分解有很多子查询的主查询，它将更快、更容易阅读

...
select o).ToList()