Cómo utilizar las interfaces IComparable e IComparer en Visual C#

Para una versión de Visual Basic .NET de este artículo, consulte 322025 .

EN ESTA TAREA

Resumen

En este artículo se describe paso a paso el uso de dos interfaces: IComparer y IComparable. Estas interfaces se describen en el mismo artículo por dos razones. Estas interfaces suelen utilizarse juntas, y aunque las interfaces son similares (y tienen nombres similares), se usan con otros fines.

Si tiene una matriz de tipos (como string o integer) que ya son compatibles con IComparer, puede ordenar dicha matriz sin proporcionar cualquier referencia explícita a IComparer. En ese caso, los elementos de la matriz se convierten a la implementación de IComparer (Comparer.Default). Sin embargo, si desea proporcionar funcionalidad de ordenación o comparación para objetos personalizados, debe implementar una o ambas de estas interfaces.

El espacio de nombres de biblioteca de clases de.NET Framework siguiente se hace referencia en este artículo:

System.Collections

IComparable

La función de IComparable es proporcionar un método para comparar dos objetos de un tipo determinado. Esto es necesario si desea proporcionar alguna capacidad de ordenación para el objeto. Piense IComparable como proporcionar un criterio de ordenación predeterminado para los objetos. Por ejemplo, si tiene una matriz de objetos de su tipo, y se llama al método Sort en dicha matriz, IComparable proporciona la comparación de objetos durante la ordenación. Cuando implemente la interfaz IComparable , debe implementar el método CompareTo , como sigue:

// Implement IComparable CompareTo method - provide default sort order.int IComparable.CompareTo(object obj)
{
car c=(car)obj;
return String.Compare(this.make,c.make);

}

La comparación en el método es diferente según el tipo de datos del valor que se va a comparar. String.Compare se utiliza en este ejemplo, debido a que se ha elegido para la comparación una cadena.

IComparer

La función de IComparer es proporcionar mecanismos de comparación adicionales. Por ejemplo, puede desee proporcionar la ordenación de la clase en varios campos o propiedades, ascendente y descendente en el mismo campo, o en ambos.

El uso de IComparer es un proceso de dos pasos. En primer lugar, declare una clase que implementa la interfaz IComparery, a continuación, implemente el método Compare :

private class sortYearAscendingHelper : IComparer{
int IComparer.Compare(object a, object b)
{
car c1=(car)a;
car c2=(car)b;
if (c1.year > c2.year)
return 1;
if (c1.year < c2.year)
return -1;
else
return 0;
}
}

Observe que el método IComparer.Compare requiere una comparación terciaria. 1, 0, -1 o se devuelve en función de si un valor es mayor que, igual a, o menos que el otro. El criterio de ordenación (ascendente o descendente) puede modificarse cambiando los operadores lógicos en este método.

El segundo paso es declarar un método que devuelve una instancia del objeto IComparer :

public static IComparer sortYearAscending(){      
return (IComparer) new sortYearAscendingHelper();
}

En este ejemplo, el objeto se utiliza como segundo argumento cuando se llama al método Array.Sort sobrecargado que acepta IComparer. El uso de IComparer no se limita a arrays. Se acepta como argumento en un número de colección diferentes y las clases de control.

Ejemplo paso a paso

