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

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

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

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

10.08.2008 07:18:02
@ORMapper, но факт остается фактом string: это лексическая конструкция грамматики C #, тогда как System.Stringэто просто тип. Независимо от каких-либо явных различий, упомянутых в какой-либо спецификации, все еще существует неявное различие, которое можно допустить с некоторой неопределенностью. Сам язык должен поддерживать stringтаким образом, чтобы реализация (совсем) не была так обязательна для конкретного класса в BCL.
Kirk Woll 2.12.2014 03:05:22
@KirkWoll: Согласно спецификации языка, а сам язык должен рассмотреть , stringчтобы быть точно такой же , как тип BCL System.String, больше ничего. Это совсем не двусмысленно. Конечно, вы можете реализовать свой собственный компилятор, используя грамматику C #, и использовать все найденные токены для чего-то произвольного, не связанного с тем, что определено в спецификации языка C #. Тем не менее, полученный язык будет похож на C #, его нельзя считать C #.
O. R. Mapper 2.12.2014 08:22:33
Вы можете использовать stringбез использования директивы для системы. Вы не можете сделать это с String.
Wilsu 30.11.2015 08:52:40
Для кого-то из Алгола и Фортрана это обсуждение показывает, что с ним что-то не так string. Его нужно сокращать System.String, но, как псевдоним, это выглядит примерно так, но не совсем так. После нескольких лет C #, хотя, я бы сказал, что это безопасно , чтобы просто использовать stringи string.Format()и не беспокоиться о System.String.
Roland 20.12.2016 00:24:25
@Sangeeta Что ты говоришь? System.StringКласс по - прежнему существует, и stringключевое слово по - прежнему является псевдонимом для него. Так же, как System.Int32и int. Они буквально одно и то же.
Craig 8.12.2018 02:14:44
30 ОТВЕТОВ
РЕШЕНИЕ

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

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

например

string place = "world";

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

например

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

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

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

6059
22.01.2019 18:50:42
Если вы решите использовать StyleCop и последуете этому, это будет означать использование типов, специфичных для языка. Так что для C # у вас будет строка (вместо String), int (вместо Int32), float (вместо Single) - stylecop.soyuz5.com/SA1121.html
Dominic Zukiewicz 22.05.2012 22:36:15
Я всегда использую псевдонимы, потому что я предположил, что однажды это может пригодиться, потому что они действуют как абстракция, поэтому могут изменить их реализации без моего ведома.
Rob 12.10.2012 23:25:39
Visual Studio 2015 говорит, что String.Format должен быть изменен на string.Format, так что я думаю, что Microsoft идет по этому пути. Я также всегда использовал String для статических методов.
Sami Kuhmonen 22.12.2014 05:21:27
Прочитав их, я заметил, что некоторые комментарии просто неверны. @ DRAirey1 Со временем вы обнаружите, что старый способ все еще остается лучшим, если вы сомневаетесь в этом, то я осмелюсь попытаться написать код C # без использования Visual Studio. Это практически невозможно, и ситуация, которая время от времени возникает в работе веб-разработки. @Vlad Вам не нужно ничего импортировать, чтобы использовать String. @Abhi Ваш комментарий не имеет смысла и одинаково верен для string.Format(). @ KlitosG Нет, это не правда. Все они работают одинаково.
krowe2 29.05.2015 14:30:54
Не могли бы вы добавить замечание, что на самом деле есть разница? Например: nameof(string)не будет компилироваться, тогда как nameof(String)будет.
Jeroen Vannevel 5.02.2016 20:38:26

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

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

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

253
6.02.2018 12:39:09
Просто выберите один и будьте последовательны. Если вы работаете где-то в стиле дома, используйте это.
Alan B 16.03.2015 16:32:52
к сожалению, стиль - это личное предпочтение, и он может быть слишком дорогим для применения в большой кодовой базе в нескольких командах без выделенного владельца кода. всегда есть более важные дела, а не строка против строки. что возвращает нас к «более важным вещам в жизни»
aiodintsov 24.02.2016 06:51:16
Это определенно вещь предпочтения; например: Я предпочитаю использовать short, int, ushort, uintвместо того Int16, и т.д. В основном потому , что это, как я узнал. Конечно, Int16это легче понять тем, у кого меньше опыта. +1 От меня!
Emma 2.01.2019 19:18:08

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

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

