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

Я всегда инициализировал свои строки в NULL, думая, что NULL означает отсутствие значения, и значение «” или String.Empty является допустимым значением. В последнее время я видел больше примеров кода, где String.Empty считается значением по умолчанию или не представляет значения. Это кажется мне странным, поскольку новые добавленные типы с нулевым значением в c # кажется, что мы делаем шаги назад с помощью строк, не используя NULL для представления «Нет значения».

Что вы используете в качестве инициализатора по умолчанию и почему?

Редактировать: Основываясь на ответах, я буду дальше своих дальнейших мыслей

  1. Избегайте обработки ошибок. Если значение не должно быть пустым, почему оно было установлено в NULL в первую очередь? Возможно, было бы лучше определить ошибку в том месте, где она происходит, а не покрывать ее остальной частью вашей кодовой базы?

  2. Избегание нулевых проверок Если вы устали от выполнения нулевых проверок в коде, не лучше ли абстрагировать нулевые проверки? Возможно, оберните (или продолжите!) Строковые методы, чтобы сделать их NULL безопасными? Что произойдет, если вы постоянно используете String.Empty и нуль, похоже, работает в вашей системе, вы все NULL начинаете добавлять NULL ?

Я не могу не вернуться к мнению, что это лень. Любой администратор базы данных пошлет вам девять способов глупости, если вы использовали «вместо null в своей базе данных. Я думаю, что одни и те же принципы применяются в программировании, и кто-то должен удалять их вверх головой, которые используют String.Empty а не NULL чтобы не представлять значения.

Связанные вопросы

  • В C # следует использовать string.Empty или String.Empty или “”?
  • В чем разница между String.Empty и “”
  • Нулевая или пустая строка для представления данных в столбце таблицы?

+1 для различения «пустой» и NULL. Я согласен, что «пустой» должен означать «действительный, но пустой» и «NULL» должен означать «недействительный».

Поэтому я бы ответил на ваш вопрос следующим образом:

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

NULL, если это ошибка, если следующий код не задает значение явно.

Согласно MSDN :

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

IsNullOrEmpty() не менее, всегда используется IsNullOrEmpty() .

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

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

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

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

 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") 

У меня плохое чувство. Почему в этом методе есть строковый литерал? Что такое настройка? Знает ли он, что логика зависит от значения строки? Знает ли он, что для работы должно быть более строгим? Должен ли я исправлять это, изменив его на использование 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. В противном случае вы не можете определить разницу между «no value» и «empty string».

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

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

Большая проблема заключается в том, что базы данных позволяют вам определять поля, которые сопоставляются с строкой 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 если значение null имеет значение, отличное от значения String.Empty, и я считаю, что случай будет меньше обычного (но люди здесь дали законные примеры этого случая).)

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

Я либо устанавливаю его на «”, либо null – я всегда проверяю, используя String.IsNullOrEmpty, так что все нормально.

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

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

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

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

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

Просто.

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

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

Пустая строка – это значение (fragment текста, который, кстати, не содержит букв). Null означает значение no.

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

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

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

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

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

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

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

  • Вызовите функции Go из C
  • Каков порядок инициализации статической переменной в C #?
  • Обработка проверки ModelState в веб-интерфейсе ASP.NET
  • Поля для участников, порядок строительства
  • Универсальный меньше для указателей в стандарте C ++
  • Почему я не могу использовать методы System.IO.File в controllerе MVC?
  • Как я могу узнать, когда истечет время ожидания HttpClient?
  • Операторы string.Equals () и == действительно одинаковы?
  • FindAll vs Где метод расширения
  • Попытка отладки приложения Windows Store из файлов дампа
  • Разблокировать файл из .net 4 c #
  • Давайте будем гением компьютера.