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

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

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

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

5326
задан Lance Fisher 10 авг. '08 в 10:18
источник поделиться
62 ответов
  • 1
  • 2
  • 3

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

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

например

string place = "world";

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

например

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

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


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

5071
ответ дан 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.

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

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

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

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

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

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

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

406
ответ дан 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();

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

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

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

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

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

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

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

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

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

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

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
источник поделиться

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

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

Рассмотрим:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

122
ответ дан 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример

string String = "I am a string";

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

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

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

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

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

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

33
ответ дан Coder 08 окт. '12 в 11:22
источник поделиться
  • 1
  • 2
  • 3

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