В чем разница между строкой и строкой в С#?

Пример (обратите внимание на случай):

string s = "Hello world!";
String s = "Hello world!";

Каковы рекомендации по использованию каждого из них? И в чем отличия?

Ответ 1

string является псевдонимом в С# для System.String.
Технически, нет никакой разницы. Это как int против System.Int32.

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

например

string place = "world";

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

например

string greet = String.Format("Hello {0}!", place);

Это стиль, который Microsoft стремится использовать в своих примерах.

Похоже, что руководство в этой области, возможно, изменилось, поскольку StyleCop теперь обеспечивает использование псевдонимов, специфичных для С#.

Ответ 2

Просто ради полноты, здесь мозговой свалкой связанной информации...

Как отмечали другие, string является псевдонимом для System.String. Они компилируются в один и тот же код, поэтому во время выполнения нет никакой разницы. Это всего лишь один из псевдонимов на С#. Полный список:

object:  System.Object
string:  System.String
bool:    System.Boolean
byte:    System.Byte
sbyte:   System.SByte
short:   System.Int16
ushort:  System.UInt16
int:     System.Int32
uint:    System.UInt32
long:    System.Int64
ulong:   System.UInt64
float:   System.Single
double:  System.Double
decimal: System.Decimal
char:    System.Char

Помимо string и object, все псевдонимы относятся ко всем типам значений. decimal - это тип значения, но не примитивный тип в CLR. Единственный примитивный тип, который не имеет псевдонима, - System.IntPtr.

В спецификации, псевдонимы типа значения известны как "простые типы". Литералы могут использоваться для постоянных значений каждого простого типа; никакие другие типы значений не имеют доступных литералов. (Сравните это с VB, который позволяет использовать литералы DateTime и имеет для него псевдоним.)

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

public enum Foo : UInt32 {} // Invalid
public enum Bar : uint   {} // Valid

Это просто вопрос того, как спецификация определяет объявления перечислений - часть после двоеточия должно быть производство интегрального типа, который один знак sbyte, byte, short, ushort, int, uint, long, ulong, char... в отличие от производства типа, используемого, например, объявлениями переменных. Это не указывает на другую разницу.

Наконец, когда дело доходит до использования: лично я использую псевдонимы везде для реализации, но тип CLR для любых API. На самом деле это не так уж важно, что вы используете с точки зрения реализации - согласованность между вашей командой приятная, но никто не заботится. С другой стороны, действительно важно, что если вы ссылаетесь на тип в API, вы делаете это на нейтральном языке. Метод, называемый ReadInt32 является однозначным, тогда как метод, называемый ReadInt требует интерпретации. Вызывающий может использовать, например, язык, который определяет int псевдоним для Int16. Конструкторы.NET Framework следовали этому шаблону, хорошие примеры были в BitConverter, BinaryReader и Convert.

Ответ 3

String означает System.String и это тип .NET Framework. String является псевдонимом на языке С# для System.String. Оба они скомпилированы в System.String в IL (промежуточный язык), поэтому нет никакой разницы. Выберите то, что вам нравится, и используйте это. Если вы набираете код на С#, я бы предпочел String, поскольку он является псевдонимом типа С# и хорошо известен программистам на С#.

Я могу сказать то же самое о (int, System.Int32) и т.д.

Ответ 4

Лучший ответ, который я когда-либо слышал об использовании предоставленных псевдонимов типов в С#, дан Джеффри Рихтером в его книге CLR Via С#. Вот его 3 причины:

Я видел, что некоторые разработчики были сбиты с толку, не зная, использовать ли в своем коде строку или строку. Поскольку в С# строка (ключевое слово) отображается точно в System.String (тип FCL), нет никакой разницы, и любой из них может быть использован.

В С# long отображается на System.Int64, но на другом языке программирования long может отображаться на Int16 или Int32. Фактически, C++/CLI фактически обрабатывает долго как Int32. Кто-то, читающий исходный код на одном языке, может легко неверно истолковать намерение кода, если он или она привыкли к программированию на другом языке программирования. На самом деле, большинство языков не будет даже рассматривать долго, как ключевое слово и не будет компилировать код, который использует его.

В FCL есть много методов, имена которых являются частью имен их методов. Например, тип BinaryReader предлагает такие методы, как ReadBoolean, ReadInt32, ReadSingle и т.д., А тип System.Convert предлагает такие методы, как ToBoolean, ToInt32, ToSingle и т.д. Хотя и разрешено писать следующий код, строка с плавающей точкой кажется мне неестественной, и не очевидно, что строка правильная:

BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

Так что у вас есть это. Я думаю, что это действительно хорошие моменты. Однако я не использую советы Джеффри в своем собственном коде. Возможно, я слишком застрял в своем мире С#, но в итоге я пытаюсь сделать мой код похожим на фреймворк.

Ответ 5

string - зарезервированное слово, но string - это просто имя класса. Это означает, что string не может использоваться как имя переменной сам по себе.

Если по какой-то причине вам нужна переменная с именем string, вы увидите только первый из этих компиляций:

StringBuilder String = new StringBuilder();  // compiles
StringBuilder string = new StringBuilder();  // doesn't compile

Если вы действительно хотите, чтобы имя переменной называлось строкой, вы можете использовать @ в качестве префикса:

StringBuilder @string = new StringBuilder();

Другое критическое различие: переполнение стека подчеркивает их по-разному.

Ответ 6

Существует одна разница - вы не можете использовать String без using System; заранее.

Ответ 7

Это было рассмотрено выше; однако вы не можете использовать string в отражении; вы должны использовать string.

Ответ 8

System.String является.NET строки класса - в С# string является псевдонимом для System.String - так в использовании они одинаковы.

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

Если вы обнаружите, что вы строите системы, где необходимо указать размер целых чисел, которые вы используете, и поэтому они имеют тенденцию использовать Int16, Int32, UInt16, UInt32 и т.д., Тогда было бы более естественно использовать String - и при перемещении между различными.net, это может сделать вещи более понятными - иначе я бы использовал строку и int.

Ответ 9

Я предпочитаю капитализированные типы .NET (а не псевдонимы) для форматирования. Типы .NET окрашены так же, как и другие типы объектов (в конце концов, являются типами значений).

Условные и управляющие ключевые слова (например, if, switch и return) имеют строчные и цветные синие цвета (по умолчанию). И я предпочел бы не иметь разногласий в использовании и формате.

Рассмотрим:

String someString; 
string anotherString;

Ответ 10

Valters, вы не можете устанавливать глобальные псевдонимы в стиле string, int и т.д., насколько я знаю. Однако вы можете сделать более локализованное сглаживание для типов и пространств имен с ключевым словом using.

например.

using str = System.String;
using strDict = System.Collections.Generic.Dictionary<string, string>;
//...
str s = "Now you've got another alias for string!";
var d = new strDict();

