Warum ist der Standardwert des Zeichenfolgentyps null anstelle einer leeren Zeichenfolge?

Es ist ziemlich ärgerlich alle für meine Saiten zu testen , nullbevor ich Methoden sicher anwenden kann , wie ToUpper(), StartWith()etc ...

Wenn der Standardwert von stringdie leere Zeichenfolge wäre, müsste ich nicht testen, und ich würde das Gefühl haben, dass er mit den anderen Werttypen wie intoder doublezum Beispiel konsistenter ist . Zusätzlich Nullable<String>würde Sinn machen.

Warum haben sich die Designer von C # für die Verwendung nullals Standardwert für Zeichenfolgen entschieden?

Hinweis: Dies bezieht sich auf diese Frage , konzentriert sich jedoch mehr auf das Warum als auf das, was damit zu tun ist.

Warum ist der Standardwert des Zeichenfolgentyps null anstelle einer leeren Zeichenfolge?

Da stringist ein Referenztyp und der Standardwert für alle Referenztypen ist null.

Es ist ziemlich ärgerlich, alle meine Zeichenfolgen auf Null zu testen, bevor ich Methoden wie ToUpper (), StartWith () usw. sicher anwenden kann.

Dies steht im Einklang mit dem Verhalten von Referenztypen. Vor dem Aufrufen ihrer Instanzmitglieder sollte eine Überprüfung auf eine Nullreferenz vorgenommen werden.

Wenn der Standardwert der Zeichenfolge die leere Zeichenfolge wäre, müsste ich sie nicht testen, und ich würde der Meinung sein, dass sie mit den anderen Werttypen wie beispielsweise int oder double konsistenter ist.

Das Zuweisen des Standardwerts zu einem bestimmten Referenztyp null, der nicht inkonsistent wäre .

Zusätzlich Nullable<String>würde Sinn machen.

Nullable<T>arbeitet mit den Werttypen. Bemerkenswert ist die Tatsache, dass sie Nullablenicht auf der ursprünglichen .NET-Plattform eingeführt wurde, so dass es viel fehlerhaften Code gegeben hätte, wenn sie diese Regel geändert hätten. ( Mit freundlicher Genehmigung von @jcolebrand )

Habib hat recht - weil stringes sich um einen Referenztyp handelt.

Noch wichtiger ist jedoch, dass Sie nichtnull jedes Mal nachsehen müssen, wenn Sie es verwenden. Sie sollten wahrscheinlich ArgumentNullExceptioneine nullReferenz werfen, wenn jemand Ihre Funktion übergibt .

Hier ist die Sache - das Framework würde NullReferenceExceptionsowieso ein für Sie werfen, wenn Sie versuchen würden, .ToUpper()eine Zeichenfolge aufzurufen . Denken Sie daran, dass dieser Fall auch dann auftreten kann, wenn Sie Ihre Argumente testen, nullda eine Eigenschaft oder Methode für die Objekte, die als Parameter an Ihre Funktion übergeben werden, ausgewertet werden kann null.

That being said, für leere Strings oder nulls Überprüfung eine gemeinsame Sache zu tun ist , so bieten sie String.IsNullOrEmpty()und String.IsNullOrWhiteSpace()nur für diesen Zweck.

Sie könnten eine Erweiterungsmethode schreiben (für das, was es wert ist):

public static string EmptyNull(this string str)
{
    return str ?? "";
}

Das funktioniert jetzt sicher:

string str = null;
string upper = str.EmptyNull().ToUpper();

Ab C # 6.0 können Sie auch Folgendes verwenden

string myString = null;
string result = myString?.ToUpper();

Das String-Ergebnis ist null.

Leere Zeichenfolgen und Nullen unterscheiden sich grundlegend. Eine Null ist das Fehlen eines Werts und eine leere Zeichenfolge ist ein Wert, der leer ist.

Die Programmiersprache, die Annahmen über den "Wert" einer Variablen, in diesem Fall eine leere Zeichenfolge, trifft, ist so gut wie das Initiieren der Zeichenfolge mit einem anderen Wert, der kein Nullreferenzproblem verursacht.

