Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Comparison<T>-Delegat

 

Veröffentlicht: Oktober 2016

Stellt die Methode dar, die zwei Objekte des gleichen Typs vergleicht.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public delegate int Comparison<in T>(
	T x,
	T y
)

Parameter

x
Type: T

Das erste zu vergleichende Objekt.

y
Type: T

Das zweite zu vergleichende Objekt.

Rückgabewert

Type: System.Int32

Eine ganze Zahl mit Vorzeichen, die die relativen Werte von x und y angibt, wie in der folgenden Tabelle veranschaulicht.

Wert

Bedeutung

Kleiner als 0

x ist kleiner als y.

0

x ist gleich y.

Größer als 0

x ist größer als y.

Typparameter

inT

Der Typ des zu vergleichenden Objekte.

Dieser Delegat wird verwendet, indem Sie die Sort<T>(T[], Comparison<T>) methodenüberladung der Array Klasse und die Sort(Comparison<T>) methodenüberladung der die List<T> Klasse die Elemente eines Arrays oder einer Liste sortiert.

Das folgende Codebeispiel veranschaulicht die Verwendung von der Comparison<T> mit Delegieren der Sort(Comparison<T>) -methodenüberladung.

Das Codebeispiel definiert eine alternative Vergleichsmethode für Zeichenfolgen, die mit dem Namen CompareDinosByLength. Diese Methode funktioniert wie folgt: zunächst der verglichenen Elemente getestet werden null, und ein null-Verweis als kleiner als ein Wert ungleich Null behandelt wird. Zweitens die Zeichenfolgenlängen verglichen werden, und die Zeichenfolge längere ist als größer werden. Wenn die Länge gleich sind, wird im dritten gewöhnliche Zeichenfolgenvergleich verwendet.

Ein List<T> von Zeichenfolgen erstellt und mit vier Zeichenfolgen, ohne bestimmte Reihenfolge gefüllt ist. Die Liste enthält auch eine leere Zeichenfolge und ein null-Verweis. Die Liste wird angezeigt, sortiert, mit einem Comparison<T> generischer Delegat darstellt der CompareDinosByLength -Methode, und erneut angezeigt.

using System;
using System.Collections.Generic;

public class Example
{
    private static int CompareDinosByLength(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }

    public static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("");
        dinosaurs.Add(null);
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        Console.WriteLine("\nSort with generic Comparison<string> delegate:");
        dinosaurs.Sort(CompareDinosByLength);
        Display(dinosaurs);

    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            if (s == null)
                Console.WriteLine("(null)");
            else
                Console.WriteLine("\"{0}\"", s);
        }
    }
}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<string> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */

Im folgenden Beispiel wird die Comparison<T> Delegaten zum Sortieren der Elemente einer Auflistung von CityInfo Objekte. CityInfoist eine anwendungsdefinierte Klasse, die Informationen über einen Orts- und seiner Einwohnerzahl enthält. Im Beispiel definiert drei Methoden CompareByName, CompareByPopulation, und CompareByNames, bieten drei verschiedene Möglichkeiten zum Sortieren der CityInfo Objekte. Jede Methode zugewiesen ist die comparison Argument der Array.Sort<T>(T[], Comparison<T>) Methode.

using System;

public class CityInfo
{
   string cityName;
   string countryName;
   int pop2010;

   public CityInfo(string name, string country, int pop2010)
   {
      this.cityName = name;
      this.countryName = country;
      this.pop2010 = pop2010;
   }

   public string City
   { get { return this.cityName; } } 

   public string Country
   { get { return this.countryName; } }

   public int Population
   { get { return this.pop2010; } }

   public static int CompareByName(CityInfo city1, CityInfo city2)
   { 
      return String.Compare(city1.City, city2.City);
   }

   public static int CompareByPopulation(CityInfo city1, CityInfo city2)
   {
      return city1.Population.CompareTo(city2.Population);
   }

   public static int CompareByNames(CityInfo city1, CityInfo city2)
   {
      return String.Compare(city1.Country + city1.City, city2.Country + city2.City);
   }      
}

public class Example
{
   public static void Main()
   {
      CityInfo NYC = new CityInfo("New York City", "United States of America", 8175133 );
      CityInfo Det = new CityInfo("Detroit", "United States of America", 713777);
      CityInfo Paris = new CityInfo("Paris", "France",  2193031);
      CityInfo[] cities = { NYC, Det, Paris };
      // Display ordered array.
      DisplayArray(cities);

      // Sort array by city name.
      Array.Sort(cities, CityInfo.CompareByName);
      DisplayArray(cities);

      // Sort array by population.
      Array.Sort(cities, CityInfo.CompareByPopulation);
      DisplayArray(cities);

      // Sort array by country + city name.
      Array.Sort(cities, CityInfo.CompareByNames);
      DisplayArray(cities);
   }

   private static void DisplayArray(CityInfo[] cities)
   {
      Console.WriteLine("{0,-20} {1,-25} {2,10}", "City", "Country", "Population");
      foreach (var city in cities)
         Console.WriteLine("{0,-20} {1,-25} {2,10:N0}", city.City, 
                           city.Country, city.Population);

      Console.WriteLine();
   }
}
// The example displays the following output:
//     City                 Country                   Population
//     New York City        United States of America   8,175,133
//     Detroit              United States of America     713,777
//     Paris                France                     2,193,031
//     
//     City                 Country                   Population
//     Detroit              United States of America     713,777
//     New York City        United States of America   8,175,133
//     Paris                France                     2,193,031
//     
//     City                 Country                   Population
//     Detroit              United States of America     713,777
//     Paris                France                     2,193,031
//     New York City        United States of America   8,175,133
//     
//     City                 Country                   Population
//     Paris                France                     2,193,031
//     Detroit              United States of America     713,777
//     New York City        United States of America   8,175,133

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: