Tuple<T1>.IStructuralComparable.CompareTo(Object, IComparer) Metode

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Sumber:: Tuple.cs

Sumber:: Tuple.cs

Sumber:: Tuple.cs

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Membandingkan objek saat ini Tuple<T1> dengan objek tertentu dengan menggunakan perbandingan tertentu, dan mengembalikan bilangan bulat yang menunjukkan apakah objek saat ini sebelum, sesudah, atau dalam posisi yang sama dengan objek yang ditentukan dalam urutan pengurutan.

 virtual int System.Collections.IStructuralComparable.CompareTo(System::Object ^ other, System::Collections::IComparer ^ comparer) = System::Collections::IStructuralComparable::CompareTo;

int IStructuralComparable.CompareTo (object other, System.Collections.IComparer comparer);

abstract member System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int
override this.System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int

Function CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareTo

Parameter

other: Object

Objek untuk dibandingkan dengan instans saat ini.

comparer: IComparer

Objek yang menyediakan aturan kustom untuk perbandingan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan yang menunjukkan posisi relatif instans ini dan other dalam urutan pengurutan, seperti yang ditunjukkan dalam tabel berikut.

Nilai	Deskripsi
Bilangan bulat negatif	Instans ini mendahului `other`.
Nol	Instans ini dan `other` memiliki posisi yang sama dalam urutan pengurutan.
Bilangan bulat positif	Instans `other`ini mengikuti .

Penerapan

CompareTo(Object, IComparer)

Pengecualian

ArgumentException

other bukan Tuple<T1> objek.

Contoh

Contoh berikut mendefinisikan kelas generik bernama DescendingComparer yang mengimplementasikan IComparer<T> antarmuka. DescendingComparer mengurutkan objek dalam urutan menurun daripada urutan naik dengan membalikkan nilai yang dikembalikan oleh perbandingan default untuk tipe tertentu. Instans kelas generik DescendingComparer kemudian diteruskan ke Array.Sort(Array, IComparer) metode untuk mengurutkan array Tuple<T1> objek dalam urutan turun. Perhatikan bahwa contoh tidak secara langsung memanggil IStructuralComparable.CompareTo metode . Metode ini dipanggil secara implisit oleh Array.Sort(Array, IComparer) metode untuk setiap elemen dalam array.

using System;
using System.Collections.Generic;

public class DescendingComparer<T> : IComparer<T>
{
    public int Compare(T x, T y) 
    {
        return -1 * Comparer<T>.Default.Compare(x, y);
    }
}

class CompareTo2
{
   static void Main()
   {
       Tuple<Double>[] values = { Tuple.Create(13.54),
                                  Tuple.Create(Double.NaN),
                                  Tuple.Create(-189.42993),
                                  Tuple.Create(Double.PositiveInfinity),
                                  Tuple.Create(Double.Epsilon),
                                  Tuple.Create(1.934E-17),
                                  Tuple.Create(Double.NegativeInfinity),
                                  Tuple.Create(-0.000000000003588),
                                  null };
       Console.WriteLine("The values in unsorted order:");
       foreach (var value in values)
           if (value != null)
               Console.WriteLine("   {0}", value.Item1);
           else
               Console.WriteLine("   <null>");
       Console.WriteLine();

       Array.Sort(values, new DescendingComparer<Tuple<Double>>());

       Console.WriteLine("The values sorted in descending order:");
       foreach (var value in values)
           if (value != null)
               Console.WriteLine("   {0}", value.Item1);
           else
               Console.WriteLine("   <null>");
    }
}
// The example displays the following output:
//      The values in unsorted order:
//         13.54
//         NaN
//         -189.42993
//         Infinity
//         4.94065645841247E-324
//         1.934E-17
//         -Infinity
//         -3.588E-12
//
//      The values sorted in descending order:
//         Infinity
//         13.54
//         1.934E-17
//         4.94065645841247E-324
//         -3.588E-12
//         -189.42993
//         -Infinity
//         NaN

open System
open System.Collections.Generic

type DescendingComparer<'T>() =
    interface IComparer<'T> with
        member _.Compare(x: 'T, y: 'T) = 
            -1 * Comparer<'T>.Default.Compare(x, y)

let values = 
    [| Tuple.Create 13.54
       Tuple.Create Double.NaN
       Tuple.Create -189.42993
       Tuple.Create Double.PositiveInfinity
       Tuple.Create Double.Epsilon
       Tuple.Create 1.934E-17
       Tuple.Create Double.NegativeInfinity
       Tuple.Create -0.000000000003588
       null |]
printfn "The values in unsorted order:"
for value in values do
    printfn $"   %A{value.Item1}"
printfn ""

Array.Sort(values, DescendingComparer<Tuple<Double>>())

printfn "The values sorted in descending order:"
for value in values do
    printfn $"   %A{value.Item1}"
// The example displays the following output:
//      The values in unsorted order:
//         13.54
//         NaN
//         -189.42993
//         Infinity
//         4.94065645841247E-324
//         1.934E-17
//         -Infinity
//         -3.588E-12
//
//      The values sorted in descending order:
//         Infinity
//         13.54
//         1.934E-17
//         4.94065645841247E-324
//         -3.588E-12
//         -189.42993
//         -Infinity
//         NaN

Imports System.Collections.Generic

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
    Public Function Compare(ByVal x As T, ByVal y As T) As Integer Implements IComparer(Of T).Compare
        Return -1 * Comparer(Of T).Default.Compare(x, y)
    End Function
End Class

Module Example
    Sub Main()
        Dim values() = { Tuple.Create(13.54),
                         Tuple.Create(Double.NaN),
                         Tuple.Create(-189.42993),
                         Tuple.Create(Double.PositiveInfinity),
                         Tuple.Create(Double.Epsilon),
                         Tuple.Create(1.934E-17),
                         Tuple.Create(Double.NegativeInfinity),
                         Tuple.Create(-0.000000000003588),
                         Nothing}

        Console.WriteLine("The values in unsorted order:")
        For Each value As Tuple(Of Double) In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
        Console.WriteLine()

        Array.Sort(values, New DescendingComparer(Of Tuple(Of Double)))

        Console.WriteLine("The values sorted in descending order:")
        For Each value As Tuple(Of Double) In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'      The values in unsorted order:
'         13.54
'         NaN
'         -189.42993
'         Infinity
'         4.94065645841247E-324
'         1.934E-17
'         -Infinity
'         -3.588E-12
'
'      The values sorted in descending order:
'         Infinity
'         13.54
'         1.934E-17
'         4.94065645841247E-324
'         -3.588E-12
'         -189.42993
'         -Infinity
'         NaN

Keterangan

Meskipun metode ini dapat dipanggil secara langsung, metode ini paling umum disebut dengan metode pengurutan koleksi yang menyertakan IComparer parameter untuk mengurutkan anggota koleksi. Misalnya, ini dipanggil dengan Array.Sort(Array, IComparer) metode dan Add metode SortedList objek yang diinstruksikan dengan menggunakan SortedList.SortedList(IComparer) konstruktor.

Perhatian

Metode IStructuralComparable.CompareTo ini ditujukan untuk digunakan dalam operasi pengurutan. Ini tidak boleh digunakan ketika tujuan utama perbandingan adalah untuk menentukan apakah dua objek sama. Untuk menentukan apakah dua objek sama, panggil IStructuralEquatable.Equals metode .

Berlaku untuk

Lihat juga

IStructuralEquatable.Equals(Object, IEqualityComparer)