LINQ .Any VS .Exists - Quelle est la différence?

En utilisant LINQ sur des collections, quelle est la différence entre les lignes de code suivantes?

if(!coll.Any(i => i.Value))

et

if(!coll.Exists(i => i.Value))

Mise à jour 1

Quand je démonte, .Existsil semble qu'il n'y ait pas de code.

Update 2

Quelqu'un sait pourquoi il n'y a pas de code pour celui-ci?

Voir documentation

List.Exists (méthode Object - MSDN)

Détermine si la liste (T) contient des éléments qui correspondent aux conditions définies par le prédicat spécifié.

Cela existe depuis .NET 2.0, donc avant LINQ. Destiné à être utilisé avec le délégué Predicate , mais les expressions lambda sont rétrocompatibles. Aussi, juste List a ceci (pas même IList)

IEnumerable.Any (méthode d'extension - MSDN)

Détermine si un élément d'une séquence satisfait à une condition.

Ceci est nouveau dans .NET 3.5 et utilise Func (TSource, bool) comme argument, il était donc destiné à être utilisé avec des expressions lambda et LINQ.

En comportement, ceux-ci sont identiques.

La différence est que Any est une méthode d'extension pour tout IEnumerable<T>défini sur System.Linq.Enumerable. Il peut être utilisé sur n'importe quelle IEnumerable<T>instance.

Exists ne semble pas être une méthode d'extension. Je suppose que coll est de type List<T>. Si c'est le cas, Exists est une méthode d'instance qui fonctionne de manière très similaire à Any.

Bref , les méthodes sont essentiellement les mêmes. L'un est plus général que l'autre.

• Any a également une surcharge qui ne prend aucun paramètre et recherche simplement n'importe quel élément dans l'énumérable.
• Existe n'a pas une telle surcharge.

TLDR; Les performances Anysemblent être plus lentes (si j'ai bien configuré cela pour évaluer les deux valeurs presque en même temps)

        var list1 = Generate(1000000);
        var forceListEval = list1.SingleOrDefault(o => o == "0123456789012");
        if (forceListEval != "sdsdf")
        {
            var s = string.Empty;
            var start2 = DateTime.Now;
            if (!list1.Exists(o => o == "0123456789012"))
            {
                var end2 = DateTime.Now;
                s += " Exists: " + end2.Subtract(start2);
            }

            var start1 = DateTime.Now;
            if (!list1.Any(o => o == "0123456789012"))
            {
                var end1 = DateTime.Now;
                s +=" Any: " +end1.Subtract(start1);
            }

            if (!s.Contains("sdfsd"))
            {

            }

générateur de liste de tests:

private List<string> Generate(int count)
    {
        var list = new List<string>();
        for (int i = 0; i < count; i++)
        {
            list.Add( new string(
            Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 13)
                .Select(s =>
                {
                    var cryptoResult = new byte[4];
                    new RNGCryptoServiceProvider().GetBytes(cryptoResult);
                    return s[new Random(BitConverter.ToInt32(cryptoResult, 0)).Next(s.Length)];
                })
                .ToArray())); 
        }

        return list;
    }

Avec 10 millions d'enregistrements

"N'importe lequel: 00: 00: 00.3770377 Existe: 00: 00: 00.2490249"

Avec 5 millions d'enregistrements

"N'importe lequel: 00: 00: 00.0940094 Existe: 00: 00: 00.1420142"

Avec 1 million d'enregistrements

"N'importe lequel: 00: 00: 00.0180018 Existe: 00: 00: 00.0090009"

Avec 500k, (j'ai également inversé l'ordre dans lequel ils sont évalués pour voir s'il n'y a aucune opération supplémentaire associée à celle qui s'exécute en premier.)

"Existe: 00: 00: 00.0050005 N'importe lequel: 00: 00: 00.0100010"

Avec 100 000 enregistrements

"Existe: 00: 00: 00.0010001 N'importe lequel: 00: 00: 00.0020002"

Il semblerait Anyqu'il soit plus lent d'une magnitude de 2.

Edit: Pour les enregistrements de 5 et 10M, j'ai changé la façon dont il génère la liste et je suis Existssoudainement devenu plus lent queAny je suis ce qui implique qu'il y a quelque chose de mal dans la façon dont je teste.

Nouveau mécanisme de test:

private static IEnumerable<string> Generate(int count)
    {
        var cripto = new RNGCryptoServiceProvider();
        Func<string> getString = () => new string(
            Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 13)
                .Select(s =>
                {
                    var cryptoResult = new byte[4];
                    cripto.GetBytes(cryptoResult);
                    return s[new Random(BitConverter.ToInt32(cryptoResult, 0)).Next(s.Length)];
                })
                .ToArray());

        var list = new ConcurrentBag<string>();
        var x = Parallel.For(0, count, o => list.Add(getString()));
        return list;
    }

    private static void Test()
    {
        var list = Generate(10000000);
        var list1 = list.ToList();
        var forceListEval = list1.SingleOrDefault(o => o == "0123456789012");
        if (forceListEval != "sdsdf")
        {
            var s = string.Empty;

            var start1 = DateTime.Now;
            if (!list1.Any(o => o == "0123456789012"))
            {
                var end1 = DateTime.Now;
                s += " Any: " + end1.Subtract(start1);
            }

            var start2 = DateTime.Now;
            if (!list1.Exists(o => o == "0123456789012"))
            {
                var end2 = DateTime.Now;
                s += " Exists: " + end2.Subtract(start2);
            }

            if (!s.Contains("sdfsd"))
            {

            }
        }

Edit2: Ok donc pour éliminer toute influence de la génération de données de test, j'ai tout écrit dans un fichier et maintenant je le lis à partir de là.

 private static void Test()
    {
        var list1 = File.ReadAllLines("test.txt").Take(500000).ToList();
        var forceListEval = list1.SingleOrDefault(o => o == "0123456789012");
        if (forceListEval != "sdsdf")
        {
            var s = string.Empty;
            var start1 = DateTime.Now;
            if (!list1.Any(o => o == "0123456789012"))
            {
                var end1 = DateTime.Now;
                s += " Any: " + end1.Subtract(start1);
            }

            var start2 = DateTime.Now;
            if (!list1.Exists(o => o == "0123456789012"))
            {
                var end2 = DateTime.Now;
                s += " Exists: " + end2.Subtract(start2);
            }

            if (!s.Contains("sdfsd"))
            {
            }
        }
    }

10M

"N'importe lequel: 00: 00: 00.1640164 Existe: 00: 00: 00.0750075"

5M

"N'importe lequel: 00: 00: 00.0810081 Existe: 00: 00: 00.0360036"

1M

"Tout: 00: 00: 00.0190019 Existe: 00: 00: 00.0070007"

500k

"N'importe lequel: 00: 00: 00.0120012 Existe: 00: 00: 00.0040004"

Dans la continuité de la réponse de Matas sur l'analyse comparative.

TL / DR : Exists () et Any () sont également rapides.

Tout d'abord: l'analyse comparative à l'aide du chronomètre n'est pas précise ( voir la réponse de series0ne sur un sujet différent, mais similaire) ), mais elle est beaucoup plus précise que DateTime.

La façon d'obtenir des lectures vraiment précises est d'utiliser le profilage des performances. Mais une façon de se faire une idée de la façon dont les performances des deux méthodes se mesurent est d'exécuter des charges de temps des deux méthodes , puis de comparer le temps d'exécution le plus rapide de chacune. De cette façon, peu importe que le JIT et d'autres bruits nous donnent de mauvaises lectures (et c'est le cas ), parce que les deux exécutions sont " également erronées " dans un sens.

static void Main(string[] args)
    {
        Console.WriteLine("Generating list...");
        List<string> list = GenerateTestList(1000000);
        var s = string.Empty;

        Stopwatch sw;
        Stopwatch sw2;
        List<long> existsTimes = new List<long>();
        List<long> anyTimes = new List<long>();

        Console.WriteLine("Executing...");
        for (int j = 0; j < 1000; j++)
        {
            sw = Stopwatch.StartNew();
            if (!list.Exists(o => o == "0123456789012"))
            {
                sw.Stop();
                existsTimes.Add(sw.ElapsedTicks);
            }
        }

        for (int j = 0; j < 1000; j++)
        {
            sw2 = Stopwatch.StartNew();
            if (!list.Exists(o => o == "0123456789012"))
            {
                sw2.Stop();
                anyTimes.Add(sw2.ElapsedTicks);
            }
        }

        long existsFastest = existsTimes.Min();
        long anyFastest = anyTimes.Min();

        Console.WriteLine(string.Format("Fastest Exists() execution: {0} ticks\nFastest Any() execution: {1} ticks", existsFastest.ToString(), anyFastest.ToString()));
        Console.WriteLine("Benchmark finished. Press any key.");
        Console.ReadKey();
    }

    public static List<string> GenerateTestList(int count)
    {
        var list = new List<string>();
        for (int i = 0; i < count; i++)
        {
            Random r = new Random();
            int it = r.Next(0, 100);
            list.Add(new string('s', it));
        }
        return list;
    }

Après avoir exécuté le code ci-dessus 4 fois (qui à son tour font 1 000 Exists()et Any()sur une liste avec 1 000 000 éléments), il n'est pas difficile de voir que les méthodes sont à peu près aussi rapides.

Fastest Exists() execution: 57881 ticks
Fastest Any() execution: 58272 ticks

Fastest Exists() execution: 58133 ticks
Fastest Any() execution: 58063 ticks

Fastest Exists() execution: 58482 ticks
Fastest Any() execution: 58982 ticks

Fastest Exists() execution: 57121 ticks
Fastest Any() execution: 57317 ticks

Il y a une légère différence, mais c'est une différence trop petite pour ne pas être expliquée par le bruit de fond. Je suppose que si l'on faisait 10 000 ou 100 000 Exists()et à la Any()place, cette légère différence disparaîtrait plus ou moins.

De plus, cela ne fonctionnera que si Value est de type bool. Normalement, cela est utilisé avec des prédicats. Tout prédicat serait généralement utilisé pour trouver s'il existe un élément satisfaisant une condition donnée. Ici, vous faites simplement une carte de votre élément i vers une propriété bool. Il recherchera un «i» dont la propriété Value est vraie. Une fois cela fait, la méthode retournera true.

Lorsque vous corrigez les mesures - comme mentionné ci-dessus: Any et Exists, et en ajoutant la moyenne - nous obtiendrons la sortie suivante:

Executing search Exists() 1000 times ... 
Average Exists(): 35566,023
Fastest Exists() execution: 32226 

Executing search Any() 1000 times ... 
Average Any(): 58852,435
Fastest Any() execution: 52269 ticks

Benchmark finished. Press any key.