163
14.08.2017 04:33:23
В этом проблема, они не псевдонимы C #, а псевдонимы C. В языке C # нет нативных 'string' или 'int', только синтаксический сахар.
Quarkly 29.05.2015 20:23:54
не знаю, откуда взялась буква «C», поскольку в спецификации языка C # 5 написано «Строка ключевого слова - это просто псевдоним для предопределенного класса System.String». на странице 85, пункт 4.2.4. Все языки высокого уровня являются синтаксическим сахаром над наборами команд ЦП и байт-кодом.
aiodintsov 24.02.2016 06:57:31

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

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

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

499
4.07.2018 11:05:58
Второй пункт звучит как причина не использовать stringи intт. Д.
MauganRa 15.06.2015 15:37:29
@MauganRa И, как предполагается, автор книги перечисляет эти причины того, почему он не использует псевдонимы.
tomi.lee.jones 15.09.2015 17:48:00
«Если кто-то читает исходный код C #, он должен интерпретировать долго в соответствии со спецификацией языка, а не спецификацией других языков». Это полностью упускает из виду. Дело не в том, что кто-то намеревается неверно истолковать код, просто мозг легко делает неверный вывод, когда тип имеет другое значение, нежели то, что программист видит ежедневно в другом контексте. Мы все делаем ошибки; использование явно именованных типов делает эти ошибки менее вероятными.
Darryl 21.09.2015 22:11:04
+ Эти причины обобщают мои чувства по этому вопросу. Когда я впервые начал писать код на C # (исходя из фона Java / C ++ / C), я думал, что псевдонимы ужасны. Я до сих пор так думаю, к сожалению, большая часть мира не согласна со мной, или им все равно, поэтому используйте строчные буквы.
gusgorman 2.03.2017 10:41:21
@jinzai вопрос о C #, в котором longопределяется как 64-разрядное целое число со знаком , независимо от платформы или компилятора. Таким образом , в некоторых случаях , по крайней мере, да, это действительно зависит от языка.
phoog 8.02.2018 14:30:36

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

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

65
3.10.2018 04:24:47

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

384
3.10.2016 18:32:52
по умолчанию большинство людей добавляют это любым способом вверху файла. VS делает это по умолчанию в большинстве случаев не во всех!
IbrarMumtaz 6.04.2010 16:10:21
По умолчанию я добавляю только те usingоператоры, которые мне требуются, и явно удаляю все, что мне не нужно. Инструменты повышения производительности> «[x] Удаление и форматирование при сохранении»
JMD 18.05.2016 16:58:27
@JMD Я изменил файл шаблона .cs, чтобы в нем даже не было операторов использования вверху! Я также изменил шаблон класса на internal sealed.
ErikE 1.12.2016 23:48:35
@ JMD Я ненавижу эту функцию. Иногда он вносит изменения в другие нетронутые файлы, затрудняя просмотр фактических изменений, содержащихся в наборе изменений. Конечно, я обычно удаляю «используя спам», но только активно, а не автоматически.
mg30rg 19.02.2019 14:45:10
Это может быть так для C #, но не для всех языков .NET. (Powershell импортирует пространство имен System по умолчанию.)
FSCKur 19.03.2019 23:29:30

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

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

Рассматривать:

String someString; 
string anotherString; 
207
28.09.2016 11:58:18
Ты тоже пишешь код вроде: Int32 i = 1; Вместо int i = 1; ? Кажется непоследовательным, чтобы не использовать псевдоним строки, когда он доступен.
bytedev 28.01.2013 10:49:37
@nashwan: на самом деле, да, я использую Int32 i=1;вместо того, int i = 1; чтобы найти более удобный для чтения мой первый: именно то, что я хочу 32-битное целое число со знаком.
NotMe 15.02.2013 17:30:42
Ну, я думаю, все зависит от того, думает ли разработчик, что он пишет код C # (строка) или код .NET (строка). Лично я в первую очередь думаю, что пишу на C # (а это C #, использующий .NET).
bytedev 15.04.2014 13:09:24
@ Алекс: моя точка зрения была просто в том, что я предпочитаю быть очень конкретным в своем кодировании, чтобы устранить двусмысленность.
NotMe 27.04.2015 02:56:54
На другом конце спектра я почти всегда просто используюvar
tic 18.03.2016 15:38:29

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

97
22.09.2008 19:40:08
Конвертировать между C # и VB.NET достаточно просто. developerfusion.com/tools/convert/vb-to-csharp
grant 1.07.2011 20:35:22

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

Строчные буквы stringпредпочтительнее в большинстве проектов из-за подсветки синтаксиса

