El cual es rápido: la sintaxis de consulta vs Loops

Question

El código siguiente proporciona dos enfoques que generan pares de números enteros cuya suma es menor que 100, y que están dispuestos en orden descendente basado en su distancia de (0,0).

    //approach 1
    private static IEnumerable<Tuple<int,int>>  ProduceIndices3()
    {
        var storage = new List<Tuple<int, int>>();
        for (int x = 0; x < 100; x++)
        {
            for (int y = 0; y < 100; y++)
            {
                if (x + y < 100)
                    storage.Add(Tuple.Create(x, y));
            }
        }
        storage.Sort((p1,p2) =>
           (p2.Item1 * p2.Item1 + 
           p2.Item2 * p2.Item2).CompareTo(
           p1.Item1 * p1.Item1 +
           p1.Item2 * p1.Item2));
        return storage;
    }

    //approach 2
    private static IEnumerable<Tuple<int, int>> QueryIndices3()
    {
        return from x in Enumerable.Range(0, 100)
               from y in Enumerable.Range(0, 100)
               where x + y < 100
               orderby (x * x + y * y) descending
               select Tuple.Create(x, y);
    }

Este código está tomado del libro A partir del C # por Bill Wagner, artículo 8. En todo el artículo, el autor se ha centrado más en la sintaxis, la compacidad y la legibilidad del código, pero prestado muy poca atención a la actuación, y casi no hablar de ello.

Así que, básicamente, quiero saber, qué método es más rápido? Y lo que suele ser mejor en el rendimiento (en general):? Sintaxis de consulta o Manual Loops

Por favor, discutirlos en detalle, proporcionando referencias si las hay. : -)

Answer 1

Perfilado es verdad, pero mi primera impresión sería que los bucles son probablemente más rápido. Lo importante es que 99 de cada 100 veces la diferencia de rendimiento no importa en el gran esquema de las cosas. Utilice la versión más fácil o para usted mismo se lo agradecerá cuando se necesita para mantenerla más tarde.

Answer 2

Correr cada función 1000 veces:

bucle for: 2623 ms consulta: 2821 ms

parece lógica ya que el segundo es simplemente azúcar sintáctica para el primero. Pero, lo usaría el segundo para su legibilidad.

Answer 3

A pesar de esto no responde estrictamente a su pregunta, en cuanto al rendimiento que podría sugerir la fusión de que x + y lógica en la iteración, así:

for (int x = 0; x < 100; x++)
    for (int y = 0; y < 100 - x; y++)
        storage.Add(Tuple.Create(x, y));