5

工作中出现了一个讨论：

我们有一个具有 IList 的类。Fact 是一个抽象基类，有几个具体的子类（PopulationFact、GdpFact 等）。

最初我们会以这种方式查询给定的事实，即按类型：

.Facts.FirstOrDefault(x => x.Year == 2011 && x is GdpFact)

然而，现在提出了一个问题，我们是否应该引入一个 FactType 枚举来代替

.Facts.FirstOrDefault(x => x.Year == 2011 && x.FactType == FactType.Gdp)

提出这个建议是因为它应该更快。我承认我没有编写任何测试来尝试辨别性能差异，但我有两个问题：

1）像这样的“查询类型”本质上是不好的吗？
2) 考虑到事实是强类型的，添加 FactType 枚举不是多余的吗？

更新 为了澄清，这是 LINQ to objects 和 GdpFact:Fact。

更新 2 我们使用当前的典型数据（4 个事实）进行了测量，结果如下：

查找枚举：0.29660000000000003 毫秒查找类型：0.24530000000000002 毫秒

所以在这种情况下类型查找更快！我会仔细选择我接受的答案。

4

5 回答 5

3

我做了一个测试，我的 1000000 次迭代的结果大约是

ByCast 166ms
ByType 84ms
ByEnum 98ms

所以这enum实际上是多余的，而且速度较慢，但​​幅度不大。这不应该太令人惊讶，类型系统是 .Net 框架的基础。

测试代码转录如下，为勘误道歉

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

class Program
{
    private enum TypeOfFact
    {
        Gdp,
        Other
    }

    private abstract class Fact
    {
        public virtual int Year { get; set; }
        public abstract TypeOfFact FactType { get; }
    }

    private class GdpFact : Fact
    {
        public override TypeOfFact FactType
        {
            get { return TypeOfFact.Gdp; }
        }
    }

    private class OtherFact : Fact
    {
        public override TypeOfFact FactType
        {
            get { return TypeOfFact.Other; }
        }
    }

    static void Main()
    {
        Ilist<Fact> facts = new List<Fact>
            {
                new GdpFact { Year = 2010 },
                new OtherFact { Year = 2010 },
                new GdpFact { Year = 2009 },
                new OtherFact { Year = 2009 },
                new GdpFact { Year = 2011 },
                new OtherFact { Year = 2011 },
            };

        const int interations = 1000000;

        var funcs = new List<Func<IList<Fact>, Fact>>
            {
                ByList,
                ByType,
                ByEnum
            };

        // Warmup
        foreach (var func in funcs)
        {
           Measure(5, func, facts);
        }

        // Results
        foreach (var result in funcs.Select(f => new
            {
                Description = f.Method.Name,
                Ms = Measure(iterations, f, facts)
            }))
        {
            Console.WriteLine(
                "{0} time = {1}ms",
                result.Description,
                result.Ms);
        }
    }

    private static long Measure(
        int iterations,
        Func<IList<Fact>, Fact> func,
        IList<Fact> facts)
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        for (var i = 0; i < iterations; i++)
        {
            func.Invoke(facts);
        }

        stopwatch.Stop();
        return stopwatch.ElapsedMilliseconds;
    }

    private static Fact ByType(IList<Fact> facts)
    {
        return facts.FirstOrDefault(f =>
            f.Year == 2011 && f is GdpFact);
    }

    private static Fact ByEnum(IList<Fact> facts)
    {
        return facts.FirstOrDefault(f =>
            f.Year == 2011 && f.FactType == TypeOfFact.Gdp);
    }

    private static Fact ByCast(IList<Fact> facts)
    {
        return facts.OfType<GdpFact>()
            .FirstOrDefault(f => f.Year == 2011);
    }
}

这个问题似乎很相关。

于 2012-11-28T17:34:13.467 回答
3

所有类型的性能相关问题都严格取决于具体的应用程序上下文，因此此处提供的答案可能对您的具体案例部分正确/错误。

考虑到这一点：

检查枚举值应该比检查类型更快，因为在第一种情况下，您只需检查相等2整数（枚举值）。

但是这在对象中引入了一个额外的字段，必须跟踪它以具有正确的值（单元测试），在第二种情况下您不需要它，因为它CLR关心正确的类型初始化。

我认为你最好根据相关数据量来分析你的想法，你的应用程序通常会运行，并且会为你提出正确的想法。

于 2012-11-28T16:10:38.623 回答
2

我认为您的原始方法很好。为此目的提供了“is”关键字。MSDN不鼓励使用'is'。使用枚举似乎是过度工程。我们应该尽量保持代码简单。在大多数情况下，代码行数越少越好。

于 2012-11-28T16:27:00.650 回答
2

这可能是寻找问题的解决方案吗？

我认为在基本类型中同时包含具体子类型和枚举可能会混淆您的设计。你可以想象有人后来出现并编写了一个新的具体类，但没有意识到他们也需要添加到枚举中......

除非您发现与性能有关的特定问题，否则我会倾向于优先考虑清晰度。因此，如果您需要不同的具体类（我假设您这样做，因为这是您开始编写它的方式），那么我会坚持使用您的类型而不是移动到枚举。

于 2012-11-28T16:19:24.500 回答
2

检查枚举值可能比运行时类型检查更快，但是......

  1. 这是一种微优化——您不太可能注意到实际场景中的性能差异。

  2. 它使事情变得更复杂，更复杂意味着更容易破裂。
    例如，是什么阻止了您或您的一位同事不小心做这样的事情？

    public class PopulationFact : Fact
{
    public FactType FactType = FactType.GdpFact;  // should be PopulationFact
}

我会坚持类型检查。实际上有一个内置的 LINQ 方法可以为您完成：

.Facts.FirstOrDefault(x => x.Year == 2011).OfType<GdpFact>()
于 2012-11-28T16:41:33.857 回答