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

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

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

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

4836
задан Lance Fisher 10 авг. '08 в 10:18
источник поделиться

55 ответов

  • 1
  • 2

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

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

например.

string place = "world";

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

например.

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

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


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

4603
ответ дан Derek Park 10 авг. '08 в 10:22
источник поделиться

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

Как отмечали другие, 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.

2811
ответ дан Jon Skeet 18 окт. '08 в 21:52
источник поделиться

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

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

565
ответ дан artur02 18 окт. '08 в 20:25
источник поделиться

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

  • Я видел, как несколько разработчиков запутались, не зная, использовать ли в своем коде строку или String. Потому что в С# строка (ключевое слово) точно сопоставляется с System.String(тип FCL), нет никакой разницы и может быть использована.
  • В С#, длинный отображается System.Int64, но на другом языке программирования long может отображаться Int16 или Int32. Фактически, С++/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

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

366
ответ дан Luke Foust 16 авг. '08 в 2:00
источник поделиться

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

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

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

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

StringBuilder @string = new StringBuilder();

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

344
ответ дан Simon_Weaver 24 февр. '09 в 8:14
источник поделиться

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

293
ответ дан user3296 27 авг. '08 в 21:21
источник поделиться

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

243
ответ дан TraumaPony 19 окт. '08 в 4:04
источник поделиться

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();

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

193
ответ дан Derek Park 10 авг. '08 в 11:17
источник поделиться

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

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

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

170
ответ дан Ronnie 10 авг. '08 в 10:26
источник поделиться

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

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

150
ответ дан TheSoftwareJedi 18 окт. '08 в 19:50
источник поделиться

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

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

Рассмотрим:

String someString; 
string anotherString; 
147
ответ дан Anthony Mastrean 03 сент. '08 в 21:58
источник поделиться

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

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

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

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

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

137
ответ дан Rasmus Faber 17 марта '09 в 23:29
источник поделиться

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

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

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

enter image description here

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

enter image description here

Короче говоря, "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() ;
126
ответ дан Shivprasad Koirala 15 янв. '14 в 21:03
источник поделиться

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

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

116
ответ дан Hallgrim 18 окт. '08 в 19:50
источник поделиться

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

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

111
ответ дан urini 10 авг. '08 в 10:27
источник поделиться

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

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

104
ответ дан Pradeep Kumar Mishra 18 окт. '08 в 21:26
источник поделиться

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

89
ответ дан Lloyd Cotten 19 окт. '08 в 4:15
источник поделиться

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

71
ответ дан Ishmael 22 сент. '08 в 22:40
источник поделиться

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

67
ответ дан RolandK 31 мая '11 в 14:20
источник поделиться

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

62
ответ дан JeeShen Lee 21 окт. '11 в 4:10
источник поделиться

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

56
ответ дан Joe Alfano 15 янв. '12 в 1:51
источник поделиться

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

50
ответ дан user576533 25 апр. '11 в 9:06
источник поделиться

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

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

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

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

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

49
ответ дан Michael Ray Lovett 24 авг. '12 в 18:22
источник поделиться

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

Спецификация языка С# заявляет, "Что касается стиля, использование ключевое слово предпочтительнее использования полное имя типа системы." Я не согласен с указанием языка; я предпочитают использовать имена типов FCL и полностью избежать примитивного типа имена. На самом деле, я хочу, чтобы компиляторы даже не предлагал примитивный тип имена и вынужденных разработчиков использовать Имена типов FCL. Вот мои Причины:

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

43
ответ дан claudioalpereira 28 янв. '11 в 13:08
источник поделиться

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

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

40
ответ дан Mel 18 авг. '08 в 20:58
источник поделиться

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

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

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

39
ответ дан Oded 15 янв. '12 в 1:47
источник поделиться

Новый ответ через 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" не может быть преобразовано в него.

37
ответ дан Jeppe Stig Nielsen 15 янв. '15 в 17:21
источник поделиться

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

30
ответ дан Coder 08 окт. '12 в 11:22
источник поделиться

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

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

30
ответ дан user2771704 01 нояб. '13 в 18:21
источник поделиться

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

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

Пример

string String = "I am a string";

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

 typeof(string) == typeof(String) == typeof(System.String)
29
ответ дан Neel 11 июня '14 в 8:26
источник поделиться
  • 1
  • 2

Другие вопросы по меткам