C # FindAll VS Wo Geschwindigkeit

FindAll ist offensichtlich langsamer als in Denen, denn es muss eine neue Liste erstellen.

Anyway, ich denke, Sie sollten wirklich Jon Hanna Kommentar - werden Sie wahrscheinlich benötigen, um einige Operationen auf Ihre Ergebnisse und die Liste wäre mehr als nützlich, IEnumerable in vielen Fällen.

Schrieb ich kleine testen, fügen Sie es in der Konsole App-Projekt. Es misst die Zeit/Zecken: Ausführung der Funktion, die Operationen auf die Ergebnisse Sammlung(perf. eine "echte" Nutzung, und sicher sein, dass der compiler nicht optimieren, ungenutzte Daten etc. - Ich bin neu in C# und weiß nicht, wie es funktioniert noch nicht,sorry).

Hinweis: jeder Funktion gemessen werden, außer WhereIENumerable() erzeugt eine neue Liste von Elementen. Könnte ich vielleicht etwas falsch, aber eindeutig zu iterieren IEnumerable braucht viel mehr Zeit als iterierende Liste.

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

namespace Tests
{

    public class Dummy
    {
        public int Val;
        public Dummy(int val)
        {
            Val = val;
        }
    }
    public class WhereOrFindAll
    {
        const int ElCount = 20000000;
        const int FilterVal =1000;
        const int MaxVal = 2000;
        const bool CheckSum = true; //Checks sum of elements in list of resutls
        static List<Dummy> list = new List<Dummy>();
        public delegate void FuncToTest();

        public static long TestTicks(FuncToTest function, string msg)
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            function();
            watch.Stop();
            Console.Write("\r\n"+msg + "\t ticks: " + (watch.ElapsedTicks));
            return watch.ElapsedTicks;
        }
        static void Check(List<Dummy> list)
        {
            if (!CheckSum) return;
            Stopwatch watch = new Stopwatch();
            watch.Start();

            long res=0;
            int count = list.Count;
            for (int i = 0; i < count; i++)     res += list[i].Val;
            for (int i = 0; i < count; i++)     res -= (long)(list[i].Val * 0.3);

            watch.Stop();
            Console.Write("\r\n\nCheck sum: " + res.ToString() + "\t iteration ticks: " + watch.ElapsedTicks);
        }
        static void Check(IEnumerable<Dummy> ieNumerable)
        {
            if (!CheckSum) return;
            Stopwatch watch = new Stopwatch();
            watch.Start();

            IEnumerator<Dummy> ieNumerator = ieNumerable.GetEnumerator();
            long res = 0;
            while (ieNumerator.MoveNext())  res += ieNumerator.Current.Val;
            ieNumerator=ieNumerable.GetEnumerator();
            while (ieNumerator.MoveNext())  res -= (long)(ieNumerator.Current.Val * 0.3);

            watch.Stop();
            Console.Write("\r\n\nCheck sum: " + res.ToString() + "\t iteration ticks :" + watch.ElapsedTicks);
        }
        static void Generate()
        {
            if (list.Count > 0)
                return;
            var rand = new Random();
            for (int i = 0; i < ElCount; i++)
                list.Add(new Dummy(rand.Next(MaxVal)));

        }
        static void For()
        {
            List<Dummy> resList = new List<Dummy>();
            int count = list.Count;
            for (int i = 0; i < count; i++)
            {
                if (list[i].Val < FilterVal)
                    resList.Add(list[i]);
            }      
            Check(resList);
        }
        static void Foreach()
        {
            List<Dummy> resList = new List<Dummy>();
            int count = list.Count;
            foreach (Dummy dummy in list)
            {
                if (dummy.Val < FilterVal)
                    resList.Add(dummy);
            }
            Check(resList);
        }
        static void WhereToList()
        {
            List<Dummy> resList = list.Where(x => x.Val < FilterVal).ToList<Dummy>();
            Check(resList);
        }
        static void WhereIEnumerable()
        {
            Stopwatch watch = new Stopwatch();
            IEnumerable<Dummy> iEnumerable = list.Where(x => x.Val < FilterVal);
            Check(iEnumerable);
        }
        static void FindAll()
        {
            List<Dummy> resList = list.FindAll(x => x.Val < FilterVal);
            Check(resList);
        }
        public static void Run()
        {
            Generate();
            long[] ticks = { 0, 0, 0, 0, 0 };
            for (int i = 0; i < 10; i++)
            {
                ticks[0] += TestTicks(For, "For \t\t");
                ticks[1] += TestTicks(Foreach, "Foreach \t");
                ticks[2] += TestTicks(WhereToList, "Where to list \t");
                ticks[3] += TestTicks(WhereIEnumerable, "Where Ienum \t");
                ticks[4] += TestTicks(FindAll, "FindAll \t");
                Console.Write("\r\n---------------");
            }
            for (int i = 0; i < 5; i++)
                Console.Write("\r\n"+ticks[i].ToString());
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            WhereOrFindAll.Run();
            Console.Read();
        }
    }
}

Ergebnisse(Zecken) - Prüfsumme aktiviert(einige Operationen auf Ergebnisse), Modus: release ohne Debuggen(STRG+F5):

• 16222276 (- >Liste)
• 17151121 (foreach -> Liste)
• 4741494 (wo ->Liste)
• 27122285 (wo ->ienum)
• 18821571 (findall ->Liste)

Prüfsumme deaktiviert (nicht mit der zurückgegebenen Liste):

• 10885004 (- >Liste)
• 11221888 (foreach ->Liste)
• 18688433 (wo ->Liste)
• 1075 (wo ->ienum)
• 13720243 (findall ->Liste)

Können die Ergebnisse etwas unterschiedlich, um echte Ergebnisse Sie brauchen mehr Iterationen.

InformationsquelleAutor der Antwort Wiory

.FindAll() schneller sein soll, dauert es von Vorteil schon zu wissen, das Liste die Größe und die Schleife durch das interne array mit einem einfachen for Schleife. .Where() hat, um Feuer auf einen enumerator (versiegelt framework-Klasse genannt WhereIterator in diesem Fall) und die gleiche Arbeit in einer weniger spezifischen Weise.

Beachten Sie aber, dass .Wo() Durchlaufen, die nicht aktiv in der Schaffung einer Liste im Speicher und Befüllen. Es ist mehr wie ein Strom, so dass die Speichernutzung auf etwas sehr großes kann einen signifikanten Unterschied. Auch könnten Sie beginnen mit der Ergebnisse in einer parallel-Mode sehr viel schneller mit dort .Wo ( - ) Ansatz in 4.0.

InformationsquelleAutor der Antwort Nick Craver