Warum ist es gültig, Nullzeichenfolgen zu verketten, aber nicht "null.ToString ()" aufzurufen?

Dies ist ein gültiger C # -Code

var bob = "abc" + null + null + null + "123";  // abc123

Dies ist kein gültiger C # -Code

var wtf = null.ToString(); // compiler error

Warum ist die erste Aussage gültig?

Der Grund für die erste Arbeit:

Von MSDN :

Bei Verkettungsoperationen von Zeichenfolgen behandelt der C # -Compiler eine Nullzeichenfolge genauso wie eine leere Zeichenfolge, konvertiert jedoch nicht den Wert der ursprünglichen Nullzeichenfolge.

Weitere Informationen zum + Binäroperator :

Der Operator binär + führt eine Zeichenfolgenverkettung durch, wenn einer oder beide Operanden vom Typ Zeichenfolge sind.

Wenn ein Operand der Zeichenfolgenverkettung null ist, wird eine leere Zeichenfolge ersetzt. Andernfalls wird jedes Nicht-String-Argument durch Aufrufen der ToStringvom Typ-Objekt geerbten virtuellen Methode in seine String-Darstellung konvertiert .

Wenn ToStringzurückgegeben wird null, wird eine leere Zeichenfolge ersetzt.

Der Grund für den Fehler in der Sekunde ist:

null (C # -Referenz) - Das Schlüsselwort null ist ein Literal, das eine Nullreferenz darstellt, die sich nicht auf ein Objekt bezieht. null ist der Standardwert von Variablen vom Referenztyp.

Weil der +Operator in C # intern in übersetzt String.Concat, was eine statische Methode ist. Und diese Methode wird zufällig nullwie eine leere Zeichenfolge behandelt. Wenn Sie sich die Quelle von String.Concatin Reflector ansehen , werden Sie es sehen:

// while looping through the parameters
strArray[i] = (str == null) ? Empty : str;
// then concatenate that string array

(MSDN erwähnt es auch: http://msdn.microsoft.com/en-us/library/k9c94ey1.aspx )

Auf der anderen Seite ToString()handelt es sich um eine Instanzmethode, die Sie nicht aufrufen können null(für welchen Typ sollte sie verwendet werden null?).

Das erste Beispiel wird übersetzt in:

var bob = String.Concat("abc123", null, null, null, "abs123");

Die ConcatMethode überprüft die Eingabe und übersetzt null als leere Zeichenfolge

Das zweite Beispiel wird übersetzt in:

var wtf = ((object)null).ToString();

Hier wird also eine nullReferenzausnahme generiert

Der erste Teil Ihres Codes wird einfach so behandelt in String.Concat,

Dies ist, was der C # -Compiler aufruft, wenn Sie Zeichenfolgen hinzufügen. " abc" + nullwird übersetzt in String.Concat("abc", null),

und intern ersetzt diese Methode nulldurch String.Empty. Deshalb löst Ihr erster Teil des Codes keine Ausnahme aus. es ist einfach so

var bob = "abc" + string.Empty + string.Empty + string.Empty + "123";  //abc123

Und im zweiten Teil Ihres Codes wird eine Ausnahme ausgelöst, da 'null' kein Objekt ist. Das Schlüsselwort null ist ein Literal, das eine Nullreferenz darstellt , die auf kein Objekt verweist. null ist der Standardwert von Variablen vom Referenztyp.

Und ' ToString()' ist eine Methode, die von einer Instanz eines Objekts aufgerufen werden kann, jedoch kein Literal.

In dem COM-Framework, das vor .net stand, musste jede Routine, die eine Zeichenfolge erhielt, diese freigeben, wenn sie damit fertig war. Da es sehr häufig vorkam, dass leere Zeichenfolgen in Routinen und aus Routinen übergeben wurden und der Versuch, einen Nullzeiger "freizugeben", als legitime Nichtstun-Operation definiert wurde, entschied Microsoft, dass ein Nullzeichenfolgenzeiger eine leere Zeichenfolge darstellt.

Um eine gewisse Kompatibilität mit COM zu gewährleisten, interpretieren viele Routinen in .net ein Nullobjekt als rechtliche Darstellung als leere Zeichenfolge. Mit ein paar geringfügigen Änderungen an .net und seinen Sprachen (insbesondere wenn Instanzmitglieder angeben können, dass sie nicht als virtuell aufgerufen werden sollen) hätte Microsoft nullObjekte vom deklarierten Typ String noch mehr wie leere Strings verhalten können. Wenn Microsoft das getan hätte, hätte es auch die Nullable<T>Arbeit etwas anders gestalten müssen (um zuzulassen - etwas, Nullable<String>was sie meiner Meinung nach sowieso hätten tun sollen) und / oder einen NullableStringTyp definieren müssen, der größtenteils austauschbar Stringwäre, aber a nicht berücksichtigt nullals gültige leere Zeichenfolge.

So wie es ist, gibt es einige Kontexte, in denen ein nullWille als legitimer leerer String angesehen wird, und andere, in denen dies nicht der Fall ist. Keine schrecklich hilfreiche Situation, aber eine, die Programmierer kennen sollten. Im Allgemeinen schlagen Ausdrücke des Formulars stringValue.someMemberfehl, wenn dies der Fall stringValueist null. Die meisten Framework-Methoden und -Operatoren, die Zeichenfolgen als Parameter akzeptieren, werden jedoch nullals leere Zeichenfolge betrachtet.

'+'ist ein Infix-Operator. Wie jeder Operator ruft er wirklich eine Methode auf. Sie können sich eine Nicht-Infix-Version vorstellen"wow".Plus(null) == "wow"

Der Implementierer hat sich für so etwas entschieden ...

class String
{
  ...
  String Plus(ending)
  {
     if(ending == null) return this;
     ...
  }
} 

Also ... dein Beispiel wird

var bob = "abc".Plus(null).Plus(null).Plus(null).Plus("123");  // abc123

das ist das gleiche wie

var bob = "abc".Plus("123");  // abc123

Null wird zu keinem Zeitpunkt zu einer Zeichenfolge. Das null.ToString()ist also nicht anders null.VoteMyAnswer(). ;)

Ich denke, weil es ein Literal ist, das sich auf kein Objekt bezieht. ToString()braucht eine object.

Jemand sagte in diesem Diskussionsthread, dass man aus nichts einen String machen kann. (Das ist ein schöner Satz, wie ich denke). Aber ja - Sie können :-), wie das folgende Beispiel zeigt:

