Warum gibt> = false zurück, wenn == true für Nullwerte zurückgibt?

Ich habe zwei Variablen vom Typ int? (oder Nullable <int>, wenn Sie so wollen). Ich wollte einen Vergleich größer als oder gleich (> =) für die beiden Variablen durchführen, aber wie sich herausstellt, gibt dies false zurück, wenn beide Variablen null sind, während der Operator == offensichtlich true zurückgibt.

Kann mir jemand erklären, warum das logisch ist, weil die semantische Definition des Operators> = das Wort "oder" enthält?

Es gab eine große Debatte über diese Kuriosität, als das Feature ursprünglich in C # 2.0 entwickelt wurde. Das Problem ist, dass C # -Benutzer daran gewöhnt sind, dass dies sinnvoll ist:

if(someReference == null)

Wenn Sie die Gleichheit auf nullbare Werttypen erweitern, haben Sie folgende Möglichkeiten.

1. Die nullbare Gleichheit wird wirklich aufgehoben . Wenn einer oder beide Operanden null sind, ist das Ergebnis weder wahr noch falsch, sondern null. In diesem Fall können Sie entweder:

   • a) Machen Sie es illegal, in einer ifAnweisung eine Gleichheit vom Typ nullbarer Werte zu haben , da die ifAnweisung einen Bool benötigt, keinen nullbaren Bool. Fordern Sie stattdessen alle zur Verwendung auf, HasValuewenn sie mit null vergleichen möchten. Das ist ausführlich und irritierend.

   • b) Konvertieren Sie automatisch null in false. Der Nachteil dabei ist, dass x==nullfalse zurückgegeben wird, wenn x null ist. Dies ist verwirrend und wirkt dem Verständnis der Benutzer von Nullvergleichen mit Referenztypen entgegen.

2. Die nullbare Gleichheit wird nicht aufgehoben. Die nullbare Gleichheit ist entweder wahr oder falsch, und der Vergleich mit null ist eine Nullprüfung. Dies macht die nullbare Gleichheit mit der nullbaren Ungleichung unvereinbar.

Keine dieser Entscheidungen ist offensichtlich richtig; Sie alle haben Vor- und Nachteile. VBScript wählt zum Beispiel 1b. Nach langen Diskussionen entschied sich das C # -Design-Team für # 2.

Weil Gleichheit getrennt von Vergleichbarkeit definiert wird.
Sie können testen x == null, x > nullist aber bedeutungslos. In C # wird es immer falsch sein.

Eine andere Art, '> =' zu beschreiben, ist: Nicht weniger als. Keine Erwähnung von Gleichen. Sobald einer der Operanden in einem Nichtgleichheitstest Null ist, ist das Ergebnis ebenfalls unbekannt (ist Null). Wenn Sie jedoch wissen möchten, ob beide Operanden Null sind, ist Null == Null ein vernünftiger Test (sollte zu true führen). Die Beseitigung des Ungleichheitsteils des Operators macht den Unterschied.

Das folgende Codebeispiel von http://msdn.microsoft.com/en-us/library/2cf62fcy.aspx#sectionToggle4 fasst zusammen, wie C # Null behandelt:

int? num1 = 10;   
int? num2 = null;   
if (num1 >= num2)   
{   
    Console.WriteLine("num1 is greater than or equal to num2");   
}   
else   
{   
    // This clause is selected, but num1 is not less than num2.   
    Console.WriteLine("num1 >= num2 returned false (but num1 < num2 also is false)");   
}   

if (num1 < num2)   
{   
    Console.WriteLine("num1 is less than num2");   
}   
else   
{   
    // The else clause is selected again, but num1 is not greater than   
    // or equal to num2.   
    Console.WriteLine("num1 < num2 returned false (but num1 >= num2 also is false)");   
}   

if (num1 != num2)   
{   
    // This comparison is true, num1 and num2 are not equal.   
    Console.WriteLine("Finally, num1 != num2 returns true!");   
}   

// Change the value of num1, so that both num1 and num2 are null.   
num1 = null;   
if (num1 == num2)   
{   
    // The equality comparison returns true when both operands are null.   
    Console.WriteLine("num1 == num2 returns true when the value of each is null");   
}   

/* Output:   
 * num1 >= num2 returned false (but num1 < num2 also is false)   
 * num1 < num2 returned false (but num1 >= num2 also is false)   
 * Finally, num1 != num2 returns true!   
 * num1 == num2 returns true when the value of each is null   
 */   

>=arbeitet mit einem numerischen Wert; welche null ist nicht.

Sie können den Operator überladen>= , um das zu liefern, was Sie für einen bestimmten Typ wünschen.

NULL ist nicht Null (numerischer oder binärer Wert), eine Zeichenfolge mit der Länge Null oder leer (Zeichenwert). Jeder Vergleichsoperator gibt also immer false zurück. Lesen Sie hier mehr darüber

Welche Werte würden Sie erwarten?

null == null true

null> = null false

null> null false

null <= null false

null <null false

null! = null false

1 == null false

1> = null false

1> null false

1 <= null false

1 <null false

1! = Null true aka! (1 == null)

> = bedeutet nur "größer oder gleich", wenn es auf diese genau definierte Weise verwendet wird. Bei Verwendung in einer Klasse mit überladenen Operatoren bedeutet dies alles, was der Klassenentwickler möchte. Wenn es auf eine stringähnliche Klasse angewendet wird, bedeutet dies möglicherweise "gleich oder höher sortieren" oder "gleich lang oder länger".

Da ein standardmäßig intnicht null sein kann und sein Wert auf gesetzt 0wird int, erwartet der Operator von> und <, der für den Typ erstellt wurde, dass er mit valuesund nicht mit arbeitet nulls.

siehe meine Antwort auf eine ähnliche Frage , wo ich schrieb einige Möglichkeiten , um Griff nullable intmit den less <und greater >Betreibern https://stackoverflow.com/a/51507612/7003760