Пример ( обратите внимание на случай ):
string s = "Hello world!";
String s = "Hello world!";
Каковы правила использования каждого из них? И в чем различия?
string
псевдоним в C # для System.String
.
Технически нет никакой разницы. Это как int
против System.Int32
.
Что касается руководящих принципов, обычно рекомендуется использовать string
любое время, когда вы ссылаетесь на объект.
например
string place = "world";
Кроме того, я думаю, что обычно рекомендуется использовать, String
если вам нужно обратиться конкретно к классу.
например
string greet = String.Format("Hello {0}!", place);
Это стиль, который Microsoft стремится использовать в своих примерах .
Похоже, что руководство в этой области, возможно, изменилось, так как StyleCop теперь принудительно использует специальные псевдонимы C #.
string.Format()
. @ KlitosG Нет, это не правда. Все они работают одинаково. nameof(string)
не будет компилироваться, тогда как nameof(String)
будет. System.String
это строковый класс .NET - в C # string
это псевдоним для System.String
- поэтому при использовании они одинаковы.
Что касается руководящих принципов, я бы не стал слишком увязать и просто использовать то, что вам хочется - в жизни есть более важные вещи, и код все равно останется прежним.
Если вы нашли себя строительные системы , где необходимо указать размер целых чисел , которые вы используете , и поэтому , как правило, использование Int16
, Int32
, UInt16
, и UInt32
т.д. , то это могло бы выглядеть более естественно использовать String
- и, передвигаясь между различными языками .net это может сделать вещи более понятными - иначе я бы использовал string и int.
short
, int
, ushort
, uint
вместо того Int16
, и т.д. В основном потому , что это, как я узнал. Конечно, Int16
это легче понять тем, у кого меньше опыта. +1 От меня! Нижний регистр string
является псевдонимом для System.String
. Они одинаковые в C#
.
Спорят о том, следует ли вам использовать типы System ( System.Int32
, System.String
и т. Д.) Или C# aliases
( int
, string
и т. Д.). Я лично считаю, что вы должны использовать C# aliases
, но это только мое личное предпочтение.
Лучший ответ, который я когда-либо слышал об использовании предоставленных псевдонимов типов в 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 #, но в итоге я пытаюсь сделать мой код похожим на фреймворк.
string
и int
т. Д.long
определяется как 64-разрядное целое число со знаком , независимо от платформы или компилятора. Таким образом , в некоторых случаях , по крайней мере, да, это действительно зависит от языка. Это действительно условно. string
просто больше похоже на стиль C / C ++. Общее соглашение состоит в том, чтобы использовать любые ярлыки, которые предоставил выбранный вами язык (int / Int для Int32
). Это относится и к «объекту» decimal
.
Теоретически это может помочь перенести код в какой-то будущий 64-битный стандарт, в котором может означать «int» Int64
, но это не главное, и я ожидаю, что любой мастер обновления в любом случае изменит любые int
ссылки, Int32
чтобы быть в безопасности.
Есть одно отличие - вы не можете использовать String
без using System;
заранее.
using
операторы, которые мне требуются, и явно удаляю все, что мне не нужно. Инструменты повышения производительности> «[x] Удаление и форматирование при сохранении»internal sealed
.
Я предпочитаю прописные .NET
типы (а не псевдонимы) по причинам форматирования. Эти .NET
типы окрашены так же , как и другие типы объектов (типы значений являются собственными объектами, в конце концов).
Условные и управляющие ключевые слова (например if
, switch
и return
) строчные и темно-синие (по умолчанию). И я бы предпочел не иметь разногласий в использовании и формате.
Рассматривать:
String someString;
string anotherString;
Int32 i=1;
вместо того, int i = 1;
чтобы найти более удобный для чтения мой первый: именно то, что я хочу 32-битное целое число со знаком. var
Использование типов системы упрощает портирование между C # и VB.Net, если вы увлекаетесь такими вещами.
string
и String
идентичны во всех отношениях (кроме заглавной буквы "S"). В любом случае нет никаких последствий для производительности.
Строчные буквы string
предпочтительнее в большинстве проектов из-за подсветки синтаксиса
string
это просто псевдоним для System.String
. Компилятор будет относиться к ним одинаково.
Единственное практическое отличие - это подсветка синтаксиса, которую вы упоминаете, и которую вы должны написать, using System
если используете String
.
using System
при использовании String
, в противном случае вы получите следующую ошибку:The type or namespace name 'String' could not be found (are you missing a using directive or an assembly reference?)
String
означает, System.String
и это тип .NET Framework. string
псевдоним в языке C # для System.String
. Оба они скомпилированы System.String
в IL (промежуточный язык), поэтому нет никакой разницы. Выберите то, что вам нравится, и используйте это. Если вы пишете код на C #, я бы предпочел, так string
как это псевдоним C # и хорошо известен программистам C #.
Я могу сказать то же самое о ( int
, System.Int32
) и т.д ..
int
определяется в спецификации языка C # как 32-разрядное целое число независимо от аппаратного обеспечения. C #, несмотря на общее наследие в глубине веков, на самом деле не является C. Изменение int
на 64-битное целое число будет серьезным изменением в спецификации и языке. Это также потребовало бы переопределения long
, как long
в настоящее время 64-битное целое число. Другая причина не беспокоиться, не имеет значения, поскольку типы никогда не изменятся, но .NET достаточно абстрактен, так что в 99% случаев вам вообще не нужно об этом думать. ;-)Int16
, Int32
и Int64
это гораздо более прозрачным в коде , чем при использовании довольно nondescriptive short
, int
иlong
Оба одинаковы. Но с точки зрения руководства по кодированию лучше использовать string
вместо String
. Это то, что обычно используют разработчики. Например, вместо использования Int32
мы используем int
как int
псевдоним дляInt32
К вашему сведению «Строка ключевого слова - это просто псевдоним для предопределенного класса System.String
». - Спецификация языка C # 4.2.3
http://msdn2.microsoft.com/En-US/library/aa691153.aspx
Просто для полноты, вот мозговая свалка соответствующей информации ...
Как уже отмечали другие, 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
классы.
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
является идентификатором, а не ключевым словом. @string
для создания идентификатора, который заканчивается как string
будто. Это своего рода механизм побега. Это было покрыто выше; тем не менее, вы не можете использовать string
в отражении; Вы должны использовать String
.
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"
учетом регистра, вы правы. Как говорят другие, они одинаковы. Правила StyleCop, по умолчанию, будет обеспечивать , чтобы использовать в string
качестве C # кода стиля передовой практики, кроме случаев , когда ссылки на System.String
статические функции, такие как String.Format
, String.Join
, String.Concat
и т.д. ...
string
это зарезервированное слово, но String
это просто имя класса. Это означает, что string
не может использоваться как имя переменной само по себе.
Если по какой-то причине вам нужна переменная с именем string , вы увидите только первый из этих компиляций:
StringBuilder String = new StringBuilder(); // compiles
StringBuilder string = new StringBuilder(); // doesn't compile
Если вы действительно хотите имя переменной с именем string, вы можете использовать @
в качестве префикса:
StringBuilder @string = new StringBuilder();
Еще одно критическое отличие: переполнение стека выделяет их по-разному.
@string
самом деле довольно бессмысленно, поскольку имена локальных пользователей присутствуют только в PDB. С таким же успехом можно назвать это _string
или как-то так. Это имеет больше смысла для вещей, имена которых доступны через отражение, где будет имя @string
члена "string"
. C # - это язык, который используется вместе с CLR.
string
это тип в C #.
System.String
это тип в CLR.
Когда вы используете C # вместе с CLR string
будет отображаться на System.String
.
Теоретически, вы могли бы реализовать C # -компилятор, который генерировал байт-код Java. Разумная реализация этого компилятора, вероятно карта string
для java.lang.String
того , чтобы взаимодействовать с библиотекой времени выполнения Java.
string
не является типом в C #; это зарезервированное слово, которое отображается на тип в CLR. Я просто хотел бы добавить это к ответу 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 метод.
Я не получил его мнение, прежде чем я прочитал полный параграф.
String
не является ключевым словом и может использоваться в качестве идентификатора, тогда как string
является ключевым словом и не может использоваться в качестве идентификатора. И с функциональной точки зрения оба одинаковы.
Против того, что , как представляется, распространенной практикой среди других программистов, я предпочитаю String
более string
, только чтобы подчеркнуть тот факт , что String
это ссылочный тип, как уже упоминалось Jon тарелочкам.
Между этими двумя понятиями нет никакой разницы - string
однако, кажется, предпочтительнее при рассмотрении исходного кода других разработчиков.
string
является псевдонимом (или сокращением) System.String
. Это означает, что печатая, string
мы имели в виду System.String
. Вы можете прочитать больше в Think Link: 'строка' является псевдонимом / сокращением System.String.
Нет никакой разницы.
Ключевое слово C # string
соответствует типу .NET System.String
- это псевдоним, который соответствует соглашениям об именах языка.
Аналогично, int
карты для System.Int32
.
int*
и типы, состоящие из [U] IntPtrs или фактических указателей). String ( System.String
) - это класс в библиотеке базовых классов. Строка (нижний регистр) - это зарезервированная работа в C #, которая является псевдонимом для System.String. Int32 против int похожая ситуация как есть Boolean vs. bool
. Эти ключевые слова для языка C # позволяют объявлять примитивы в стиле, аналогичном C.
Опаздываю на вечеринку: я использую типы CLR 100% времени (ну, за исключением случаев, когда вынужден использовать тип C #, но я не помню, когда это было в последний раз).
Первоначально я начал делать это несколько лет назад, в соответствии с книгами CLR Ричи. Для меня имело смысл, что в конечном итоге все языки CLR должны поддерживать набор типов CLR, поэтому использование типов CLR самостоятельно обеспечивает более четкий и, возможно, более «многократно используемый» код.
Теперь, когда я делал это годами, это привычка, и мне нравится цвет, который VS показывает для типов CLR.
Единственный реальный недостаток заключается в том, что автозаполнение использует тип C #, поэтому я в итоге перепечатываю автоматически сгенерированные типы, чтобы вместо этого указать тип CLR.
Кроме того, теперь, когда я вижу «int» или «string», для меня это выглядит просто неправильно, как будто я смотрю на C-код 1970-х годов.
Один аргумент, не упомянутый в другом месте, чтобы предпочесть случай Паскаля String
:
System.String
является ссылочным типом, а имена ссылочных типов являются условными .
string
это действительно ключевое слово C #. Здесь задается вопрос: предпочитать ли ключевое слово или имя типа. Мой ответ говорит, что, хотя вы, очевидно, можете выбрать ключевое слово, один аргумент в пользу использования имени типа состоит в том, что ключевое слово они string
, которое является псевдонимом для String
, в конечном счете является ссылочным типом. Напротив, ключевое слово int
является псевдонимом для Int32
который является типом значения. Int32
вами тип. Нет смысла отказываться от ключевого слова в пользу имени класса, чтобы соблюдать некое воображаемое ограничение, согласно которому ссылочные типы следуют другим соглашениям об именах, чем типы значений. String
относится к строковому объекту, который поставляется с различными функциями для управления содержащейся строкой.
string
относится к примитивному типу
В C # они оба компилируются в String, но в других языках этого не происходит, поэтому вам следует использовать String, если вы хотите иметь дело с объектами String, и string, если вы хотите иметь дело с литералами.
Да, между ними нет разницы, как bool
и в Boolean
.
По этому вопросу есть цитата из книги Дэниела Солиса .
Все предопределенные типы отображаются непосредственно в базовые типы .NET. Имена типов C # (string) являются просто псевдонимами для типов .NET (String или System.String), поэтому использование имен .NET синтаксически работает нормально, хотя это не рекомендуется. В программе на C # вы должны использовать имена C #, а не имена .NET.
Это видео на 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.Object
string:, System.String
bool:, System.Boolean
byte:, System.Byte
sbyte:, System.SByte
short: System.Int16
и так далее
Теперь вопрос на миллион долларов с точки зрения программиста. Так когда же использовать «String» и «string»?
Во-первых, чтобы избежать путаницы, используйте один из них последовательно. Но с точки зрения передового опыта, когда вы делаете объявление переменной, лучше использовать «string» (маленькие «s»), а когда вы используете его в качестве имени класса, тогда «String» (заглавная «S») предпочтительнее.
В приведенном ниже коде левая часть представляет собой объявление переменной, и оно объявлено с использованием «строки». В правой части мы вызываем метод, поэтому «String» более разумно.
string s = String.ToUpper() ;
String
его, предложите «упростить код», перенеся его в string
...
string
: это лексическая конструкция грамматики C #, тогда какSystem.String
это просто тип. Независимо от каких-либо явных различий, упомянутых в какой-либо спецификации, все еще существует неявное различие, которое можно допустить с некоторой неопределенностью. Сам язык должен поддерживатьstring
таким образом, чтобы реализация (совсем) не была так обязательна для конкретного класса в BCL.string
чтобы быть точно такой же , как тип BCLSystem.String
, больше ничего. Это совсем не двусмысленно. Конечно, вы можете реализовать свой собственный компилятор, используя грамматику C #, и использовать все найденные токены для чего-то произвольного, не связанного с тем, что определено в спецификации языка C #. Тем не менее, полученный язык будет похож на C #, его нельзя считать C #.string
без использования директивы для системы. Вы не можете сделать это сString
.string
. Его нужно сокращатьSystem.String
, но, как псевдоним, это выглядит примерно так, но не совсем так. После нескольких лет C #, хотя, я бы сказал, что это безопасно , чтобы просто использоватьstring
иstring.Format()
и не беспокоиться оSystem.String
.System.String
Класс по - прежнему существует, иstring
ключевое слово по - прежнему является псевдонимом для него. Так же, какSystem.Int32
иint
. Они буквально одно и то же.