Смотрите здесь: с использованием директивы (ссылка на С#)

Ответ 11

string и string идентичны во всех отношениях (кроме прописных букв "S" ). Никаких последствий для производительности не имеет.

Нижний регистр string является предпочтительным в большинстве проектов из-за подсветки синтаксиса

Ответ 12

С# - это язык, который используется вместе с CLR.

string - это тип в С#.

System.String - это тип в CLR.

При использовании С# вместе с CLR string будет отображаться System.String.

Теоретически вы можете реализовать С# -компилятор, который генерировал байт-код Java. Разумная реализация этого компилятора, вероятно, будет отображать string на java.lang.String, чтобы взаимодействовать с библиотекой времени выполнения Java.

Ответ 13

Это видео YouTube демонстрирует практически то, как они отличаются.

Но теперь для длинного текстового ответа.

Когда мы говорим о .NET, существует две разные вещи: существует .NET framework, а другая есть языки (C#, VB.NET и т.д.), которые используют эту инфраструктуру.

"System.String" a.k.a "String" (капитал "S" ) - это тип данных структуры .NET, тогда как "string" - это тип данных C#.

Короче говоря, "String" - это псевдоним (то же самое, что называется с разными именами) "string" . Так что технически оба приведенных ниже оператора кода будут давать одинаковый результат.

String s = "I am String";

или

String s = "I am String";

Таким же образом существуют псевдонимы для другого типа данных С#, как показано ниже: -

object: System.Object, строка: System.String, bool: System.Boolean, byte: System.Byte, sbyte: System.SByte, short: System.Int16 и т.д.

Теперь вопрос в миллион долларов с точки зрения программиста Итак, когда использовать "String" и "string" ?

Во-первых, чтобы избежать путаницы, используйте один из них последовательно. Но из соображений лучшей практики, когда вы делаете объявление переменной, полезно использовать "string" (small "s" ), и когда вы используете его как имя класса, предпочтительнее "String" (капитал "S" ).

В приведенном ниже коде левая сторона является объявлением переменной и объявляется с использованием "string" . С правой стороны мы вызываем метод, поэтому "String" более разумный.

string s = String.ToUpper() ;

Ответ 14

Нижний регистр string является псевдонимом для System.String. Они одинаковы в C#.

Там обсуждается, следует ли использовать типы систем (System.Int32, System.String и т.д.) или C# aliases (int, string и т.д.). Я лично считаю, что вы должны использовать C# aliases, но это только мои личные предпочтения.

Ответ 15

string - это просто псевдоним для System.String. Компилятор будет обрабатывать их одинаково.

Единственное практическое отличие - подсветка синтаксиса, как вы упоминаете, и что вы должны писать using System, если используете string.

Ответ 16

Оба одинаковы. Но с точки зрения руководства по кодированию лучше использовать string вместо string. Это то, что обычно используют разработчики. например вместо Int32 мы используем int, поскольку int является псевдонимом Int32

FYI "Строка ключевого слова - просто псевдоним для предопределенного класса System.String". - Спецификация языка С# 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

Ответ 17

Как говорят другие, они одинаковы. По умолчанию правила StyleCop заставят вас использовать string как наилучшую практику стиля кода на С#, за исключением случаев, когда ссылаются на статические функции System.String, такие как String.Format, String.Join, String.Concat и т.д.

Ответ 18

Новый ответ через 6 лет и 5 месяцев (промедление).

Хотя string - зарезервированное ключевое слово С#, которое всегда имеет фиксированное значение, string - это просто обычный идентификатор, который может ссылаться на что угодно. В зависимости от членов текущего типа текущее пространство имен и применяемые директивы using и их размещение string могут быть значением или типом, отличным от global::System.String.

Я приведу два примера, в которых директивы using не помогут.

Во-первых, когда string является значением текущего типа (или локальной переменной):

class MySequence<TElement>
{
  public IEnumerable<TElement> String { get; set; }

  void Example()
  {
    var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
  }
}

Вышеуказанное не будет компилироваться, потому что IEnumerable<> не имеет нестатического члена с именем Format, и не применяются методы расширения. В приведенном выше случае все еще можно использовать string в других контекстах, где тип является единственной возможностью синтаксически. Например, String local = "Hi mum!"; может быть в порядке (в зависимости от пространств имен и директив using).

Хуже: высказывание String.Concat(someSequence) будет (в зависимости от using s) перейти к методу расширения Linq Enumerable.Concat. Он не переходит к статическому методу string.Concat.

Во-вторых, если string - это другой тип , вложенный внутри текущего типа:

class MyPiano
{
  protected class String
  {
  }

  void Example()
  {
    var test1 = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
    String test2 = "Goodbye";
  }
}

Ни один из операторов в методе Example не компилируется. Здесь string всегда является пианино string, MyPiano.String. Нет члена (static или нет) Format существует на нем (или наследуется от его базового класса). И значение "Goodbye" не может быть преобразовано в него.

Ответ 19

Использование типов системы упрощает перенос между С# и VB.Net, если вы в этом ведете.

Ответ 20

Против того, что кажется обычной практикой среди других программистов, я предпочитаю String over String, чтобы подчеркнуть тот факт, что String является ссылочным типом, как упоминал Джон Скит.

Ответ 21

string является псевдонимом (или сокращением) System.String. Это означает, что, набрав string, мы имели в виду System.String. Вы можете прочитать больше в мысленной ссылке: 'string' - это псевдоним/стенография System.String.

Ответ 22

Я просто хотел бы добавить это к ответу lfousts, из книги Ritchers:

Спецификация языка С# гласит: "В зависимости от стиля использование ключевого слова предпочтительнее использования полного имени типа системы". Я не согласен с языковой спецификацией; Я предпочитаю использовать имена типов FCL и полностью избегать примитивных имен типов. На самом деле, мне жаль, что компиляторы даже не предложили примитивные имена типов и заставили разработчиков вместо этого использовать имена типов FCL. Вот мои причины:
Ive видел, как некоторые разработчики путались, не зная, использовать ли строку или String в своем коде. Потому что в строке С# (ключевое слово) точно сопоставляется с System.String (тип FCL), нет никакой разницы и может быть использована. Аналогично, Ive слышал, что некоторые разработчики говорят, что int представляет собой 32-разрядное целое число, когда приложение работает на 32-разрядной ОС и что оно представляет собой 64-разрядное целое, когда приложение работает в 64-разрядной ОС. Это утверждение абсолютно неверно: в С# int всегда сопоставляется с System.Int32 и поэтому представляет собой 32-разрядное целое, независимо от ОС, на котором работает код. Если программисты будут использовать Int32 в своем коде, то эта потенциальная путаница также будет устранена.

В С#, long maps to System.Int64, но на другом языке программирования, long может отображать Int16 или Int32. В самом деле, C++/CLI это лечить долго, как Int32. Кто-то, читающий исходный код на одном языке, может легко неверно интерпретировать намерение кодов, если он или она использовались для программирования на другом языке программирования. На самом деле, большинство языков даже долго не будут рассматривать ключевое слово и не будут компилировать код, который его использует.
FCL имеет множество методов, которые имеют имена типов как часть имен их методов. Например, тип BinaryReader предлагает такие методы, как ReadBoolean, ReadInt32, ReadSingle и т.д., А тип System.Convert предлагает такие методы, как ToBoolean, ToInt32, ToSingle и т.д. Хотя законно писать следующий код, линия с поплавком кажется мне очень неестественной, и не очевидно, что строка правильная:
BinaryReader br = new BinaryReader(...);
float val = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good
Многие программисты, использующие С#, имеют тенденцию забывать, что другие языки программирования могут использоваться против CLR, и из-за этого С# -isms ползут в код библиотеки классов. Например, Microsoft FCL почти исключительно написан на С#, а разработчики из команды FCL теперь внедрили методы в библиотеку, такие как Array s GetLongLength, которая возвращает значение Int64, которое длиннее на С#, но не на других языках (например, [CN10 ]/CLI). Другим примером является метод System.Linq.Enumerable s LongCount.

Я не получил его мнения, прежде чем я прочитал полный параграф.

Ответ 23

String (System.String) - это класс в библиотеке базового класса. string (нижний регистр) - это зарезервированная работа в С#, которая является псевдонимом для System.String. Int32 vs int аналогичная ситуация, как и Boolean vs. bool. Эти ключевые слова на языке С# позволяют объявлять примитивы в стиле, аналогичном C.

Ответ 24

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

Ответ 25

Поздняя вечеринка: я использую типы CLR 100% времени (ну, кроме того, если принудительно использовать тип С#, но я не помню, когда это было в последний раз).

Я изначально начал делать это много лет назад, согласно книгам CLR от Ritchie. Мне было разумно, что все языки CLR в конечном итоге должны иметь возможность поддерживать набор типов CLR, поэтому использование типов CLR обеспечивало бы более четкий и, возможно, более "многоразовый" код.

Теперь, когда я делал это в течение многих лет, это привычка, и мне нравится окраска, которую VS показывает для типов CLR.

Единственный реальный downer заключается в том, что auto-complete использует тип С#, поэтому я в конечном итоге повторно набираю автоматически сгенерированные типы, чтобы указать тип CLR.

Кроме того, теперь, когда я вижу "int" или "string", это выглядит просто неправильно для меня, например, я смотрю код 1970 C.

Ответ 26

На самом деле это вопрос конвенции. string просто больше похожа на стиль C/C++. Общее соглашение заключается в том, чтобы использовать любые ярлыки, выбранные вашим выбранным языком (int/Int для Int32). Это относится и к "объекту" и decimal.

Теоретически это могло бы помочь перекодировать код в какой-то будущий 64-битный стандарт, в котором "int" может означать Int64, но это не так, и я ожидал бы, что любой мастер обновления изменит любые int ссылки на Int32 любом случае просто для того, чтобы быть в безопасности.

Ответ 27

Нет никакой разницы.

Ключевое слово С# string относится к типу .NET System.String - это псевдоним, который поддерживает соглашения об именах языка.

Аналогично, int отображается на System.Int32.

Ответ 28

Вот цитата из этой статьи из книга Даниэля Солиса.

Все предопределенные типы отображаются непосредственно на основных типов .NET. Названия типов С# (строка) - это просто псевдонимы для .NET(String или System.String), поэтому использование имен .NET отлично работает синтаксически, хотя это обескураживает. В рамках программы С# вы должны использовать имена С# а не имена .NET.

Ответ 29

строка - это ключевое слово, и вы не можете использовать строку в качестве идентификатора.

Строка не является ключевым словом, и вы можете использовать ее как идентификатор:

Пример

string String = "I am a string";

Ключевое слово string является псевдонимом для System.String Помимо проблемы с ключевым словом, эквивалентны.

 typeof(string) == typeof(String) == typeof(System.String)

Ответ 30

Да, нет никакой разницы между ними, как и bool и Boolean.