var x = null + (string)null;     
var wtf = x.ToString();

funktioniert gut und löst überhaupt keine Ausnahme aus. Der einzige Unterschied besteht darin, dass Sie eine der Nullen in eine Zeichenfolge umwandeln müssen. Wenn Sie die Umwandlung (Zeichenfolge) entfernen , wird das Beispiel weiterhin kompiliert, es wird jedoch eine Laufzeitausnahme ausgelöst : "Operator '+' ist für Operanden von nicht eindeutig Geben Sie '<null>' und '<null>' "ein.

Hinweis: Im obigen Codebeispiel ist der Wert von x nicht wie erwartet null, sondern eine leere Zeichenfolge, nachdem Sie einen der Operanden in eine Zeichenfolge umgewandelt haben.

Eine weitere interessante Tatsache ist, dass in C # / .NET die nullBehandlung nicht immer gleich ist, wenn Sie unterschiedliche Datentypen betrachten. Beispielsweise:

int? x = 1;  //  string x = "1";
x = x + null + null;
Console.WriteLine((x==null) ? "<null>" : x.ToString());

Betrachten Sie die erste Zeile des Code-Snippets: Wennx es sich um eine nullbare Ganzzahlvariable (dh int?) handelt, die einen Wert enthält 1, erhalten Sie das Ergebnis <null>zurück. Wenn es sich um eine Zeichenfolge (wie im Kommentar gezeigt) mit Wert handelt "1", erhalten Sie "1"eher zurück als <null>.

NB Auch interessant: Wenn Sie var x = 1;für die erste Zeile verwenden, wird ein Laufzeitfehler angezeigt. Warum? Weil die Zuweisung die Variable xin den Datentyp verwandelt int, der nicht nullwertfähig ist. Der Compiler geht hier nicht davon int?aus und schlägt daher in der 2. Zeile wo fehlnull hinzugefügt wird.

Das Hinzufügen nullzu einer Zeichenfolge wird einfach ignoriert. null(in Ihrem zweiten Beispiel) ist keine Instanz eines Objekts, daher gibt es nicht einmal eine ToString()Methode. Es ist nur ein Wortlaut.

Weil es keinen Unterschied zwischen string.Emptyund nullwann Sie Zeichenfolgen konkatieren. Sie können auch null übergeben string.Format. Sie versuchen jedoch, eine Methode aufzurufen null, die immer zu a führt NullReferenceExceptionund daher einen Compilerfehler generiert.
Wenn Sie es aus irgendeinem Grund wirklich tun möchten, können Sie eine Erweiterungsmethode schreiben, die nach sucht nullund dann zurückgibt string.Empty. Eine solche Erweiterung sollte aber nur verwendet werden, wenn dies absolut notwendig ist (meiner Meinung nach).

Allgemein: Je nach Spezifikation kann es gültig sein, null als Parameter zu akzeptieren, aber es ist immer ungültig, eine Methode für null aufzurufen.

Dies ist ein weiteres Thema, warum die Operanden des Operators + bei Zeichenfolgen null sein können. Dies ist eine Art VB-Sache (sorry Leute), um Programmierern das Leben zu erleichtern, oder wenn der Programmierer nicht mit Nullen umgehen kann. Ich stimme dieser Spezifikation überhaupt nicht zu. 'unbekannt' + 'irgendetwas' sollte immer noch 'unbekannt' sein ...