¿Por qué Array.Sort() es tan lento en comparación con LINQ?

Question

Hice la aplicación de prueba rápida para comparar la clasificación LINQ a Array.Sort en mis objetos personalizados. ¡Array.Sort parece extremadamente lento!

hice mi clase personalizada como esto:

class Person : IComparable<Person> 
{ 
    public int Age { get; set; } 
    public string Name { get; set; } 

    public int CompareTo(Person obj) 
    { 
     return this.Age.CompareTo(obj.Age); 
    } 

    public Person() 
    { } 

} 

Entonces hice mis pruebas de personas en main():

string name = "Mr. Tomek"; 

Random r = new Random(); 
int size = 10000000; 

DateTime start, end; 
Person[] people1 = new Person[size]; 
Person[] people2 = new Person[size]; 

for (int i = 0; i < size; i++) 
{ 
    people1[i] = new Person(); 
    people1[i].Age = r.Next(0, 10000); 
    people1[i].Name = name; 

    people2[i] = new Person(); 
    people2[i].Age = people1[i].Age; 
    people2[i].Name = people1[i].Name; 
} 

Después de ese tiempo he tomado medida de Ordenar por Array.Sort y por LINQ: tiempo

start = DateTime.Now; 
var sort = from s in people2 
      orderby s.Age 
      select s; 
end = DateTime.Now; 
Console.WriteLine("LINQ: "); 
Console.WriteLine((end - start).TotalMilliseconds); 

start = DateTime.Now; 
Array.Sort(people1,((Person p1, Person p2)=>{return p1.CompareTo(p2);})); 
end = DateTime.Now; 

Console.WriteLine("IComparable: "); 
Console.WriteLine((end - start).TotalMilliseconds); 

Console.ReadLine(); 

Linq: alrededor de 1 o 2 milisegundos

Array.Sort: más de 16 SECONDS!

Todas las matrices están ordenadas (LINQ produce una nueva colección y deja oryginal array sin clasificar) pero Array.Sort es extremadamente lenta. ¿Cómo podría ser explicado? (en modo DEBUG y RELEASE Array.Sort falla extremadamente)

Pegué el código con la expresión lambda al ordenar con Array.Sort pero es lo mismo con y sin él. (Persona de clase implementa la interfaz IComparable)

Answer 1

Su consulta de Linq ni siquiera se ejecuta porque no obtiene los resultados. Eso se llama deferred execution. La consulta solo se ejecuta cuando realmente enumera los resultados.

Use algo como var results = sort.ToArray() para ejecutar la consulta, y obtendrá resultados más precisos.

Answer 2

LINQ es flojo. Su people2 no ha sido realmente ordenado, LINQ acaba de crear un "objeto de promesa" temporal que sería ordenado. Para que realmente suceda, debe forzar la evaluación por Console.WriteLine el resultado ordenado, convertirlo en list/array o hacer cualquier otra cosa como esta.

Ver más: deferred execution.

Answer 3

declaraciones Linq vuelven IEnumerable<T> o de sabores, esta (o cualquier cosa usando la palabra clave yield) sólo se ejecuta cuando se iterate ella. La mayoría de las acciones disponibles en las bibliotecas de Linq (no todas) are lazy/deferred.

No está iterando, por lo que en realidad no realiza el tipo.

Debe forzar una repetición completa. Pegue los resultados en una lista se repetirá plenamente la enumerable devuelto:

var sort = (from s in people2 
      orderby s.Age 
      select s).ToList(); 

Sólo entonces se puede comparar manzanas con manzanas.

De hecho, en el caso de una especie (orderby), sólo tiene que seleccionar la primera elemento causará una iteración completa como hay que hacer totalmente una especie antes de poder devolver el primer resultado:

var sort = from s in people2 
      orderby s.Age 
      select s; 

var s = sort.First(); 

Answer 4

Intenta cambiar esta parte y haz tu prueba una vez más.

start = DateTime.Now; 
    var sort = (from s in people2 
       orderby s.Age 
       select s).ToList(); 
    end = DateTime.Now; 

Este evaluará la expresión LINQ.