En el ejemplo siguiente se muestra el uso de estas interfaces. Para demostrar IComparer y IComparable, se crea una clase denominada automóvil . El objeto de automóvil tiene las propiedades hacen y año . Una ordenación ascendente para hacer que el campo está habilitado a través de la interfaz IComparable y un orden descendente en el hacer campo está habilitado a través de la interfaz IComparer . Se proporcionan tanto ascendente y descendente para la propiedad año mediante el uso de IComparer.
  1. En Visual C#, cree un nuevo proyecto de aplicación de consola. Nombre de la aplicación ConsoleEnum.
  2. Cambie el nombre Program.cs como Host.cs y, a continuación, reemplace el código con el código siguiente.

    Nota: En Visual Studio .NET 2003, cambie el nombre Class1.cs como Host.cs.
    using System;
    namespace ConsoleEnum
    {
    class host
    {
    [STAThread]
    static void Main(string[] args)
    {
    // Create an arary of car objects.
    car[] arrayOfCars= new car[6]
    {
    new car("Ford",1992),
    new car("Fiat",1988),
    new car("Buick",1932),
    new car("Ford",1932),
    new car("Dodge",1999),
    new car("Honda",1977)
    };

    // Write out a header for the output.
    Console.WriteLine("Array - Unsorted\n");

    foreach(car c in arrayOfCars)
    Console.WriteLine(c.Make + "\t\t" + c.Year);

    // Demo IComparable by sorting array with "default" sort order.
    Array.Sort(arrayOfCars);
    Console.WriteLine("\nArray - Sorted by Make (Ascending - IComparable)\n");

    foreach(car c in arrayOfCars)
    Console.WriteLine(c.Make + "\t\t" + c.Year);

    // Demo ascending sort of numeric value with IComparer.
    Array.Sort(arrayOfCars,car.sortYearAscending());
    Console.WriteLine("\nArray - Sorted by Year (Ascending - IComparer)\n");

    foreach(car c in arrayOfCars)
    Console.WriteLine(c.Make + "\t\t" + c.Year);

    // Demo descending sort of string value with IComparer.
    Array.Sort(arrayOfCars,car.sortMakeDescending());
    Console.WriteLine("\nArray - Sorted by Make (Descending - IComparer)\n");

    foreach(car c in arrayOfCars)
    Console.WriteLine(c.Make + "\t\t" + c.Year);

    // Demo descending sort of numeric value using IComparer.
    Array.Sort(arrayOfCars,car.sortYearDescending());
    Console.WriteLine("\nArray - Sorted by Year (Descending - IComparer)\n");

    foreach(car c in arrayOfCars)
    Console.WriteLine(c.Make + "\t\t" + c.Year);

    Console.ReadLine();
    }
    }
    }

  3. Agregar una clase al proyecto. Nombre de la clase automóvil.
  4. Reemplace el código de Car.cs con lo siguiente:
    using System;using System.Collections;
    namespace ConsoleEnum
    {
    public class car : IComparable
    {
    // Beginning of nested classes.

    // Nested class to do ascending sort on year property.
    private class sortYearAscendingHelper: IComparer
    {
    int IComparer.Compare(object a, object b)
    {
    car c1=(car)a;
    car c2=(car)b;

    if (c1.year > c2.year)
    return 1;

    if (c1.year < c2.year)
    return -1;

    else
    return 0;
    }
    }

    // Nested class to do descending sort on year property.
    private class sortYearDescendingHelper: IComparer
    {
    int IComparer.Compare(object a, object b)
    {
    car c1=(car)a;
    car c2=(car)b;

    if (c1.year < c2.year)
    return 1;

    if (c1.year > c2.year)
    return -1;

    else
    return 0;
    }
    }

    // Nested class to do descending sort on make property.
    private class sortMakeDescendingHelper: IComparer
    {
    int IComparer.Compare(object a, object b)
    {
    car c1=(car)a;
    car c2=(car)b;
    return String.Compare(c2.make,c1.make);
    }
    }

    // End of nested classes.

    private int year;
    private string make;

    public car(string Make,int Year)
    {
    make=Make;
    year=Year;
    }

    public int Year
    {
    get {return year;}
    set {year=value;}
    }

    public string Make
    {
    get {return make;}
    set {make=value;}
    }

    // Implement IComparable CompareTo to provide default sort order.
    int IComparable.CompareTo(object obj)
    {
    car c=(car)obj;
    return String.Compare(this.make,c.make);
    }

    // Method to return IComparer object for sort helper.
    public static IComparer sortYearAscending()
    {
    return (IComparer) new sortYearAscendingHelper();
    }

    // Method to return IComparer object for sort helper.
    public static IComparer sortYearDescending()
    {
    return (IComparer) new sortYearDescendingHelper();
    }

    // Method to return IComparer object for sort helper.
    public static IComparer sortMakeDescending()
    {
    return (IComparer) new sortMakeDescendingHelper();
    }

    }
    }

  5. Ejecute el proyecto. Aparece el siguiente resultado en la ventana de la consola:

    Array - Unsorted
    Ford 1992
    Fiat 1988
    Buick 1932
    Ford 1932
    Dodge 1999
    Honda 1977

    Array - Sorted by Make (Ascending - IComparable)

    Buick 1932
    Dodge 1999
    Fiat 1988
    Ford 1932
    Ford 1992
    Honda 1977

    Array - Sorted by Year (Ascending - IComparer)

    Ford 1932
    Buick 1932
    Honda 1977
    Fiat 1988
    Ford 1992
    Dodge 1999

    Array - Sorted by Make (Descending - IComparer)

    Honda 1977
    Ford 1932
    Ford 1992
    Fiat 1988
    Dodge 1999
    Buick 1932

    Array - Sorted by Year (Descending - IComparer)

    Dodge 1999
    Ford 1992
    Fiat 1988
    Honda 1977
    Buick 1932
    Ford 1932

Propiedades

Id. de artículo: 320727 - Última revisión: 17 ene. 2017 - Revisión: 1

Comentarios