190
19.11.2011 09:37:17
Джеффри Рихтер рекомендует во всех случаях использовать тип CLR (CLR через C #), чтобы избежать именно той путаницы, которая имеет место здесь.
Josh 18.10.2008 17:02:29
Очевидно, что если вы используете S или s, это вызовет эти вопросы, так что проголосуйте за Рихтера. ;)
Brad Wilson 18.10.2008 17:17:18
Рихтер подразумевал, что строка не должна быть опцией - у Microsoft не должно быть ее в языке. Вы не можете понизить голос Рихтера - он легенда! :)
Joe Ratzer 18.10.2008 19:23:07
Я согласен, что было бы лучше вообще не иметь псевдонимов. Но учитывая, что они у нас есть, я думаю, что их можно использовать (но не в именах методов и т. Д.)
Jon Skeet 19.10.2008 06:34:50
«string» - это не то же самое, что «String». Есть средство "System.String". Поэтому, если вы используете «String», вы должны добавить «using System» для включения пространства имен
ThiagoAlves 3.12.2011 16:41:29

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

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

154
3.12.2011 19:53:47
Вам не нужно ставить префикс System для использования String.
Joe Ratzer 18.10.2008 19:24:16
Вы должны включить using Systemпри использовании String, в противном случае вы получите следующую ошибку:The type or namespace name 'String' could not be found (are you missing a using directive or an assembly reference?)
Ronald 16.10.2009 17:53:00

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

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

709
3.12.2011 19:53:11
«Если вы пишете код на C #, я бы предпочел строку, так как это псевдоним C # и хорошо известен программистам C #» - когда человек на C # не знает фреймворк .NET. +1, как мне кажется, в общем, это лучший ответ, но пункт, который я упоминаю, кажется странным.
MyDaftQuestions 16.11.2015 08:31:12
Я лично предпочитаю использовать «Int32», так как он сразу показывает диапазон значений. Представьте, обновили ли они тип int в более поздних старших системах. int в c, по-видимому, рассматривается как «целочисленный тип, с которым целевой процессор работает наиболее эффективно» , и определяется как «не менее 16 бит». Я бы предпочел предсказуемую последовательность, большое спасибо.
Nyerguds 28.04.2016 11:41:38
@MyDaftQuestions Я согласен. Во всяком случае, имеет смысл последовательно использовать типы .net, потому что они не знают языка, а тип очевиден, независимо от какого-либо языка (знаю ли я все идиосинкразии F # или VB?).
Peter - Reinstate Monica 21.01.2017 17:39:59
@ Nyerguds Есть две причины, чтобы просто не беспокоиться об этом. Одним из них является то, что intопределяется в спецификации языка C # как 32-разрядное целое число независимо от аппаратного обеспечения. C #, несмотря на общее наследие в глубине веков, на самом деле не является C. Изменение intна 64-битное целое число будет серьезным изменением в спецификации и языке. Это также потребовало бы переопределения long, как longв настоящее время 64-битное целое число. Другая причина не беспокоиться, не имеет значения, поскольку типы никогда не изменятся, но .NET достаточно абстрактен, так что в 99% случаев вам вообще не нужно об этом думать. ;-)
Craig 8.12.2018 02:47:06
@Craig Я копаюсь во многих старых проприетарных игровых форматах, где мне все же приходится все время об этом думать. А затем , используя Int16, Int32и Int64это гораздо более прозрачным в коде , чем при использовании довольно nondescriptive short, intиlong
Nyerguds 9.12.2018 02:29:47

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

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

141
14.08.2017 05:16:40

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

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

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 дизайнеры следовали этой модели, хорошие примеры будучи в BitConverter, BinaryReaderи Convertклассы.

3421
15.12.2019 06:49:13
Ситуация наследования с enum интересна. Можете ли вы указать на документацию, почему псевдоним должен использоваться для перечислений? Или это известная ошибка?
JaredPar 19.10.2008 02:00:57
Это в разделе 14.1 спецификации (я не могу здесь легко цитировать, потому что это слишком долго). Он прямо не сказать , что вы должны использовать псевдоним, но псевдонимы рода рассматриваются как свои собственные типы. Это все немного странно.
Jon Skeet 19.10.2008 06:34:02
@PiPeep Что поразительнее, чем большое количество голосов «против», так это ошеломляюще низкое количество голосов «против» (рассмотрим, что у 5 лучших постов в общей сложности более 2000 голосов, и при этом среди них всего 1 голос). Особенно, если учесть, что в любом сообществе всегда есть «ненавистники», я нахожу это просто невероятным.
corsiKa 9.09.2011 21:27:44
Одно интересное различие между stringи Stringзаключается в том, что string' is a keyword in c#, so you can not use it as a variable name.For Ex: string string = "hi"; //compiler error, but String String = "hi"; `допустимо, так как Stringявляется идентификатором, а не ключевым словом.
Sanjeev Rai 5.06.2013 07:09:27
@SanjeevRai: Да. Вы можете использовать @stringдля создания идентификатора, который заканчивается как stringбудто. Это своего рода механизм побега.
Jon Skeet 5.06.2013 07:18:18

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

306
19.11.2011 09:36:59
Я не понимаю, что означает этот ответ и почему за него проголосовали. Вы можете использовать typeof(string)в отражении. Пример первый: if (someMethodInfo.ReturnType == typeof(string)) { ... }Пример два: var p = typeof(string).GetProperty("FirstChar", BindingFlags.NonPublic | BindingFlags.Instance);где вы должны использовать String, а не string? Если вы попробуете что-то вроде Type.GetType("String")или Type.GetType("string"), ни один из них не найдет класс, потому что пространство имен отсутствует. Если по какой-то глупой причине вы сравниваете .Nameтип с "string"учетом регистра, вы правы.
Jeppe Stig Nielsen 24.05.2019 12:04:17

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

119
19.11.2011 09:35:51
Я не знал, что StyleCop будет отмечать использование String - за исключением статических методов. Я думаю, что это здорово, так как я всегда использую это: строка для объявлений типов и строка, когда я получаю доступ к статическим членам.
Goyuix 5.05.2011 18:41:26

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

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

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

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

StringBuilder @string = new StringBuilder();

Еще одно критическое отличие: переполнение стека выделяет их по-разному.

451
27.12.2017 17:33:19
Имейте в виду, что вызывать локальный код на @stringсамом деле довольно бессмысленно, поскольку имена локальных пользователей присутствуют только в PDB. С таким же успехом можно назвать это _stringили как-то так. Это имеет больше смысла для вещей, имена которых доступны через отражение, где будет имя @stringчлена "string".
Roman Starkov 19.08.2013 10:30:07
Также имейте в виду, что использование зарезервированного слова в качестве имени переменной крайне не элегантно.
Elton 27.10.2015 15:16:54
OP не хочет использовать строку или строку в качестве имени переменной. Они попросили объяснить разницу между этими типами . Ваш ответ только добавляет больше путаницы ИМО
Matt Wilko 4.07.2016 15:14:19
@ Craig, если вы писали программное обеспечение, чтобы научить людей, как завязывать узлы?
Simon_Weaver 9.12.2018 03:31:28
@Simon_Waaver завязывает в струнах? ахаха прикольно. :-) Конечно, вы можете выбрать другое имя, например, thread. Подожди минутку ...
Craig 9.12.2018 03:59:54

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

