IStructuralComparable Interfaz

Definición

Espacio de nombres:

System.Collections

Ensamblados:

netstandard.dll, System.Runtime.dll

Admite la comparación estructural de objetos de colección.

C#

public interface IStructuralComparable

Derivado

System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

System.Tuple<T1,T2,T3,T4>

System.Tuple<T1,T2,T3,T4,T5>

System.Tuple<T1,T2,T3,T4,T5,T6>

System.Tuple<T1,T2,T3,T4,T5,T6,T7>

System.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>

System.ValueTuple

System.ValueTuple<T1>

System.ValueTuple<T1,T2>

System.ValueTuple<T1,T2,T3>

System.ValueTuple<T1,T2,T3,T4>

System.ValueTuple<T1,T2,T3,T4,T5>

System.ValueTuple<T1,T2,T3,T4,T5,T6>

System.ValueTuple<T1,T2,T3,T4,T5,T6,T7>

System.ValueTuple<T1,T2,T3,T4,T5,T6,T7,TRest>

Ejemplos

En el ejemplo siguiente se crea una matriz de Tuple<T1,T2,T3,T4,T5,T6> objetos que contiene datos de población para tres ciudades de EE. UU. de 1960 a 2000. El primer componente de sextuple es el nombre de la ciudad. Los cinco componentes restantes representan la población a intervalos de diez años de 1960 a 2000.

La PopulationComparer clase proporciona una IComparer implementación que permite ordenar la matriz de sextuples por cualquiera de sus componentes. Se proporcionan dos valores a la PopulationComparer clase en su constructor: la posición del componente que define el criterio de ordenación y un valor booleano que indica si los objetos de tupla deben ordenarse en orden ascendente o descendente.

A continuación, el ejemplo muestra los elementos de la matriz en orden no ordenado, los ordena por el tercer componente (la población en 1970) y los muestra y, a continuación, los ordena por el sexto componente (la población en 2000) y los muestra. Tenga en cuenta que el ejemplo no llama directamente al CompareTo método . El método llama implícitamente al Sort(Array, IComparer) método para cada objeto de tupla de la matriz.

C#

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

public class PopulationComparer<T1, T2, T3, T4, T5, T6> : IComparer
{
   private int itemPosition;
   private int multiplier = -1;

   public PopulationComparer(int component) : this(component, true)
   { }

   public PopulationComparer(int component, bool descending)
   {
      if (!descending) multiplier = 1;

      if (component <= 0 || component > 6)
         throw new ArgumentException("The component argument is out of range.");

      itemPosition = component;
   }

   public int Compare(object x, object y)
   {
      var tX = x as Tuple<T1, T2, T3, T4, T5, T6>;
      if (tX == null)
      {
         return 0;
      }
      else
      {
         var tY = y as Tuple<T1, T2, T3, T4, T5, T6>;
         switch (itemPosition)
         {
            case 1:
               return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
            case 2:
               return Comparer<T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier;
            case 3:
               return Comparer<T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier;
            case 4:
               return Comparer<T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier;
            case 5:
               return Comparer<T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier;
            case 6:
               return Comparer<T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier;
            default:
               return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
         }
      }
   }
}

public class Example
{
   public static void Main()
   {
      // Create array of sextuple with population data for three U.S.
      // cities, 1960-2000.
      Tuple<string, int, int, int, int, int>[] cities =
           { Tuple.Create("Los Angeles", 2479015, 2816061, 2966850, 3485398, 3694820),
             Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278),
             Tuple.Create("Chicago", 3550904, 3366957, 3005072, 2783726, 2896016) };

      // Display array in unsorted order.
      Console.WriteLine("In unsorted order:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
      Console.WriteLine();

      Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int>(3));

      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 1970:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
      Console.WriteLine();

      Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int>(6));

      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 2000:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
   }
}
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
//    
//    Sorted by population in 1970:
//    (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 2000:
//    (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)

Comentarios

La IStructuralComparable interfaz permite implementar comparaciones personalizadas para los miembros de la colección. Es decir, puede definir exactamente lo que significa que un objeto de colección preceda, siga o se produzca en la misma posición en el criterio de ordenación como un segundo objeto de colección. A continuación, puede especificar que esta definición se use con un tipo de colección que acepte la IStructuralComparable interfaz .

La interfaz tiene un único miembro, CompareTo, que determina si el objeto de colección actual es menor, igual o mayor que un segundo objeto en el criterio de ordenación. La comparación real de los miembros o elementos de la instancia actual con los de un segundo objeto se realiza mediante una IComparer implementación de interfaz, que contiene la definición de la comparación personalizada.

Nota

La IStructuralComparable interfaz solo admite comparaciones estructurales para ordenar o ordenar. La IStructuralEquatable interfaz admite comparaciones personalizadas para la igualdad estructural.

.NET Framework proporciona dos comparadores predeterminados. La propiedad devuelve StructuralComparisons.StructuralComparer uno; el otro lo devuelve la Comparer<T>.Default propiedad .

Las clases de tupla genéricas (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>, etc.) y la Array clase proporcionan implementaciones explícitas de la IStructuralComparable interfaz. Al convertir (en C#) o convertir (en Visual Basic) la instancia actual de una matriz o tupla en un IStructuralComparable valor de interfaz y proporcionar la IComparer implementación como argumento al CompareTo método, puede definir un criterio de ordenación personalizado para la matriz o colección. Sin embargo, no se llama al método directamente en la CompareTo mayoría de los casos. En su lugar, se llama al CompareTo método ordenando métodos como Sort(Array, IComparer). En este caso, se define la IComparer implementación y se pasa como argumento a un método de ordenación o constructor de clase del objeto de colección. El CompareTo método con el comparador personalizado se llama automáticamente cada vez que se ordena la colección.

Métodos

CompareTo(Object, IComparer)

Determina si el objeto de colección actual precede o sigue a otro objeto en el criterio de ordenación, o aparece en la misma posición que él.

Se aplica a

Consulte también

• IComparable
• IStructuralEquatable
• StructuralComparer