Single.CompareTo Methode

Definition

Namespace:: System

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Assemblys:: mscorlib.dll, System.Runtime.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Vergleicht diese Instanz mit einem angegebenen Objekt oder einer anderen Single Instanz und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert des angegebenen Objekts oder der anderen Single Instanz ist.

Überlädt

Name	Beschreibung
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert des angegebenen Objekts ist.
CompareTo(Single)	Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit einfacher Genauigkeit und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert der angegebenen Gleitkommazahl mit einfacher Genauigkeit ist.

CompareTo(Object)

Quelle:: Single.cs

Quelle:: Single.cs

Quelle:: Single.cs

Quelle:: Single.cs

Quelle:: Single.cs

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert des angegebenen Objekts ist.

public:
 virtual int CompareTo(System::Object ^ value);

public int CompareTo(object? value);

public int CompareTo(object value);

abstract member CompareTo : obj -> int
override this.CompareTo : obj -> int

Public Function CompareTo (value As Object) As Integer

Parameter

value: Object

Ein zu vergleichende Objekt oder null.

Gibt zurück

Int32

Eine signierte Zahl, die die relativen Werte dieser Instanz angibt und value.

Rückgabewert	Beschreibung
Kleiner als Null	Diese Instanz ist kleiner als `value`, oder diese Instanz ist keine Zahl (NaN) und `value` eine Zahl.
Null	Diese Instanz ist gleich `value`, oder diese Instanz und der Wert sind keine Zahl (NaN), PositiveInfinityoder NegativeInfinity.
Größer als Null	Diese Instanz ist größer als `value`, ODER diese Instanz ist eine Zahl und `value` keine Zahl (NaN), ODER `value` ist `null`.

Implementiert

CompareTo(Object)

Ausnahmen

ArgumentException

value ist kein Single.

Beispiele

Im folgenden Codebeispiel wird die CompareTo Methode veranschaulicht.

obj1 = (Single)450;

if (a.CompareTo(obj1) < 0)
{
    Console.WriteLine("{0} is less than {1}.", a.ToString(), obj1.ToString());
}

if (a.CompareTo(obj1) > 0)
{
    Console.WriteLine("{0} is greater than {1}.", a.ToString(), obj1.ToString());
}

if (a.CompareTo(obj1) == 0)
{
    Console.WriteLine("{0} equals {1}.", a.ToString(), obj1.ToString());
}

let obj1 = single 450

if a.CompareTo obj1 < 0 then
    printfn $"{a} is less than {obj1}."

if a.CompareTo obj1 > 0 then
    printfn $"{a} is greater than {obj1}."

if a.CompareTo obj1 = 0 then
    printfn $"{a} equals {obj1}."

Obj1 = CType(450, Single)

If A.CompareTo(Obj1) < 0 Then
    Console.WriteLine(A.ToString() + " is less than " + Obj1.ToString() + ".")
End If

If (A.CompareTo(Obj1) > 0) Then
    Console.WriteLine(A.ToString() + " is greater than " + Obj1.ToString() + ".")
End If

If (A.CompareTo(Obj1) = 0) Then
    Console.WriteLine(A.ToString() + " equals " + Obj1.ToString() + ".")
End If

Hinweise

Werte müssen identisch sein, um gleich zu werden. Besonders wenn Gleitkommawerte von mehreren mathematischen Vorgängen abhängen, ist es üblich, dass sie genauigkeit verlieren und dass ihre Werte nahezu identisch sind, mit Ausnahme ihrer am wenigsten signifikanten Ziffern. Aus diesem Gründen kann der Rückgabewert der CompareTo Methode manchmal überraschend erscheinen. Beispielsweise sollte die Multiplikation durch einen bestimmten Wert, gefolgt von der Division durch denselben Wert, den ursprünglichen Wert erzeugen, im folgenden Beispiel wird der berechnete Wert jedoch größer als der ursprüngliche Wert. Wenn Alle signifikanten Ziffern der beiden Werte mithilfe der standardmäßigen numerischen Formatzeichenfolge "R" angezeigt werden, bedeutet dies, dass der berechnete Wert von dem ursprünglichen Wert in seinen am wenigsten signifikanten Ziffern abweicht. Informationen zum Behandeln solcher Vergleiche finden Sie im Abschnitt "Hinweise" der Equals(Single) Methode.

