Uma instrução LINQ é mais rápida que um loop 'foreach'?

Estou escrevendo um gerente de renderização de malha e pensei que seria uma boa ideia agrupar todas as malhas que usam o mesmo sombreador e renderizá-las enquanto estou nesse passe de sombreador.

Atualmente, estou usando um foreachloop, mas me perguntei se a utilização do LINQ poderia me dar um aumento de desempenho?

Por que o LINQ deve ser mais rápido? Ele também usa loops internamente.

Na maioria das vezes, o LINQ é um pouco mais lento porque apresenta sobrecarga. Não use o LINQ se você se preocupa muito com o desempenho. Use o LINQ porque você deseja um código mais curto, de melhor legibilidade e manutenção.

O LINQ-to-Objects geralmente adicionará algumas sobrecargas marginais (vários iteradores, etc.). Ele ainda precisa executar os loops e delegar chamadas, e geralmente precisará fazer uma desreferenciação extra para obter as variáveis ​​capturadas etc. Na maioria dos códigos, isso será virtualmente indetectável e mais do que o código mais simples de entender.

Com outros provedores de LINQ, como o LINQ-to-SQL, então, como a consulta pode filtrar no servidor, ela deve ser muito melhor do que uma apartamento foreach, mas provavelmente você não teria feito uma manta de "select * from foo" qualquer maneira , portanto, isso não é necessariamente justo. comparação.

Re PLINQ; o paralelismo pode reduzir o tempo decorrido , mas o tempo total da CPU geralmente aumenta um pouco devido às despesas gerais do gerenciamento de threads, etc.

Eu acho que o LINQ é melhor usar sobre um foreachloop, porque fornece um código muito mais limpo e fácil de entender. Mas o LINQ é mais lento que foreach. Para obter mais informações, consulte o artigo LINQ vs FOREACH vs FOR Loop Performance .

O LINQ está mais lento agora, mas pode ficar mais rápido em algum momento. A coisa boa sobre o LINQ é que você não precisa se preocupar com como ele funciona. Se um novo método for incrivelmente rápido, as pessoas da Microsoft poderão implementá-lo sem nem mesmo informar a você e seu código seria muito mais rápido.

Mais importante, porém, o LINQ é muito mais fácil de ler. Isso deve ser motivo suficiente.

Provavelmente, deve-se notar que o forloop é mais rápido que o foreach. Portanto, para a postagem original, se você estiver preocupado com o desempenho em um componente crítico como um renderizador, use um forloop.

Referência: no .NET, qual loop é executado mais rapidamente, 'for' ou 'foreach'?

Você pode obter um aumento de desempenho se usar o LINQ paralelo para vários núcleos. Consulte LINQ paralelo (PLINQ) (MSDN).

Eu estava interessado nesta questão, então fiz um teste agora. Usando o .NET Framework 4.5.2 em uma CPU Intel (R) Core i3-2328M a 2,20 GHz, 2200 Mhz, 2 Núcleos com 8 GB de RAM executando o Microsoft Windows 7 Ultimate.

Parece que o LINQ pode ser mais rápido do que para cada loop. Aqui estão os resultados que obtive:

Exists = True
Time   = 174
Exists = True
Time   = 149

Seria interessante se alguns de vocês pudessem copiar e colar esse código em um aplicativo de console e testar também. Antes de testar com um objeto (Employee), tentei o mesmo teste com números inteiros. O LINQ também foi mais rápido lá.

public class Program
{
    public class Employee
    {
        public int id;
        public string name;
        public string lastname;
        public DateTime dateOfBirth;

        public Employee(int id,string name,string lastname,DateTime dateOfBirth)
        {
            this.id = id;
            this.name = name;
            this.lastname = lastname;
            this.dateOfBirth = dateOfBirth;

        }
    }

    public static void Main() => StartObjTest();

    #region object test

    public static void StartObjTest()
    {
        List<Employee> items = new List<Employee>();

        for (int i = 0; i < 10000000; i++)
        {
            items.Add(new Employee(i,"name" + i,"lastname" + i,DateTime.Today));
        }

        Test3(items, items.Count-100);
        Test4(items, items.Count - 100);

        Console.Read();
    }


    public static void Test3(List<Employee> items, int idToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = false;
        foreach (var item in items)
        {
            if (item.id == idToCheck)
            {
                exists = true;
                break;
            }
        }

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    public static void Test4(List<Employee> items, int idToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = items.Exists(e => e.id == idToCheck);

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    #endregion


    #region int test
    public static void StartIntTest()
    {
        List<int> items = new List<int>();

        for (int i = 0; i < 10000000; i++)
        {
            items.Add(i);
        }

        Test1(items, -100);
        Test2(items, -100);

        Console.Read();
    }

    public static void Test1(List<int> items,int itemToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = false;
        foreach (var item in items)
        {
            if (item == itemToCheck)
            {
                exists = true;
                break;
            }
        }

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    public static void Test2(List<int> items, int itemToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = items.Contains(itemToCheck);

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    #endregion

}

Esta é realmente uma questão bastante complexa. O Linq facilita muito algumas coisas, que se você as implementar, poderá tropeçar (por exemplo, linq .Except ()). Isso se aplica particularmente ao PLinq, e especialmente à agregação paralela, conforme implementada pelo PLinq.

Em geral, para código idêntico, o linq será mais lento, devido à sobrecarga da chamada de delegado.

No entanto, se você estiver processando uma grande variedade de dados e aplicando cálculos relativamente simples aos elementos, obterá um enorme aumento de desempenho se:

1. Você usa uma matriz para armazenar os dados.

2. Você usa um loop for para acessar cada elemento (ao contrário de foreach ou linq).

   • Nota: Ao fazer o benchmarking, lembre-se todos - se você usar a mesma matriz / lista por dois testes consecutivos, o cache da CPU tornará o segundo mais rápido. *