orderby - Ordenando una lista de objetos en C#

list sort c#

Question

public class CarSpecs
{
  public String CarName { get; set; }

  public String CarMaker { get; set; }

  public DateTime CreationDate { get; set; }
}

Esta es una lista y estoy tratando de encontrar una manera eficiente de ordenar esta lista List CarList, que contiene 6 (o cualquier cantidad entera) Cars, por la fecha de fabricación del auto. Iba a hacer Bubble sort, pero ¿funcionará? ¿Alguna ayuda?

Gracias

Answer 1

El mejor enfoque es implementar IComparable o IComparable<T> , y luego llamar a List<T>.Sort() . Esto hará todo el trabajo duro de ordenar por ti.

Answer 2

Evitaría escribir mi propio algoritmo de clasificación, pero si va a hacerlo de todos modos, eche un vistazo a http://www.sorting-algorithms.com/ para algunas comparaciones de diferentes algoritmos de clasificación ...

Answer 3

La clase List<T> hace que esto sea trivial, ya que contiene un método Sort . (Utiliza el algoritmo QuickSort, no Bubble Sort, que por lo general es mejor). Incluso mejor, tiene una sobrecarga que toma un argumento de Comparison<T> , lo que significa que puede pasar una expresión lambda y hacer las cosas muy simples.

Prueba esto:

CarList.Sort((x, y) => DateTime.Compare(x.CreationDate, y.CreationDate));

Answer 4

Otra opción sería usar un comparador personalizado:

using System;
using System.Collections.Generic;
using System.Text;

namespace Yournamespace
{
   class CarNameComparer : IComparer<Car>
   {
      #region IComparer<Car> Members

      public int Compare(Car car1, Car car2)
      {
         int returnValue = 1;
         if (car1 != null && car2 == null)
         {
            returnValue = 0;
         }
         else if (car1 == null && car2 != null)
         {
            returnValue = 0;
         }
         else if (car1 != null && car2 != null)
         {
            if (car1.CreationDate.Equals(car2.CreationDate))
            {
               returnValue = car1.Name.CompareTo(car2.Name);
            }
            else
            {
               returnValue = car2.CreationDate.CompareTo(car1.CreationDate);
            }
         }
         return returnValue;
      }

      #endregion
   }
}

que llamas así:

yourCarlist.Sort(new CarNameComparer());

Nota: No compilé este código por lo que es posible que deba eliminar los errores de tipografía

Editar: lo modificó para que el comparador compare en la fecha de creación como se solicitó en cuestión.

Answer 5

Poniendo algunas de las piezas mencionadas aquí juntas. Esto compila y funciona en C # 4.xy VS2010. WinForm con un WinForm . Así que agrega el método al WinForm Main() . Necesitará al menos los ensamblados System.Linq y System.Generic.Collection .

    private void SortCars()
    {
        List<CarSpecs> cars = new List<CarSpecs>();
        List<CarSpecs> carsSorted = new List<CarSpecs>();

        cars.Add(new CarSpecs
        {
            CarName = "Y50",
            CarMaker = "Ford",
            CreationDate = new DateTime(2011, 4, 1),
        });

        cars.Add(new CarSpecs
        {
            CarName = "X25",
            CarMaker = "Volvo",
            CreationDate = new DateTime(2012, 3, 1),
        });

        cars.Add(new CarSpecs
        {
            CarName = "Z75",
            CarMaker = "Datsun",
            CreationDate = new DateTime(2010, 5, 1),
        });

        //More Comprehensive if needed  
        //cars.OrderBy(x => x.CreationDate).ThenBy(x => x.CarMaker).ThenBy(x => x.CarName);

        carsSorted.AddRange(cars.OrderBy(x => x.CreationDate));

        foreach (CarSpecs caritm in carsSorted)
        {
            MessageBox.Show("Name: " +caritm.CarName 
                + "/r/nMaker: " +caritm.CarMaker
                + "/r/nCreationDate: " +caritm.CreationDate);
        }
    }
}

public class CarSpecs
{
    public string CarName { get; set; }
    public string CarMaker { get; set; }
    public DateTime CreationDate { get; set; }
} 

Answer 6

Puedes usar LINQ:

listOfCars.OrderBy(x => x.CreationDate);

EDITAR: con este enfoque, es fácil agregar más columnas de clasificación:

listOfCars.OrderBy(x => x.CreationDate).ThenBy(x => x.Make).ThenBy(x => x.Whatever);

Answer 7

Si buscas una forma eficiente de ordenar, te aconsejo que no utilices el tipo burbuja y, en su lugar, busques una ordenación rápida. Esta página proporciona una explicación bastante buena del algoritmo:

http://www.devhood.com/Tutorials/tutorial_details.aspx?tutorial_id=574

¡La mejor de las suertes!

Answer 8

Si usa 2.0, la siguiente discusión puede ser útil: C # List <> Sort by x then y

Answer 9

Si usa delegados (también conocidos como métodos anónimos), no tendrá que implementar ninguna interfaz IComparer / IComparable.

public static void Main(string[] args)
    {


      List<CarSpecs> list = new List<CarSpecs>();

      list.Add(new CarSpecs("Focus", "Ford", new DateTime(2010,1, 2));
      list.Add(new CarSpecs("Prius", "Toyota", new DateTime(2012,3, 3));
      list.Add(new CarSpecs("Ram", "Dodge", new DateTime(2013, 10, 6));



        list.Sort(delegate (CarSpecs first, CarSpecs second)
        {
            int returnValue = 1;
            if((first != null & second != null))
            {
                if (first.CarName.Equals(second.CarName))
                {
                    if (first.CarMaker.Equals(second.CarMaker))
                    {
                    returnValue = first.CreationDate.CompareTo(second.CreationDate);
                    }
                    else
                    {
                    returnValue = first.CarMaker.CompareTo(second.CarMaker);
                    }
                }
                else
                {
                    returnValue = first.CarName.CompareTo(second.CarName);
                }
            }
            return returnValue;
        });

    }

Answer 10

Solo usaría la compilación en el método List.Sort. Utiliza el algoritmo QuickSort que, en promedio, se ejecuta en O (n log n).

Este código debería funcionar para usted, cambio sus propiedades a auto-propiedades y definí un método estático CompareCarSpecs que solo usa el método DateTime.CompareTo ya existente.

class Program
{
    static void Main(string[] args)
    {
        List<CarSpecs> cars = new List<CarSpecs>();
        cars.Sort(CarSpecs.CompareCarSpecs);
    }
}

public class CarSpecs
{
    public string CarName { get; set; }
    public string CarMaker { get; set; }
    public DateTime CreationDate { get; set; }

    public static int CompareCarSpecs(CarSpecs x, CarSpecs y)
    {
        return x.CreationDate.CompareTo(y.CreationDate);
    }
}

Espero que esto ayude.