Obwohl ein Objekt, dessen Wert NaN ist, nicht als gleich zu einem anderen Objekt mit dem Wert NaN (auch nicht zu sich selbst) betrachtet wird, erfordert die IComparable<T>-Schnittstelle, dass A.CompareTo(A) null zurückgibt.

CompareTo(System.Object)

Der value Parameter muss null sein oder eine Instanz von Single; andernfalls wird eine Ausnahme ausgelöst. Jede Instanz von Single, unabhängig vom Wert, gilt als größer als null.

using System;

public class Example
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       object value2 = value1 * operand / operand;
       Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}");
       Console.WriteLine();
       Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = box (value1 * operand / operand)
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example2
    Public Sub Main()
        Dim value1 As Single = 16.5457
        Dim value2 As Object = value1 * CSng(3.8899982) / CSng(3.8899982)
        Console.WriteLine("Comparing {0} and {1}: {2}",
                          value1, value2, value1.CompareTo(value2))
        Console.WriteLine()
        Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                          value1, value2, value1.CompareTo(value2))
    End Sub
End Module
' The example displays the following output:
'       Comparing 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Diese Methode wird implementiert, um die IComparable Schnittstelle zu unterstützen.

CompareTo(System.Single)

Diese Methode implementiert die System.IComparable<T> Schnittstelle und führt etwas besser aus als die Single.CompareTo(Object) Überladung, da der value Parameter nicht in ein Objekt konvertiert werden muss.

using System;

public class Example2
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       float value2 = value1 * operand / operand;
       Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}");
       Console.WriteLine();
       Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = value1 * operand / operand
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example
   Public Sub Main()
       Dim value1 As Single = 16.5457
       Dim value2 As Single = value1 * CSng(3.8899982) / CSng(3.8899982)
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Erweiterungskonvertierungen

Je nach Programmiersprache kann es möglich sein, eine CompareTo Methode zu codieren, bei der der Parametertyp weniger Bits aufweist (ist schmaler) als der Instanztyp. Dies ist möglich, da einige Programmiersprachen eine implizite Erweiterungskonvertierung ausführen, die den Parameter als Typ mit so vielen Bits wie die Instanz darstellt.

Angenommen, der Instanztyp ist Single und der Parametertyp ist Int32. Der Microsoft C#-Compiler generiert Anweisungen, um den Wert des Parameters als Single Objekt darzustellen, und generiert dann eine Single.CompareTo(Single) Methode, die die Werte der Instanz und die erweiterte Darstellung des Parameters vergleicht.

In der Dokumentation der Programmiersprache können Sie ermitteln, ob der Compiler implizite Erweiterungskonvertierungen numerischer Typen durchführt. Weitere Informationen finden Sie im Thema "Typkonvertierungstabellen ".

Genauigkeit in Vergleichen

Die Genauigkeit von Gleitkommazahlen über die dokumentierte Genauigkeit hinaus ist spezifisch für die Implementierung und Version von .NET. Folglich kann sich ein Vergleich zweier bestimmter Zahlen zwischen .NET-Versionen ändern, da sich die Genauigkeit der internen Darstellung der Zahlen ändern kann.

Weitere Informationen

Equals(Object)

Gilt für:

CompareTo(Single)

Quelle:: Single.cs

Quelle:: Single.cs

Quelle:: Single.cs

Quelle:: Single.cs

Quelle:: Single.cs

Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit einfacher Genauigkeit und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert der angegebenen Gleitkommazahl mit einfacher Genauigkeit ist.

public:
 virtual int CompareTo(float value);

public int CompareTo(float value);

abstract member CompareTo : single -> int
override this.CompareTo : single -> int

Public Function CompareTo (value As Single) As Integer