string это тип в C #.

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

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

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

181
25.12.2015 12:55:26
stringне является типом в C #; это зарезервированное слово, которое отображается на тип в CLR.
CesarGon 31.07.2011 17:58:52
@CesarGon: Согласно ECMA-334, раздел 8.2.1: «C # предоставляет набор предопределенных типов [...] Предопределенными ссылочными типами являются объект и строка».
Rasmus Faber 31.07.2011 19:03:30
Согласно ECMA-334, раздел 9.4.3, «строка» является ключевым словом. :-) Я согласен с вами, что «строка» - это тип, если вы сосредоточены на семантике, но я бы сказал, что это ключевое слово (т.е. зарезервированное слово), если вы сосредоточены на синтаксисе. Стандарт поддерживает обе точки зрения (возможно, слишком неоднозначно!). Для меня ОП - это синтаксис, поэтому я склонен концентрироваться на синтаксисе, когда смотрю на ответы, но я вижу и вашу точку зрения. Кроме того, ваш ответ в его нынешнем виде может интерпретироваться как означающий, что существуют два разных типа: строка и строка, если это не так. Одно - это отображение на другое.
CesarGon 31.07.2011 19:30:23
Давайте проясним это. 'string' является зарезервированным псевдонимом. Это не настоящий тип данных. Это то, что указывает на что-то еще. Вы можете удалить все эти псевдонимы (или просто никогда не использовать их) и иметь совершенно хороший язык программирования.
Quarkly 8.07.2013 16:50:49

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

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

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

  • В C # 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
  • Многие программисты, использующие исключительно C #, склонны забывать, что другие языки программирования могут использоваться против CLR, и из-за этого C # -измы заползают в код библиотеки классов. Например, FCL Microsoft, почти исключительно написан на C # и разработчики в команде FCL теперь ввели методы в библиотеке , такой как массив «s GetLongLength , который возвращает Int64 значение , которое является длинным в C # , но не на других языках (например , C ++ / CLI). Другим примером может служить System.Linq.Enumerable «ы LongCount метод.

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

