Пример (обратите внимание на случай):
string s = "Hello world!";
String s = "Hello world!";
Каковы рекомендации по использованию каждого из них? И в чем отличия?
string
является псевдонимом в С# для System.String
.
Технически, нет никакой разницы. Это как int
против System.Int32
.
Что касается рекомендаций, обычно рекомендуется использовать string
каждый раз, когда вы ссылаетесь на объект.
например
string place = "world";
Кроме того, я думаю, что обычно рекомендуется использовать String
если вам нужно обратиться конкретно к классу.
например
string greet = String.Format("Hello {0}!", place);
Похоже, что руководство в этой области, возможно, изменилось, так как StyleCop теперь принудительно использует специальные псевдонимы С#.
Convert
, чтобы сохранить их, переопределив их для каждого языка.
Просто ради полноты, здесь мозговой свалкой связанной информации...
Как отмечали другие, 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
.
String
означает System.String
и это тип .NET Framework. String
является псевдонимом на языке С# для System.String
. Оба они скомпилированы в System.String
в IL (промежуточный язык), поэтому нет никакой разницы. Выберите то, что вам нравится, и используйте это. Если вы набираете код на С#, я бы предпочел String
, поскольку он является псевдонимом типа С# и хорошо известен программистам на С#.
Я могу сказать то же самое о (int
, System.Int32
) и т.д.
Лучший ответ, который я когда-либо слышал об использовании предоставленных псевдонимов типов в С#, дан Джеффри Рихтером в его книге CLR Via С#. Вот его 3 причины:
- Я видел, что некоторые разработчики были сбиты с толку, не зная, использовать ли в своем коде строку или строку. Поскольку в С# строка (ключевое слово) отображается точно в System.String (тип FCL), нет никакой разницы, и любой из них может быть использован.
- В С# long отображается на System.Int64, но на другом языке программирования long может отображаться на Int16 или Int32. Фактически, C++/CLI фактически обрабатывает долго как Int32. Кто-то, читающий исходный код на одном языке, может легко неверно истолковать намерение кода, если он или она привыкли к программированию на другом языке программирования. На самом деле, большинство языков не будет даже рассматривать долго, как ключевое слово и не будет компилировать код, который использует его.
- В FCL есть много методов, имена которых являются частью имен их методов. Например, тип BinaryReader предлагает такие методы, как ReadBoolean, ReadInt32, ReadSingle и т.д., А тип System.Convert предлагает такие методы, как ToBoolean, ToInt32, ToSingle и т.д. Хотя и разрешено писать следующий код, строка с плавающей точкой кажется мне неестественной, и не очевидно, что строка правильная:
BinaryReader br = new BinaryReader(...);
float val = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good
Так что у вас есть это. Я думаю, что это действительно хорошие моменты. Однако я не использую советы Джеффри в своем собственном коде. Возможно, я слишком застрял в своем мире С#, но в итоге я пытаюсь сделать мой код похожим на фреймворк.
string
, int
и т. Д.
string
- зарезервированное слово, но string
- это просто имя класса.
Это означает, что string
не может использоваться как имя переменной сам по себе.
Если по какой-то причине вам нужна переменная с именем string, вы увидите только первый из этих компиляций:
StringBuilder String = new StringBuilder(); // compiles
StringBuilder string = new StringBuilder(); // doesn't compile
Если вы действительно хотите, чтобы имя переменной называлось строкой, вы можете использовать @
в качестве префикса:
StringBuilder @string = new StringBuilder();
Другое критическое различие: переполнение стека подчеркивает их по-разному.
@string
на самом деле довольно бессмысленно, поскольку имена локальных @string
присутствуют только в PDB. _string
также назвать это _string
или что-то. Это имеет больше смысла для вещей, имена которых доступны через отражение, где имя члена @string
будет "string"
.
Существует одна разница - вы не можете использовать String
без using System;
заранее.
using
операторы , которые мне нужны, и явно удалить все , что у меня нет. Инструменты Power Productivity> «[x] Удаление и форматирование использования при сохранении»
Это было рассмотрено выше; однако вы не можете использовать string
в отражении; вы должны использовать string
.
System.String
является.NET строки класса - в С# string
является псевдонимом для System.String
- так в использовании они одинаковы.
Что касается руководящих принципов, я бы не стал слишком увязшим и просто использовал бы то, что вам хочется - в жизни есть более важные вещи, и в любом случае код будет одинаковым.
Если вы обнаружите, что вы строите системы, где необходимо указать размер целых чисел, которые вы используете, и поэтому они имеют тенденцию использовать Int16
, Int32
, UInt16
, UInt32
и т.д., Тогда было бы более естественно использовать String
- и при перемещении между различными.net, это может сделать вещи более понятными - иначе я бы использовал строку и int.
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();
Смотрите здесь: с использованием директивы (ссылка на С#)
Я предпочитаю капитализированные типы .NET
(а не псевдонимы) для форматирования. Типы .NET
окрашены так же, как и другие типы объектов (в конце концов, являются типами значений).
Условные и управляющие ключевые слова (например, if
, switch
и return
) имеют строчные и цветные синие цвета (по умолчанию). И я предпочел бы не иметь разногласий в использовании и формате.
Рассмотрим:
String someString;
string anotherString;
Int32 i=1;
вместо int i = 1;
Я считаю, что первое более читабельно в отношении моих намерений, а именно: я хочу получить 32-разрядное целое число со знаком.
string
и string
идентичны во всех отношениях (кроме прописных букв "S" ). Никаких последствий для производительности не имеет.
Нижний регистр string
является предпочтительным в большинстве проектов из-за подсветки синтаксиса
С# - это язык, который используется вместе с CLR.
string
- это тип в С#.
System.String
- это тип в CLR.
При использовании С# вместе с CLR string
будет отображаться System.String
.
Теоретически вы можете реализовать С# -компилятор, который генерировал байт-код Java. Разумная реализация этого компилятора, вероятно, будет отображать string
на java.lang.String
, чтобы взаимодействовать с библиотекой времени выполнения Java.
string
не является типом в C #; это зарезервированное слово, которое отображается на тип в CLR.
Это видео YouTube демонстрирует практически то, как они отличаются.
Но теперь для длинного текстового ответа.
Когда мы говорим о .NET
, существует две разные вещи: существует .NET
framework, а другая есть языки (C#
, VB.NET
и т.д.), которые используют эту инфраструктуру.
"System.String
" a.k.a "String" (капитал "S" ) - это тип данных структуры .NET
, тогда как "string" - это тип данных C#
.
Короче говоря, "String" - это псевдоним (то же самое, что называется с разными именами) "string" . Так что технически оба приведенных ниже оператора кода будут давать одинаковый результат.
String s = "I am String";
или
String s = "I am String";
Таким же образом существуют псевдонимы для другого типа данных С#, как показано ниже: -
object: System.Object
, строка: System.String
, bool: System.Boolean
, byte: System.Byte
, sbyte: System.SByte
, short: System.Int16
и т.д.
Теперь вопрос в миллион долларов с точки зрения программиста Итак, когда использовать "String" и "string" ?
Во-первых, чтобы избежать путаницы, используйте один из них последовательно. Но из соображений лучшей практики, когда вы делаете объявление переменной, полезно использовать "string" (small "s" ), и когда вы используете его как имя класса, предпочтительнее "String" (капитал "S" ).
В приведенном ниже коде левая сторона является объявлением переменной и объявляется с использованием "string" . С правой стороны мы вызываем метод, поэтому "String" более разумный.
string s = String.ToUpper() ;
String
она предлагает вам «упростить код», перенося его в string
...
Нижний регистр string
является псевдонимом для System.String
.
Они одинаковы в C#
.
Там обсуждается, следует ли использовать типы систем (System.Int32
, System.String
и т.д.) или C# aliases
(int
, string
и т.д.). Я лично считаю, что вы должны использовать C# aliases
, но это только мои личные предпочтения.
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
вместо string
. Это то, что обычно используют разработчики. например вместо Int32
мы используем int
, поскольку int
является псевдонимом Int32
FYI
"Строка ключевого слова - просто псевдоним для предопределенного класса System.String
". - Спецификация языка С# 4.2.3
http://msdn2.microsoft.com/En-US/library/aa691153.aspx
Как говорят другие, они одинаковы. По умолчанию правила StyleCop заставят вас использовать string
как наилучшую практику стиля кода на С#, за исключением случаев, когда ссылаются на статические функции System.String
, такие как String.Format
, String.Join
, String.Concat
и т.д.
Против того, что кажется обычной практикой среди других программистов, я предпочитаю String
over String
, чтобы подчеркнуть тот факт, что String
является ссылочным типом, как упоминал Джон Скит.
Использование типов системы упрощает перенос между С# и VB.Net, если вы в этом ведете.
string
является псевдонимом (или сокращением) System.String
. Это означает, что, набрав string
, мы имели в виду System.String
. Вы можете прочитать больше в мысленной ссылке: 'string' - это псевдоним/стенография System.String.
Поздняя вечеринка: я использую типы CLR 100% времени (ну, кроме того, если принудительно использовать тип С#, но я не помню, когда это было в последний раз).
Я изначально начал делать это много лет назад, согласно книгам CLR от Ritchie. Мне было разумно, что все языки CLR в конечном итоге должны иметь возможность поддерживать набор типов CLR, поэтому использование типов CLR обеспечивало бы более четкий и, возможно, более "многоразовый" код.
Теперь, когда я делал это в течение многих лет, это привычка, и мне нравится окраска, которую VS показывает для типов CLR.
Единственный реальный downer заключается в том, что auto-complete использует тип С#, поэтому я в конечном итоге повторно набираю автоматически сгенерированные типы, чтобы указать тип CLR.
Кроме того, теперь, когда я вижу "int" или "string", это выглядит просто неправильно для меня, например, я смотрю код 1970 C.
String (System.String
) - это класс в библиотеке базового класса. string (нижний регистр) - это зарезервированная работа в С#, которая является псевдонимом для System.String. Int32 vs int аналогичная ситуация, как и Boolean vs. bool
. Эти ключевые слова на языке С# позволяют объявлять примитивы в стиле, аналогичном C.
String
не является ключевым словом и может использоваться как идентификатор, тогда как String
является ключевым словом и не может использоваться как идентификатор. И в функциональной точке зрения оба они одинаковы.
Я просто хотел бы добавить это к ответу lfousts, из книги Ritchers:
Спецификация языка С# гласит: "В зависимости от стиля использование ключевого слова предпочтительнее использования полного имени типа системы". Я не согласен с языковой спецификацией; Я предпочитаю использовать имена типов FCL и полностью избегать примитивных имен типов. На самом деле, мне жаль, что компиляторы даже не предложили примитивные имена типов и заставили разработчиков вместо этого использовать имена типов FCL. Вот мои причины:
Ive видел, как некоторые разработчики путались, не зная, использовать ли строку или String в своем коде. Потому что в строке С# (ключевое слово) точно сопоставляется с System.String (тип FCL), нет никакой разницы и может быть использована. Аналогично, Ive слышал, что некоторые разработчики говорят, что int представляет собой 32-разрядное целое число, когда приложение работает на 32-разрядной ОС и что оно представляет собой 64-разрядное целое, когда приложение работает в 64-разрядной ОС. Это утверждение абсолютно неверно: в С# int всегда сопоставляется с System.Int32 и поэтому представляет собой 32-разрядное целое, независимо от ОС, на котором работает код. Если программисты будут использовать Int32 в своем коде, то эта потенциальная путаница также будет устранена.
В С#, long maps to System.Int64, но на другом языке программирования, long может отображать Int16 или Int32. В самом деле, C++/CLI это лечить долго, как Int32. Кто-то, читающий исходный код на одном языке, может легко неверно интерпретировать намерение кодов, если он или она использовались для программирования на другом языке программирования. На самом деле, большинство языков даже долго не будут рассматривать ключевое слово и не будут компилировать код, который его использует.
FCL имеет множество методов, которые имеют имена типов как часть имен их методов. Например, тип BinaryReader предлагает такие методы, как ReadBoolean, ReadInt32, ReadSingle и т.д., А тип System.Convert предлагает такие методы, как ToBoolean, ToInt32, ToSingle и т.д. Хотя законно писать следующий код, линия с поплавком кажется мне очень неестественной, и не очевидно, что строка правильная:
BinaryReader br = new BinaryReader(...); float val = br.ReadSingle(); // OK, but feels unnatural Single val = br.ReadSingle(); // OK and feels good
Многие программисты, использующие С#, имеют тенденцию забывать, что другие языки программирования могут использоваться против CLR, и из-за этого С# -isms ползут в код библиотеки классов. Например, Microsoft FCL почти исключительно написан на С#, а разработчики из команды FCL теперь внедрили методы в библиотеку, такие как Array s GetLongLength, которая возвращает значение Int64, которое длиннее на С#, но не на других языках (например, [CN10 ]/CLI). Другим примером является метод System.Linq.Enumerable s LongCount.
Я не получил его мнения, прежде чем я прочитал полный параграф.
На самом деле это вопрос конвенции. string
просто больше похожа на стиль C/C++. Общее соглашение заключается в том, чтобы использовать любые ярлыки, выбранные вашим выбранным языком (int/Int для Int32
). Это относится и к "объекту" и decimal
.
Теоретически это могло бы помочь перекодировать код в какой-то будущий 64-битный стандарт, в котором "int" может означать Int64
, но это не так, и я ожидал бы, что любой мастер обновления изменит любые int
ссылки на Int32
любом случае просто для того, чтобы быть в безопасности.
Нет никакой разницы.
Ключевое слово С# string
относится к типу .NET System.String
- это псевдоним, который поддерживает соглашения об именах языка.
Аналогично, int
отображается на System.Int32
.
Новый ответ через 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"
не может быть преобразовано в него.
using String = System.Int32; using Int32 = System.String;
а затем посчитать ошибки.
string
является System.String
. String
может быть чем угодно.
строка - это ключевое слово, и вы не можете использовать строку в качестве идентификатора.
Строка не является ключевым словом, и вы можете использовать ее как идентификатор:
Пример
string String = "I am a string";
Ключевое слово string
является псевдонимом для
System.String
Помимо проблемы с ключевым словом,
эквивалентны.
typeof(string) == typeof(String) == typeof(System.String)
Вот цитата из этой статьи из книга Даниэля Солиса.
Все предопределенные типы отображаются непосредственно на основных типов .NET. Названия типов С# (строка) - это просто псевдонимы для .NET(String или System.String), поэтому использование имен .NET отлично работает синтаксически, хотя это обескураживает. В рамках программы С# вы должны использовать имена С# а не имена .NET.
Да, нет никакой разницы между ними, как и bool
и Boolean
.
Нет разницы между двумя - string
, однако, представляется предпочтительным вариантом при рассмотрении исходного кода других разработчиков.
Один аргумент, не упомянутый в другом месте, предпочитает случай pascal String
:
System.String
является ссылочным типом, а имена ссылочных типов - это случай pascal по соглашению.
string
действительно является ключевым словом C #. Вопрос, который здесь задают, заключается в том, предпочитать ли ключевое слово или имя типа. Мой ответ говорит, что, хотя вы, очевидно, можете выбрать ключевое слово, один аргумент в пользу использования имени типа состоит в том, что string
ключевого слова они, которая является псевдонимом для String
, в конечном счете является ссылочным типом. В отличие от этого, ключевое слово int
псевдоним для Int32
который является типом значения.
Оба одинаковы. Разница в том, как вы его используете. Конвенция,
s tring для переменных
S tring для вызова других методов класса String
Как
string fName = "John";
string lName = "Smith";
string fullName = String.Concat(fName,lName);
if (String.IsNullOrEmpty(fName))
{
Console.WriteLine("Enter first name");
}
String
программа предлагает вам «упростить код», перенося его в 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
относится к строковому объекту, который поставляется с различными функциями для управления содержащейся строкой.
String
относится к примитивному типу
В С# они компилируются в String, но на других языках они не так, поэтому вы должны использовать String, если хотите иметь дело со строковыми объектами и строкой, если вы хотите иметь дело с литералами.
Если вам действительно полезно видеть, что между string
и System.String
нет разницы:
var method1 = typeof(MyClass).GetMethod("TestString1").GetMethodBody().GetILAsByteArray();
var method2 = typeof(MyClass).GetMethod("TestString2").GetMethodBody().GetILAsByteArray();
//...
public string TestString1()
{
string str = "Hello World!";
return str;
}
public string TestString2()
{
String str = "Hello World!";
return str;
}
Оба создают точно такой же массив байтов IL:
[ 0, 114, 107, 0, 0, 112, 10, 6, 11, 43, 0, 7, 42 ]
return "Hello World!";
, Чтобы убедиться, что типы «считаются», вы можете использовать return (string)(object)typeof(string).Name;
и return (System.String)(System.Object)typeof(System.String).Name;
, что подтверждает, что System.Object
тоже идентичен object
:-)
Практически нет разницы
Строка ключевого слова С# соответствует типу.NET. System.String - это псевдоним, который поддерживает соглашения об именах языка.
Вам не нужно импортировать пространство имен (используя System
;), чтобы использовать string
потому что это глобальный псевдоним System.String
.
Чтобы узнать больше о псевдонимах вы можете проверить эту ссылку.
Существует одно практическое различие между string
и String
.
nameof(String); // compiles
nameof(string); // doesn't compile
Это связано с тем, что string
является ключевым словом (псевдоним в этом случае), тогда как String
является типом.
То же самое верно и для других псевдонимов.
| Alias | Type |
|-----------|------------------|
| bool | System.Boolean |
| byte | System.Byte |
| sbyte | System.SByte |
| char | System.Char |
| decimal | System.Decimal |
| double | System.Double |
| float | System.Single |
| int | System.Int32 |
| uint | System.UInt32 |
| long | System.Int64 |
| ulong | System.UInt64 |
| object | System.Object |
| short | System.Int16 |
| ushort | System.UInt16 |
| string | System.String |
Прежде всего, оба (string & String) не одинаковы. Существует разница: String не является ключевым словом, и его можно использовать как идентификатор, тогда как строка является ключевым словом и не может использоваться как идентификатор.
Я пытаюсь объяснить с помощью другого примера: во-первых, когда я помещаю "string s;" в Visual Studio и наведите курсор на него, я получаю (без цвета):
Это говорит о том, что строка - System.String, правильно? Документация находится на https://msdn.microsoft.com/en-us/library/362314fe.aspx. Во втором предложении говорится: "string - это псевдоним для String в.NET Framework".
Джеффри Рихтер написал:
Другой способ думать об этом является то, что С# компилятор автоматически предполагает, что у вас есть следующие с
using
директивы во всех ваших файлов исходного кода:
using int = System.Int32;
using uint = System.UInt32;
using string = System.String;
...
Ive видел, как некоторые разработчики путались, не зная, использовать ли строку или String в своем коде. Потому что в строке С# (ключевое слово) точно сопоставляется с System.String (тип FCL), нет никакой разницы и может быть использована.
Честно говоря, на практике обычно нет разницы между System.String и строкой.
Все типы в С# являются объектами, а все происходит из класса System.Object. Одно отличие состоит в том, что строка является ключевым словом С# и Строка, которую вы можете использовать как имя переменной. System.String - это обычное имя .NET этого типа, а строка - это удобное имя С#. Вот простая программа, которая представляет разницу между System.String и строкой.
string a = new string(new char[] { 'x', 'y', 'z' });
string b = new String(new char[] { 'x', 'y', 'z' });
String c = new string(new char[] { 'x', 'y', 'z' });
String d = new String(new char[] { 'x', 'y', 'z' });
MessageBox.Show((a.GetType() == typeof(String) && a.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((b.GetType() == typeof(String) && b.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((c.GetType() == typeof(String) && c.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((d.GetType() == typeof(String) && d.GetType() == typeof(string)).ToString()); // shows true
@JonSkeet в моем компиляторе
public enum Foo : UInt32 { }
работает. У меня есть сообщество Visual Studio 2015.
Между ними нет никакой разницы. Вы можете использовать любой из них в своем коде.
System.String
- это класс (ссылочный тип), определяемый mscorlib
в пространстве имен System
. Другими словами, System.String
является типом в CLR
.
string
- это ключевое слово в C#
Строка - это последовательный набор символов, который используется для представления текста.
Объект String представляет собой последовательную коллекцию объектов System.Char, которые представляют строку; объект System.Char соответствует единице кода UTF-16.
Значением объекта String является содержимое последовательной коллекции объектов System.Char, и это значение является неизменным (то есть оно доступно только для чтения).
Для получения дополнительной информации об неизменяемости строк см. Раздел Immutability и класс StringBuilder в msdn.
Максимальный размер объекта String в памяти составляет 2 ГБ или около 1 миллиарда символов.
Примечание: ответ извлечен из раздела справки msdn. Вы можете увидеть полное содержимое здесь в теме msdn String Class в разделе Замечания
Как указано, это одно и то же, а string
- это просто псевдоним string
.
Для чего стоит, я использую строку для объявления типов - переменных, свойств, возвращаемых значений и параметров. Это согласуется с использованием других типов систем - int, bool, var
и т.д. (Хотя Int32
и Boolean
также верны).
Я использую string
при использовании статических методов в классе String, например String.Split()
или String.IsNullOrEmpty()
. Я чувствую, что это имеет больше смысла, потому что методы принадлежат классу, и это согласуется с тем, как я использую другие статические методы.
В С# строка - это короткая версия System.String(String). Они в основном означают одно и то же.
Как и кто-то упоминал, это просто как bool
и Boolean
, не так уж и много.
Я предпочитаю использовать string
, потому что этот тип используется настолько, что я не хочу, чтобы синтаксический ярлык смешивал его со всеми другими классами. Хотя это класс, он используется больше как примитив, поэтому я думаю, что цвет подсветки подходит.
Если вы щелкните правой кнопкой мыши по ключевому слову string
и выберите Go to definition
в контекстном меню, вы попадете в класс string
- это просто синтаксический сахар, но он улучшит читаемость imo.
равна System.String
в VS2015, если вы напишете это
System.String str;
Затем компилятор покажет потенциальное исправление, чтобы его оптимизировать, и после применения этого исправления он будет выглядеть так:
string str;
Насколько я знаю, string
является просто псевдонимом для System.String
, и аналогичные псевдонимы существуют для bool
, object
, int
... Единственное тонкое различие заключается в том, что вы можете использовать string
без директивы "using System;
", в то время как для нее требуется строка (иначе вы должны полностью указать System.String
).
О том, что лучше всего использовать, я думаю, это вопрос вкуса. Лично я предпочитаю string
, но я не религиозный вопрос.
String: Объект String называется неизменяемым (только для чтения), поскольку его значение не может быть изменено после его создания. Методы, которые, как представляется, изменяют объект String, фактически возвращают новый объект String, содержащий модификацию. Если необходимо изменить фактическое содержимое строкового объекта
string: Тип строки представляет собой последовательность из ноль или более символов Unicode. string - это псевдоним для String в .NET Framework. string
является внутренним типом С# и является псевдонимом для системного типа "System.String". Спецификация С# заявляет, что в качестве стиля ключевое слово (строка) предпочтительнее всего имени системного типа (System.String или String).
Хотя строка является ссылочным типом, операторы равенства (== и! =) Определены для сравнения значений строковых объектов, а не ссылок. Это делает тестирование для равенства строк более интуитивным. Например:
Разница между строкой и строкой:
string
обычно используется для объявления, а string
используется для доступа к статическим строковым методам.'string'
do объявить поля, свойства и т.д., которые используют предопределенный тип 'string'
, так как спецификация С# говорит мне, что это хороший стиль.'string'
для использования системных методов, таких как String.Compare и т.д. Первоначально они определены в "System.String", а не "string". 'string'
- это просто псевдоним в этом случае.'string'
или 'System.Int32' при общении с другой системой, особенно если они совместимы с CLR. то есть, если я получаю данные из других источников, я бы де-сериализовал его в System.Int32, а не в "int", если происхождение по определению было чем-то иным, чем системой С#.String
и string
- это одно и то же.
string
- это короткое имя System.String
. String
или System.String
- это имя строки в CTS(Common Type System)
.
Строка: представляет класс
строка: представляет псевдоним
Это просто соглашение о кодировании от Microsoft.
string - это ярлык для System.String
. Единственное отличие состоит в том, что вам не нужно ссылаться на пространство имен System.String
. Так что лучше использовать строку, чем String.
Как вы уже знаете, string
является просто псевдонимом для System.String
. Но что я должен использовать? это просто личное предпочтение.
В моем случае я люблю использовать string
а не использовать System.String
потому что для String
требуется пространство имен, using System;
или полное имя System.String
.
Поэтому я считаю, что string
псевдонима была создана для простоты, и мне это нравится!
string - это псевдоним для String в .NET Framework.
Где "String" на самом деле System.String.
Я бы сказал, что они взаимозаменяемы, и нет никакой разницы, когда и где вы должны использовать тот или иной.
Было бы лучше соглашаться с тем, что вы использовали.
Для чего стоит, я использую string
для объявления типов - переменных, свойств, возвращаемых значений и параметров. Это согласуется с использованием других типов систем - int, bool, var
и т.д. (Хотя Int32
и Boolean
также верны).
Я использую String при использовании статических методов в классе String, например String.Split()
или String.IsNullOrEmpty()
. Я чувствую, что это имеет больше смысла, потому что методы принадлежат классу, и это согласуется с тем, как я использую другие статические методы.
В С# строка - это псевдоним для класса String в .NET framework. Фактически, каждый тип С# имеет эквивалент в .NET. В качестве другого примера, short и int на С# сопоставляем Int16 и Int32 в .NET.
Итак, технически нет никакой разницы между строкой и строкой, но общепринятой практикой является объявление переменной с использованием ключевых слов С#. Ive вряд ли видел, что кто-то объявляет целое число с Int32!
Единственное небольшое различие заключается в том, что если вы используете класс String, вам нужно импортировать пространство имен System поверх вашего файла, тогда как вам не нужно делать это при использовании ключевого слова string.
Многие разработчики предпочитают объявлять строковую переменную со строкой, но при использовании одного из своих статических членов используют класс String:
1
String.Format()
общепринятой практикой является объявление переменной с использованием ключевых слов С#. Фактически, каждый тип С# имеет эквивалент в.NET. В качестве другого примера, short и int на С# сопоставляем Int16 и Int32 в.NET. Итак, технически нет никакой разницы между строкой и строкой, но в С# строка - это псевдоним для класса String в.NET framework.
String
- это класс string
. Если вы удалите System
namespace из использования операторов, вы увидите, что String
пошла, но string
все еще здесь. string
- ключевое слово для String. подобно int and Int32
short and Int16
long and Int64
Таким образом, ключевые слова - это просто слова, которые используют класс. Эти ключевые слова заданы С# (поэтому Microsoft, потому что С# является Microsoft). Вкратце, нет никакой разницы. Использование string or String
. Это не имеет значения. Они такие же.
В С# string
- это псевдоним для класса System.String
в.NET framework. Фактически, каждый тип С# имеет эквивалент в.NET. В качестве другого примера, short
и int
в С# сопоставляем System.Int16
и System.Int32
в.NET.
Таким образом, технически нет никакой разницы между string
и String
, но общепринятой практикой является объявление переменной с использованием ключевых слов С#. Ive вряд ли видел, что кто-то объявляет целое число с Int32
.
Единственное небольшое различие заключается в том, что если вы используете класс String, вам нужно импортировать пространство имен System поверх вашего файла, тогда как вам не нужно делать это при использовании ключевого слова string.
Многие разработчики предпочитают объявлять string
переменную со строкой, но при использовании одного из ее static
элементов используют класс System.String
:
String.Format();
String - это класс .net framework, где в качестве строки является класс С#.
Строка - это не что иное, как псевдоним для класса String. Если вы хотите использовать функции класса string, вы должны использовать String else, который вы должны придерживаться в строке. Например, если вы хотите отформатировать строку, вы должны использовать класс String для использования String.Format()
, но если вы просто хотите определить строку, вы должны использовать string test="";
Обратите внимание, что оба они являются ссылочными типами.
Простой способ: строка - тип данных, Строка - это класс.
Факты о строке:
System.String
String class
, созданный Microsoft
Строка - тип значения (тип данных) - это ключевое слово C#
string - это ярлык компилятора для System.String
class
string
- это лексическая конструкция грамматики C #, тогда какSystem.String
- просто тип. Независимо от каких-либо явных различий, упомянутых в какой-либо спецификации, все еще существует неявное различие, которое можно допустить с некоторой неопределенностью. Сам язык должен поддерживатьstring
таким образом, чтобы реализация (совсем) не была так обязательна для конкретного класса в BCL.string
точно такой же, как и BCL-типSystem.String
, больше ничего. Это совсем не двусмысленно. Конечно, вы можете реализовать свой собственный компилятор, используя грамматику C #, и использовать все найденные токены для чего-то произвольного, не связанного с тем, что определено в спецификации языка C #. Тем не менее, результирующий язык будет только похож на C #, его нельзя считать C #.