Wenn Sie das Handle an diese Zeichenfolgenvariable an andere Teile der Anwendung übergeben, kann dieser Code nicht überprüfen, ob Sie absichtlich einen leeren Wert übergeben haben oder vergessen haben, den Wert dieser Variablen aufzufüllen.

Eine andere Möglichkeit, bei der dies ein Problem darstellen würde, besteht darin, dass die Zeichenfolge ein Rückgabewert einer Funktion ist. Da string ein Referenztyp ist und technisch einen Wert wie null und leer haben kann, kann die Funktion auch technisch null oder leer zurückgeben (nichts hindert sie daran). Da es nun zwei Begriffe für das "Fehlen eines Werts" gibt, dh eine leere Zeichenfolge und eine Null, muss der gesamte Code, der diese Funktion verwendet, zwei Überprüfungen durchführen. Einer für leer und der andere für null.

Kurz gesagt, es ist immer gut, nur eine Darstellung für einen einzelnen Staat zu haben. Weitere Informationen zu Leerzeichen und Nullen finden Sie unter den folgenden Links.

/software/32578/sql-empty-string-vs-null-value

NULL vs Leer beim Umgang mit Benutzereingaben

Der grundlegende Grund / das grundlegende Problem besteht darin, dass die Designer der CLS-Spezifikation (die definiert, wie Sprachen mit .net interagieren) kein Mittel definiert haben, mit dem Klassenmitglieder festlegen können, dass sie direkt und nicht über aufgerufen werden müssen callvirt, ohne dass der Aufrufer a ausführt Nullreferenzprüfung; Es bot auch keine Möglichkeit, Strukturen zu definieren, die keinem "normalen" Boxen unterliegen würden.

Hätte die CLS-Spezifikation ein solches Mittel definiert, wäre es für .net möglich, konsequent dem vom Common Object Model (COM) festgelegten Vorsprung zu folgen, unter dem eine Nullzeichenfolgenreferenz als semantisch äquivalent zu einer leeren Zeichenfolge angesehen wurde, und für andere Benutzerdefinierte unveränderliche Klassentypen, die eine Wertsemantik haben sollen, um ebenfalls Standardwerte zu definieren. Was im Wesentlichen passieren würde, wäre, dass jedes Mitglied von String, z. B. Lengthals so etwas geschrieben wird [InvokableOnNull()] int String Length { get { if (this==null) return 0; else return _Length;} }. Dieser Ansatz hätte eine sehr schöne Semantik für Dinge geboten, die sich wie Werte verhalten sollten, aber aufgrund von Implementierungsproblemen auf dem Heap gespeichert werden müssen. Die größte Schwierigkeit bei diesem Ansatz besteht darin, dass die Semantik der Konvertierung zwischen solchen Typen Objectetwas trübe werden kann.

Ein alternativer Ansatz wäre gewesen, die Definition spezieller Strukturtypen zu ermöglichen, die nicht von geerbten, Objectsondern benutzerdefinierte Box- und Unboxing-Operationen erbten (die in einen anderen Klassentyp konvertiert wurden). Bei einem solchen Ansatz würde es einen Klassentyp geben, NullableStringder sich jetzt wie eine Zeichenfolge verhält, und einen Strukturtyp mit benutzerdefinierten Boxen String, der ein einzelnes privates Feld Valuevom Typ enthält String. Der Versuch, a Stringin NullableStringoder zu konvertieren , wird Objectzurückgegeben, Valuewenn er nicht null oder String.Emptynull ist. Beim Versuch, Stringin eine NullableStringInstanz umzuwandeln, die nicht null ist , wird die Referenz in Valuegespeichert (möglicherweise wird null gespeichert, wenn die Länge null ist). Das Wirken einer anderen Referenz würde eine Ausnahme auslösen.