75
5.12.2018 09:34:21

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

66
19.11.2011 09:35:19

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

86
19.11.2011 09:35:06

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

35
19.11.2011 09:34:52

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

81
8.10.2016 18:50:20

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

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

Аналогично, intкарты для System.Int32.

49
15.01.2012 00:30:34
В 64-битной сборке int сопоставляется с System.Int64 (8 байт), в 32-битной сборке он сопоставляется с System.Int32 (4 байта)
Alex 25.07.2012 15:26:08
IntPtr и UIntPtr являются единственными типами, которые изменяют размер в соответствии с платформой (не учитывая фактические типы указателей, такие как int*и типы, состоящие из [U] IntPtrs или фактических указателей).
P Daddy 23.04.2013 21:20:46

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

72
24.12.2013 04:50:19

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

Первоначально я начал делать это несколько лет назад, в соответствии с книгами CLR Ричи. Для меня имело смысл, что в конечном итоге все языки CLR должны поддерживать набор типов CLR, поэтому использование типов CLR самостоятельно обеспечивает более четкий и, возможно, более «многократно используемый» код.

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

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

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

66
24.08.2012 15:22:47

Один аргумент, не упомянутый в другом месте, чтобы предпочесть случай Паскаля String:

System.Stringявляется ссылочным типом, а имена ссылочных типов являются условными .

28
3.10.2012 10:52:15
-1 Все имена типов в паскале по соглашению. Но все ключевые слова C # строчные.
P Daddy 23.04.2013 21:14:37
@Padaddy да, и stringэто действительно ключевое слово C #. Здесь задается вопрос: предпочитать ли ключевое слово или имя типа. Мой ответ говорит, что, хотя вы, очевидно, можете выбрать ключевое слово, один аргумент в пользу использования имени типа состоит в том, что ключевое слово они string, которое является псевдонимом для String, в конечном счете является ссылочным типом. Напротив, ключевое слово intявляется псевдонимом для Int32который является типом значения.
Zaid Masud 24.04.2013 13:24:26
Соглашения об использовании не различаются между ссылочными типами и типами значений, о чем свидетельствует упомянутый Int32вами тип. Нет смысла отказываться от ключевого слова в пользу имени класса, чтобы соблюдать некое воображаемое ограничение, согласно которому ссылочные типы следуют другим соглашениям об именах, чем типы значений.
P Daddy 24.04.2013 15:34:06
@ Папочка, да, ты прав. Я нес здесь соглашения Java, где примитивы - camelCase.
Zaid Masud 24.04.2013 18:40:21

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

string относится к примитивному типу

В C # они оба компилируются в String, но в других языках этого не происходит, поэтому вам следует использовать String, если вы хотите иметь дело с объектами String, и string, если вы хотите иметь дело с литералами.

15
12.08.2016 18:42:22
Не забудьте назвать эти другие языки, потому что я не знаю ни одного в .net, где string! = System.String. Кроме того, литерал не имеет ничего общего со строкой против строки ...
Andy 8.10.2016 18:53:24
Есть ли действительно 26 избирателей, которые считают, что это правильно?
Dawood ibn Kareem 21.02.2019 01:17:14
@ Энди, когда я отвечал на этот вопрос, когда я отвечал на него, я работал над Java, не уверенный, указывал ли вопрос .net, когда я отвечал на него, так как он был отредактирован с тех пор
Inverted Llama 21.02.2019 01:36:53

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

40
25.12.2015 12:55:50

По этому вопросу есть цитата из книги Дэниела Солиса .

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

45
11.12.2016 05:27:45

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

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

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

введите описание изображения здесь

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

введите описание изображения здесь

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

String s = "I am String";

или

string s = "I am String";

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

object:, System.Objectstring:, System.Stringbool:, System.Booleanbyte:, System.Bytesbyte:, System.SByteshort: System.Int16и так далее

Теперь вопрос на миллион долларов с точки зрения программиста. Так когда же использовать «String» и «string»?

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

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

string s = String.ToUpper() ;
168
28.02.2015 10:48:34
«Короче говоря,« String »- это псевдоним (то же самое, что называется с разными именами)« string »». Это не правильно: псевдоним "строка".
Xavier Egea 6.11.2014 12:04:10
когда вы делаете объявление переменной, хорошо использовать «string» (маленькие «s»), а когда вы используете его как имя класса, тогда «String» (заглавная «S») предпочтительнее. Это соглашение, кажется, больше не действует: если вы используете Visual Studio 2015 и пытаетесь написать Stringего, предложите «упростить код», перенеся его в string...
Massimiliano Kraus 4.11.2016 14:11:45