LINQ .Qualquer VS .Exists - Qual a diferença?

Usando o LINQ em coleções, qual é a diferença entre as seguintes linhas de código?

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

e

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

Atualização 1

Quando desmonte .Exists, parece que não há código.

Atualização 2

Alguém sabe por que não existe um código para este?

Ver documentação

List.Exists (método de objeto - MSDN)

Determina se a Lista (T) contém elementos que correspondem às condições definidas pelo predicado especificado.

Isso existe desde o .NET 2.0, portanto, antes do LINQ. Era para ser usado com o delegado do Predicado , mas as expressões lambda são compatíveis com versões anteriores. Além disso, apenas a List possui isso (nem mesmo o IList)

IEnumerable.Any (método de extensão - MSDN)

Determina se algum elemento de uma sequência satisfaz uma condição.

Isso é novo no .NET 3.5 e usa Func (TSource, bool) como argumento; portanto, ele deveria ser usado com expressões lambda e LINQ.

No comportamento, estes são idênticos.

A diferença é que Any é um método de extensão para qualquer IEnumerable<T>definido em System.Linq.Enumerable. Pode ser usado em qualquer IEnumerable<T>instância.

Existe não parece ser um método de extensão. Meu palpite é que coll é do tipo List<T>. Se houver, existe um método de instância que funciona muito semelhante a Qualquer.

Em suma , os métodos são essencialmente os mesmos. Um é mais geral que o outro.

• Qualquer um também tem uma sobrecarga que não aceita parâmetros e simplesmente procura por qualquer item no enumerável.
• Existe não existe essa sobrecarga.

TLDR; O desempenho Anyparece mais lento (se eu tiver configurado isso corretamente para avaliar os dois valores quase ao mesmo tempo)

        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"))
            {

            }

gerador de lista de testes:

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;
    }

Com 10 milhões de registros

"Qualquer: 00: 00: 00.3770377 Existe: 00: 00: 00.2490249"

Com registros de 5 milhões

"Qualquer: 00: 00: 00.0940094 Existe: 00: 00: 00.1420142"

Com 1 milhão de registros

"Qualquer: 00: 00: 00.0180018 Existe: 00: 00: 00.0090009"

Com 500k, (também inverti a ordem na qual eles são avaliados para ver se não há nenhuma operação adicional associada ao que ocorrer primeiro).

"Existe: 00: 00: 00.0050005 Qualquer: 00: 00: 00.0100010"

Com 100 mil registros

"Existe: 00: 00: 00.0010001 Qualquer: 00: 00: 00.0020002"

Parece Anyser mais lento pela magnitude de 2.

Edit: Para registros de 5 e 10 milhões, mudei a maneira como gera a lista e, de Existsrepente, fiquei mais lento do que o Anyque implica que há algo errado na maneira como estou testando.

Novo mecanismo de teste:

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, para eliminar qualquer influência da geração de dados de teste, escrevi tudo para arquivar e agora li a partir daí.

 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"))
            {
            }
        }
    }

10 milhões

"Qualquer: 00: 00: 00.1640164 Existe: 00: 00: 00.0750075"

5M

"Qualquer: 00: 00: 00.0810081 Existe: 00: 00: 00.0360036"

1 milhão

"Qualquer: 00: 00: 00.0190019 Existe: 00: 00: 00.0070007"

500k

"Qualquer: 00: 00: 00.0120012 Existe: 00: 00: 00.0040004"

Como continuação da resposta de Matas sobre benchmarking.

TL / DR : existe () e Qualquer () são igualmente rápidos.

Primeiro: o benchmarking usando o cronômetro não é preciso ( consulte a resposta da série0ne sobre um tópico diferente, mas semelhante ), mas é muito mais preciso que o DateTime.

A maneira de obter leituras realmente precisas é usando o Performance Profiling. Mas uma maneira de ter uma noção de como medir o desempenho dos dois métodos-se uns aos outros é através da execução de ambos os métodos cargas de vezes e, em seguida, comparando o tempo de execução mais rápida de cada um. Dessa forma, realmente não importa que o JIT e outros ruídos nos proporcionem leituras ruins (e o fazem ), porque ambas as execuções são " igualmente equivocadas " em certo sentido.

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;
    }

Depois de executar o código acima 4 vezes (que por sua vez faz 1 000 Exists()e Any()em uma lista com 1 000 000 elementos), não é difícil ver que os métodos são praticamente igualmente rápidos.

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

Não é uma pequena diferença, mas é diferença que um pequeno demais para não ser explicado pelo ruído de fundo. Meu palpite seria que, se um faria 10 000 ou 100 000 Exists()e Any()em vez disso, que leve diferença desapareceria mais ou menos.

Além disso, isso só funcionará se Valor for do tipo bool. Normalmente, isso é usado com predicados. Qualquer predicado geralmente seria usado para descobrir se existe algum elemento que satisfaça uma determinada condição. Aqui você está apenas fazendo um mapa do seu elemento i para uma propriedade bool. Ele procurará um "i" cuja propriedade Value seja verdadeira. Uma vez feito, o método retornará verdadeiro.

Quando você corrige as medidas - como mencionado acima: Qualquer e Existe, e adicionando média -, obteremos a seguinte saída:

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.