Инициализация строки по умолчанию: NULL или пустой? [закрытый]

по данным MSDN:

инициализация строк Empty вместо null, вы можете уменьшить шансы NullReferenceException происходит.

всегда использовать IsNullOrEmpty() это хорошая практика, тем не менее.

почему вы хотите, чтобы ваши строки инициализации вообще? Вам не нужно инициализировать переменную, когда вы ее объявляете, и IMO, вы должны делать это только тогда, когда значение, которое вы назначаете, допустимо в контексте блока кода.

Я вижу это много:

string name = null; // or String.Empty
if (condition)
{
  name = "foo";
}
else
{
  name = "bar";
}

return name;

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

string name = null; // or String.Empty
if (condition)
{
  name = "foo";
}
else if (othercondition)
{
  name = "bar";
}

return name; //returns null when condition and othercondition are false

Если вы не инициализируете значение null, компилятор выдаст ошибку, сообщающую, что не все пути кода присваивают значение. Конечно, это очень простой пример...

Matthijs

для большинства программ, которые на самом деле не являются программным обеспечением для обработки строк, логика программы не должна зависеть от содержимого строковых переменных. Всякий раз, когда я вижу что-то подобное в программе:

if (s == "value")

у меня плохое предчувствие. Почему в этом методе есть строковый литерал? Что такое настройка s? Знает ли он, что логика зависит от значения строки? Знает ли он, что он должен быть строчным, чтобы работать? Я должен исправить это, изменив его на использование String.Compare? Должен Я создаю Enum и разбор в нем?

С этой точки зрения можно перейти к философии кода, которая довольно проста: вы избегаете изучения содержимого строки, где это возможно. Сравнение строки с String.Empty на самом деле это просто частный случай сравнения его с литералом: это то, чего следует избегать, если вам действительно не нужно.

зная это, я не моргаю, когда вижу что-то вроде этого в коде:

string msg = Validate(item);
if (msg != null)
{
   DisplayErrorMessage(msg);
   return;
}

Я знаю, что Validate никогда больше не вернется String.Empty, потому что мы пишем лучший код, чем это.

конечно, остальной мир так не работает. Когда ваша программа имеет дело с пользовательским вводом, базами данных, файлами и т. д., Вы должны учитывать другие философии. Там, это работа вашего кода, чтобы наложить порядок на хаос. Часть этого порядка знает, когда пустая строка должна означать String.Empty и когда это должно означать null.

(просто чтобы убедиться, что я не говорил из моей задницы, я просто искал нашу кодовую базу для ' String.IsNullOrEmpty'. Все 54 его вхождения находятся в методах, которые обрабатывают пользовательский ввод, возвращают значения из скриптов Python, проверяют значения, полученные из внешних API, и т. д.)

Это зависит.

вы должны быть в состоянии сказать, если значение отсутствует (возможно ли, чтобы он не был определен)?

пустая строка является допустимым значением для использования этой строки?

Если вы ответили "да" на оба вопроса, Вы хотите использовать null. В противном случае вы не можете сказать разницу между "нет значения" и "пустая строка".

Если вам не нужно знать, если нет значения, то пустая строка, вероятно, безопаснее, так как это позволяет вам чтобы пропустить нулевые проверки везде, где вы его используете.

Это на самом деле зияющая дыра в языке C#. Невозможно определить строку, которая не может быть null. Это приводит к проблемам, столь же простым, как и тот, который вы описываете, что заставляет программистов принимать решение, которое им не нужно делать, поскольку во многих случаях NULL и String.Пустые означают то же самое. Это, в свою очередь, может позже заставить других программистов обрабатывать как NULL, так и String.Пусто, что раздражает.

большая проблема заключается в том, что базы данных позволяют определите поля, которые сопоставляются со строкой C#, но поля базы данных могут быть определены как NOT NULL. Таким образом, нет способа точно представить, скажем, поле varchar( 100 ) NOT NULL в SQL Server с использованием типа C#.

другие языки, такие как Spec#, позволяют это.

на мой взгляд, неспособность C#определить строку, которая не позволяет null, так же плоха, как и ее предыдущая неспособность определить int, который позволяет null.

чтобы полностью ответить на ваш вопрос: я всегда используйте пустую строку для инициализации по умолчанию, потому что это больше похоже на то, как работают типы данных базы данных. (Edit: это утверждение было очень неясным. Он должен читать "я использую пустую строку для инициализации по умолчанию, когда NULL является избыточным состоянием, точно так же, как я настраиваю столбец базы данных как NOT NULL, если NULL будет избыточным состоянием. Точно так же многие из моих столбцов БД настроены как NOT NULL, поэтому, когда я привожу их в строку C#, строка будет пустой или иметь значение, но никогда не будет НОЛЬ. Другими словами, Я инициализирую строку только в NULL, если null имеет значение, отличное от значения String.Пустой, и я считаю, что этот случай менее распространен (но люди здесь привели законные примеры этого случая).")

похоже, что это частный случай http://en.wikipedia.org/wiki/Null_Object_pattern

Я либо установить его в "" или null-я всегда проверяю с помощью строки.IsNullOrEmpty, так что либо хорошо.

но внутренний выродок во мне говорит, что я должен установить его в null, прежде чем у меня будет правильное значение для него...

Я всегда объявляю строку со строкой.пусто;

возможно ли, что это метод предотвращения ошибок (желательно или нет..)? Поскольку "" все еще является строкой, вы могли бы вызвать строковые функции на ней, что привело бы к исключению, если бы оно было NULL?

Я всегда инициализирую их как NULL.

Я всегда использовать string.IsNullOrEmpty(someString) чтобы проверить его значение.

простой.

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

Я только устанавливаю строку в null, когда мне нужно знать, была ли она установлена или нет, и где пустая строка является чем-то допустимым для ее установки. На практике я нахожу такие ситуации редкими.

пустая строка-это значение (фрагмент текста, который, кстати, не содержит никаких букв). Null означает отсутствие значения.

Я инициализирую переменные в null, когда хочу указать, что они не указывают или не содержат фактических значений - когда намерение не имеет значения.

повторяя ответ Tomalak, имейте в виду, что когда вы присваиваете строковой переменной начальное значение null, ваша переменная больше не является строковым объектом; то же самое с любым объектом в C#. Таким образом, если вы попытаетесь получить доступ к любым методам или свойствам для своей переменной, и вы предполагаете, что это строковый объект, вы получите исключение NullReferenceException.

Null следует использовать только в тех случаях, когда значение является необязательным. Если значение не является необязательным (например, " имя " или "адрес"), то значение никогда не должно быть null. Это относится к базам данных, а также к POCOs и пользовательскому интерфейсу. Null означает " это значение является необязательным и в настоящее время отсутствует."

Если поле не является обязательным, то вы должны инициализировать его как пустую строку. Чтобы инициализировать его как null, ваш объект будет помещен в недопустимое состояние (недопустимое по вашим собственным данным модель.)

лично я бы предпочел, чтобы строки не были nullable по умолчанию, но вместо этого только nullable если мы объявим "string?". Хотя, возможно, это неосуществимо или логично на более глубоком уровне; не уверен.

строки не являются типами значений и никогда не будут ; -)

Я думаю, что нет причин не использовать null для неназначенного (или в этом месте в потоке программы не происходит) значения. Если вы хотите отличить, есть ==null. Если вы просто хотите проверить определенное значение и не волнует, является ли это null или что-то другое, String.Equals ("XXX", MyStringVar) делает просто отлично.