Obwohl Zeichenfolgen auf dem Heap gespeichert werden müssen, gibt es konzeptionell keinen Grund, warum sie sich nicht wie Werttypen verhalten sollten , die einen Standardwert ungleich Null haben. Wenn sie als "normale" Struktur gespeichert worden wären, die eine Referenz enthielt, wäre dies für Code, der sie als Typ "Zeichenfolge" verwendete, effizient gewesen, hätte jedoch beim Umwandeln in "Objekt" eine zusätzliche Ebene der Indirektion und Ineffizienz hinzugefügt. Obwohl ich nicht vorsehe, dass .net zu diesem späten Zeitpunkt eine der oben genannten Funktionen hinzufügt, könnten Designer zukünftiger Frameworks in Betracht ziehen, sie einzubeziehen.

Da eine Zeichenfolgenvariable eine Referenz und keine Instanz ist .

Eine standardmäßige Initialisierung auf "Leer" wäre möglich gewesen, hätte jedoch auf der ganzen Linie viele Inkonsistenzen verursacht.

Warum haben die Designer von C # null als Standardwert für Zeichenfolgen verwendet?

Da Zeichenfolgen Referenztypen sind , sind Referenztypen Standardwerte null. Variablen von Referenztypen speichern Verweise auf die tatsächlichen Daten.

Verwenden wir defaultfür diesen Fall das Schlüsselwort.

string str = default(string); 

strist a string, also ist es ein Referenztyp , also ist der Standardwert null.

int str = (default)(int);

strist ein int, also ist es ein Werttyp , also ist der Standardwert zero.

Wenn der Standardwert von stringdie leere Zeichenfolge wäre, müsste ich nicht testen

Falsch! Das Ändern des Standardwerts ändert nichts an der Tatsache, dass es sich um einen Referenztyp handelt und jemand die Referenz weiterhin explizit festlegen kann null.

Zusätzlich Nullable<String>würde Sinn machen.

Wahrer Punkt. Es wäre sinnvoller, nullkeine Referenztypen zuzulassen , sondern diese Funktion zu benötigen Nullable<TheRefType>.

Warum haben sich die Designer von C # für die Verwendung nullals Standardwert für Zeichenfolgen entschieden?

Konsistenz mit anderen Referenztypen. Warum überhaupt nullReferenztypen zulassen ? Wahrscheinlich, damit es sich wie C anfühlt, obwohl dies eine fragwürdige Entwurfsentscheidung in einer Sprache ist, die auch bietet Nullable.

Wenn Sie ??beim Zuweisen Ihrer Zeichenfolgenvariablen den Operator verwenden, kann dies möglicherweise hilfreich sein.

string str = SomeMethodThatReturnsaString() ?? "";
// if SomeMethodThatReturnsaString() returns a null value, "" is assigned to str.

Ein String ist ein unveränderliches Objekt. Wenn ein Wert angegeben wird, wird der alte Wert nicht aus dem Speicher gelöscht, sondern verbleibt am alten Speicherort, und der neue Wert wird an einem neuen Speicherort abgelegt. Also , wenn der Standardwert String awar String.Empty, würde es den Abfall String.EmptyBlock im Speicher , wenn er seinen ersten Wert gegeben wurde.

Obwohl es winzig erscheint, kann es beim Initialisieren eines großen Arrays von Zeichenfolgen mit Standardwerten von zu einem Problem werden String.Empty. Natürlich können Sie immer die veränderbare StringBuilderKlasse verwenden, wenn dies ein Problem sein sollte.

Da string ein Referenztyp ist und der Standardwert für den Referenztyp null ist.

Vielleicht hat Sie das stringSchlüsselwort verwirrt, da es genau wie jede andere Werttypdeklaration aussieht , aber es ist tatsächlich ein Alias ​​für, System.Stringwie in dieser Frage erläutert .
Auch die dunkelblaue Farbe in Visual Studio und der Kleinbuchstabe können irreführen, wenn man denkt, dass es sich um eine handelt struct.

Nullable-Typen kamen erst in 2.0.

Wenn am Anfang der Sprache nullbare Typen erstellt worden wären, wäre die Zeichenfolge nicht nullwertfähig und die Zeichenfolge? wäre nullbar gewesen. Aufgrund der Abwärtskompatibilität konnten sie dies jedoch nicht tun.

Viele Leute sprechen über Ref-Typ oder nicht Ref-Typ, aber String ist eine ungewöhnliche Klasse und es wären Lösungen gefunden worden, um dies zu ermöglichen.