1

我正在从单个视图查询以检索指标列表。可以从该单个视图中检索指标的所有属性。

这是代码：

data = new DataContext();

var core = from item in data.Items
           where countryIDs.Contains(item.CountryId)
           && indicatorIDs.Contains(item.IndicatorId)
           orderby item.Indicator
           select item;

var x = from item in core.Distinct()
        group item by new { item.IndicatorId, item.Indicator }
            into indicator
            select new
            {
                IndicatorID = indicator.Key.IndicatorId,
                IndicatorDescription = indicator.Key.Indicator,
                Genders = from g in core
                          where g.Gender != null
                          && g.IndicatorId == indicator.Key.IndicatorId
                          select new Gender
                          {
                              GenderID = g.GenderId,
                              GenderDescription = g.Gender
                          },
                HasGender = (from g in core
                             where g.Gender != null
                             && g.IndicatorId == indicator.Key.IndicatorId
                             select g.GenderId).Count() > 0,
                AreaTypes = from rat in core
                                     where rat.IndicatorId == indicator.Key.IndicatorId
                                     && rat.AreaType != null
                                     select new AreaType
                                     {
                                         AreaTypeId = rat.AreaTypeId,
                                         AreaDescription = rat.AreaType
                                     },
                HasAreaType = (from rat in core
                                        where rat.IndicatorId == indicator.Key.IndicatorId
                                        && rat.AreaType != null
                                        select rat.AreaTypeId).Count() > 0,
                Sectors = from s in core
                          where s.IndicatorId == indicator.Key.IndicatorId
                          && s.Sector != null
                          select new Sector
                          {
                              SectorID = s.SectorId,
                              Title = s.Sector
                          },
                HasSector = (from s in core
                             where s.IndicatorId == indicator.Key.IndicatorId
                             && s.Sector != null
                             select s.SectorId).Count() > 0
            };

List<Indicator> indicators = new List<Indicator>();
Indicator i = new Indicator();
foreach (var item in x)
{
    i = new Indicator()
    {
        IndicatorID = item.IndicatorID,
        IndicatorDescription = item.IndicatorDescription,
        Genders = item.Genders.ToList(),
        AreaTypes = item.AreaTypes.ToList(),
        Sectors = item.Sectors.ToList(),
        HasGender = item.HasGender,
        HasAreaType = item.HasAreaType,
        HasSector = item.HasSector
    };
    indicators.Add(i);
}
return indicators;

当它到达 foreach 循环时，当 x 被转换时，它会减慢。有没有办法让这个查询更快地转换为列表？谢谢你。

4

3 回答 3

4

看起来你正在做很多不必要的嵌套查询。

您的core查询在返回项目之前进行了一些相对昂贵的过滤和排序。最好只执行一次此查询。

但是，您在此查询上执行了六个不必要的连接。

Genders例如，您的查询正在重新查询一个仅保留与您已经分组core的项目相同的项目！IndicatorId如果我可以假设这item.Indicator是一对一的，item.IndicatorId那么您的组indicator已经包含此子集。

您正在以相同的方式查询AreaTypes& Sectors。

现在HasGender, HasAreaType, & HasSectoreach中的每一个都重复上述查询并对.Count()它们中的每一个强制执行 a 以检查值是否大于零。这是一种浪费，因为它.Any()会以更便宜的方式为您检查至少一个值。

core现在为了测试查询被访问了多少次，我创建了这个测试代码：

var countryIDs = Enumerable.Range(0, 100).ToArray();
var indicatorIDs = Enumerable.Range(0, 100).ToArray();

data.Items.AddRange(
    Enumerable
        .Range(0, 100)
        .Select(n =>
            new Item()
            {
                CountryId = n,
                IndicatorId = n,
                Indicator = "Indicator",
                GenderId = n,
                Gender = "Gender",
                AreaTypeId = n,
                AreaType = "Area",
                SectorId = n,
                Sector = "Sector",
            }));

我修改core为如下所示：

var counter = 0;
var core =
    (from item in data.Items
    where countryIDs.Contains(item.CountryId)
        && indicatorIDs.Contains(item.IndicatorId)
    orderby item.Indicator
    select item).Do(_ => counter++);

操作员来自DoReactive ExtensionsSystem.Interactive程序集。

运行您的代码，我得到以下结果：

counter == 60100

由于我在集合中放置了 100 个项目，这告诉我您的查询正在调用core601 次的新执行！

这可以core很容易地更改为执行一次。

首先，我修改core为如下所示：

var query =
    from item in data.Items
    where countryIDs.Contains(item.CountryId)
        && indicatorIDs.Contains(item.IndicatorId)
    orderby item.Indicator
    select item;

var core = query.ToArray();

将.ToArray()查询结果带入内存。

然后将x查询修改为如下所示：

var x =
    from item in core.Distinct()
    group item by new
    {
        item.IndicatorId,
        item.Indicator
    } into indicator
    let Genders = (
        from g in indicator
        where g.Gender != null
        select new Gender
        {
            GenderID = g.GenderId,
            GenderDescription = g.Gender,
        }).ToList()
    let AreaTypes = (
        from rat in indicator
        where rat.AreaType != null
        select new AreaType
        {
            AreaTypeId = rat.AreaTypeId,
            AreaDescription = rat.AreaType,
        }).ToList()
    let Sectors = (
        from s in indicator
        where s.Sector != null
        select new Sector
        {
            SectorID = s.SectorId,
            Title = s.Sector,
        }).ToList()
    select new Indicator()
    {
        IndicatorID = indicator.Key.IndicatorId,
        IndicatorDescription = indicator.Key.Indicator,
        Genders = Genders,
        AreaTypes = AreaTypes,
        Sectors = Sectors,
        HasGender = Genders.Any(),
        HasAreaType = AreaTypes.Any(),
        HasSector = Sectors.Any(),
    };

请注意，我只计算每个Genders, AreaTypes, &Sectors一次并将每个创建为一个列表。这使我可以更改x以立即生成Indicator.

现在列表的最终创建indicators很简单：

var indicators = x.ToList();

当我在这个方法上使用我的样本数据时，我的结果是这样的：

counter == 100

这意味着该查询仅命中原始core查询一次！

然后，当我将原始样本数据增加到 1,000 个项目时，我检查了嵌套的行为方式——我使用新代码获得了一次点击，使用原始代码获得了 6,001 次点击——而且速度要慢得多。

请记住，LINQ 是延迟计算的，因此执行不会发生在您定义查询的位置，而是执行它的位置。

所以这里的建议是，在内存允许的情况下，您应该尽快执行查询以将数据放入内存，然后执行一次且仅一次的计算。

于 2012-06-26T07:43:01.350 回答
0

对于初学者，将每个 Count() > 0 更改为 Any() 方法，Count 将强制对您正在查询的表进行全面扫描。

如果这没有给您想要的性能提升，请尝试重写您的查询。如果您首先将数据投影到匿名类型中，然后按该匿名类型分组，我认为性能会更高。

于 2012-06-26T06:07:04.203 回答
0

您的查询中有一些 where 子句（例如 where s.IndicatorId == indicator.Key.IndicatorId）

尝试在此处使用 Join Syntax，这将使其更快。即您的情况下的核心连接指标。就像是

你的版本

from g in core 
where g.Gender != null && g.IndicatorId == indicator.Key.IndicatorId

会得到这样的东西

From g In core Join indi In indicator 
on g.IndicatorId Equals indi.Key.IndicatorId

为什么 LINQ JOIN 比使用 WHERE 链接快得多？

于 2012-06-26T06:09:49.700 回答