Почему допустимо объединять пустые строки, но нельзя вызывать «null.ToString ()»?

Это действительный код C #

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

Это недопустимый код C #

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

Почему первое утверждение действительно?

Причина первой работы:

Из MSDN :

В операциях конкатенации строк компилятор C # обрабатывает пустую строку так же, как пустую строку, но не преобразует значение исходной пустой строки.

Дополнительная информация о бинарном операторе + :

Бинарный оператор + выполняет конкатенацию строк, если один или оба операнда относятся к строковому типу.

Если операнд конкатенации строк равен нулю, подставляется пустая строка. В противном случае любой нестроковый аргумент преобразуется в его строковое представление путем вызова виртуального ToStringметода, унаследованного от объекта типа.

Если ToStringвозвращается null, подставляется пустая строка.

Причина ошибки в секундах:

null (справочник C #) - ключевое слово null - это литерал, представляющий пустую ссылку, не относящуюся ни к какому объекту. null - это значение по умолчанию для переменных ссылочного типа.

Поскольку +оператор в C # выполняет внутреннее преобразование в String.Concatстатический метод. И этот метод обрабатывается nullкак пустая строка. Если вы посмотрите на исходный код String.Concatв Reflector, вы увидите:

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

(MSDN тоже упоминает об этом: http://msdn.microsoft.com/en-us/library/k9c94ey1.aspx )

С другой стороны, ToString()это метод экземпляра, который нельзя вызвать null(для какого типа следует использовать null?).

Первый образец будет переведен на:

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

ConcatВходной метод проверки и перевести нуль как пустая строка

Второй образец будет переведен на:

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

Таким образом, здесь nullбудет сгенерировано ссылочное исключение

Первая часть вашего кода обрабатывается так же, как в String.Concat,

это то, что компилятор C # вызывает при добавлении строк. " abc" + nullпереводится на String.Concat("abc", null),

а внутри этот метод заменяется nullна String.Empty. Вот почему ваша первая часть кода не вызывает никаких исключений. это просто как

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

И во 2-й части вашего кода выдается исключение, потому что «null» не является объектом, ключевое слово null - это литерал, представляющий пустую ссылку , которая не ссылается ни на какой объект. null - это значение по умолчанию для переменных ссылочного типа.

И " ToString()" - это метод, который может быть вызван экземпляром объекта, но не любым литералом.

В структуре COM, предшествовавшей .NET, для любой подпрограммы, получившей строку, было необходимо освободить ее, когда она будет с ней выполнена. Поскольку пустые строки очень часто передавались в подпрограммы и из них, и поскольку попытка «освободить» нулевой указатель была определена как законная операция, не выполняющая никаких действий, Microsoft решила, что указатель нулевой строки представляет собой пустую строку.

Чтобы обеспечить некоторую совместимость с COM, многие подпрограммы в .net будут интерпретировать нулевой объект как законное представление как пустую строку. С парой небольших изменений .net и его языков (в первую очередь, позволяя членам экземпляра указывать «не вызывать как виртуальный»), Microsoft могла бы заставить nullобъекты объявленного типа String вести себя даже больше как пустые строки. Если бы Microsoft сделала это, ей также пришлось бы Nullable<T>работать несколько иначе (чтобы разрешить - Nullable<String>то, что они должны были сделать в любом случае, ИМХО) и / или определить NullableStringтип, который был бы в основном взаимозаменяемым String, но который не учитывал бы nullкак допустимая пустая строка.

Как бы то ни было, есть некоторые контексты, в которых a nullбудет рассматриваться как допустимая пустая строка, а в других - нет. Не очень полезная ситуация, но программисты должны знать о ней. Как правило, выражения формы stringValue.someMemberне работают, если они stringValueесть null, но большинство методов и операторов инфраструктуры, которые принимают строки в качестве параметров, будут рассматриваться nullкак пустая строка.

'+'- инфиксный оператор. Как и любой оператор, он действительно вызывает метод. Вы можете представить себе неинфиксную версию"wow".Plus(null) == "wow"

Примерно так решил исполнитель ...

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

Итак .. ваш пример становится

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

который совпадает с

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

Ни в коем случае значение null не становится строкой. Так null.ToString()что ничем не отличается null.VoteMyAnswer(). ;)

Я думаю, потому что это литерал, который не относится ни к какому объекту. ToString()нужен object.

Кто-то сказал в этой ветке обсуждения, что вы не можете сделать строку из ничего. (что, на мой взгляд, хорошая фраза). Но да - вы можете :-), как показывает следующий пример:

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

отлично работает и вообще не вызывает исключения. Единственное отличие состоит в том, что вам нужно преобразовать один из нулей в строку - если вы удалите приведение (string) , то пример все равно компилируется, но выдает исключение времени выполнения: «Оператор '+' неоднозначен для операндов введите '<null>' и '<null>' ".

NB. В приведенном выше примере кода значение x не равно нулю, как вы могли ожидать, это фактически пустая строка после преобразования одного из операндов в строку.

Другой интересный факт заключается в том, что в C # / .NET способ nullобработки не всегда одинаков, если рассматривать разные типы данных. Например:

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

Что касается 1-й строки фрагмента кода: если xэто целочисленная переменная, допускающая значение NULL (т. Е. int?), Содержащая значение 1, то вы получаете результат <null>обратно. Если это строка (как показано в комментарии) со значением "1", то вы "1"скорее возвращаетесь, чем <null>.

NB Также интересно: если вы используете var x = 1;для первой строки, вы получаете ошибку времени выполнения. Зачем? Поскольку присвоение превратит переменную xв тип данных int, который не допускает значения NULL. Компилятор здесь не предполагает int?, и, следовательно, не работает во второй строке, где nullдобавлено.

Добавление nullв строку просто игнорируется. null(в вашем втором примере) не является экземпляром какого-либо объекта, поэтому у него даже нет ToString()метода. Это просто буквально.

Потому что нет разницы между string.Emptyи, nullкогда вы объединяете строки. Вы также можете передать null string.Format. Но вы пытаетесь вызвать метод null, который всегда приводит к NullReferenceExceptionвозникновению ошибки компилятора.
Если по какой-то причине вы действительно хотите это сделать, вы можете написать метод расширения, который проверяет, nullа затем возвращает string.Empty. Но такое расширение следует использовать только в случае крайней необходимости (на мой взгляд).

В общем: это может быть или не быть допустимым, принимая значение null в качестве параметра в зависимости от спецификации, но всегда недопустимо вызывать метод для null.

Это и другая тема, почему операнды оператора + могут быть нулевыми в случае строк. Это что-то вроде VB (извините, ребята), чтобы облегчить жизнь программистам, или предположим, что программист не может иметь дело с нулями. Я полностью не согласен с этой спецификацией. "unknown" + "something" должно оставаться "unknown" ...