生成质数序列，Loop Break与LINQ TakeWhile

如何解决生成质数序列，Loop Break与LINQ TakeWhile

我尝试用C＃生成素数序列。 到目前为止，该代码似乎运行良好。

List<int> _primes = new List<int>();

bool IsPrime(int num)
{
    if (num < 2)
        return false;
    int chkEnd = (int)Math.Sqrt(num);

    foreach (var p in _primes)
    {
        if (p > chkEnd)
            break;
        if (num % p == 0)
            return false;
    }
    return true;
}

for (int i=2; i<1000000; i++)
{
    if (IsPrime(i))
        _primes.Add(i);
}

然后我将IsPrime（）更改为使用LINQ TakeWhile（）， 我认为这两种方法的时间复杂度相同， 但是执行时间明显长于前者。

bool IsPrime(int num)
{
    if (num < 2)
        return false;
    int chkEnd = (int)Math.Sqrt(num);

    foreach (var p in _primes.TakeWhile(x => x <= chkEnd))
    {
        if (num % p == 0)
            return false;
    }
    return true;
}

或

bool IsPrime(int num)
{
    if (num < 2)
        return false;
    int chkEnd = (int)Math.Sqrt(num);

    return _primes.TakeWhile(x => x <= chkEnd).All(p => num % p != 0);
}

有人有什么主意吗？

---

编辑： 我将循环迭代次数增加到5000000，在consoleApplication中运行代码并输出执行时间

00：00：01.1841593-IsPrime_PureLoopBreak

00：00：03.2560654-IsPrime_TakeWhileAndLoop

00：00：03.4178782-IsPrime_TakeWhileAndAll

    static void Main(string[] args)
    {
        List<int> _primes;

        bool IsPrime_PureLoopBreak(int num)
        {
            if (num < 2)
                return false;
            int chkEnd = (int)Math.Sqrt(num);

            foreach (var p in _primes)
            {
                if (p > chkEnd)
                    break;
                if (num % p == 0)
                    return false;
            }
            return true;
        }

        bool IsPrime_TakeWhileAndLoop(int num)
        {
            if (num < 2)
                return false;
            int chkEnd = (int)Math.Sqrt(num);

            foreach (var p in _primes.TakeWhile(x => x <= chkEnd))
            {
                if (num % p == 0)
                    return false;
            }
            return true;
        }

        bool IsPrime_TakeWhileAndAll(int num)
        {
            if (num < 2)
                return false;
            int chkEnd = (int)Math.Sqrt(num);

            return _primes.TakeWhile(x => x <= chkEnd).All(p => num % p != 0);
        }

        var t1 = Measure(() => 
        {
            _primes = new List<int>();
            for (int i = 2; i < 5000000; i++)
            {
                if (IsPrime_PureLoopBreak(i))
                    _primes.Add(i);
            }
        });
        Console.WriteLine($"{t1} -- IsPrime_PureLoopBreak");

        var t2 = Measure(() =>
        {
            _primes = new List<int>();
            for (int i = 2; i < 5000000; i++)
            {
                if (IsPrime_TakeWhileAndLoop(i))
                    _primes.Add(i);
            }
        });
        Console.WriteLine($"{t2} -- IsPrime_TakeWhileAndLoop");

        var t3 = Measure(() =>
        {
            _primes = new List<int>();
            for (int i = 2; i < 5000000; i++)
            {
                if (IsPrime_TakeWhileAndAll(i))
                    _primes.Add(i);
            }
        });
        Console.WriteLine($"{t3} -- IsPrime_TakeWhileAndAll");

        Console.ReadLine();
    }

    public static TimeSpan Measure(Action action)
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        action?.Invoke();
        stopwatch.Stop();
        return stopwatch.Elapsed;
    }

解决方法

考虑编译器将需要生成的代码。像Linq这样的“高级”代码简单易写，但对于编译器而言，优化起来通常更困难。

您以前的示例可以进一步简化为使用普通的for循环而不是foreach。因此，每次迭代都只需要少量指令。

使用linq时，编译器将为迭代器生成一个代理对象。这将需要调用您的lambda以便检查是否需要继续迭代，并且编译器可能无法内联方法调用。方法调用很便宜，但仍然比简单的算术指令贵好几倍。

因此，根据经验，可以使用Linq和其他高级模式来提高可读性。如果发现代码中的某些部分不满足性能目标，请使用探查器准确地确定哪个部分需要花费时间，然后重写该部分，直到足够快或您使它尽可能快为止。 / p>

,

使用LINQ会有一些额外的开销。您正在创建和调用lambda表达式。

但是，请确保在得出结论之前尝试使用Release版本。