В чем разница между строкой и строкой в C#?
https://stackoverflow.com/questions/7074
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Пример (обратите внимание на случай):
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 имеет тенденцию использовать в их примеры.
Похоже, что руководство в этой области могло измениться, поскольку СтильКоп теперь принудительно использует специальные псевдонимы C#.
Другие советы
Просто для полноты картины, вот вам соответствующая информация...
Как отмечали другие, 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 означает System.String и это тип .NET Framework. string это псевдоним на языке C# для System.String.Оба они скомпилированы в System.String в Иллинойсе (средний язык), так что разницы нет.Выбирайте то, что вам нравится, и используйте это.Если вы кодируете на C#, я бы предпочел string поскольку это псевдоним типа C#, хорошо известный программистам C#.
Я могу сказать то же самое о (int, System.Int32) и т. д..
Лучший ответ, который я когда-либо слышал об использовании предоставленных псевдонимов типов в C#, дал Джеффри Рихтер в его книге. CLR через C#.Вот его 3 причины:
- Я видел, как многие разработчики были в замешательстве, не зная, стоит ли использовать нить или Нить в их коде.Поскольку в C# строка (ключевое слово) точно сопоставляется с System.String (тип FCL), разницы нет, и можно использовать любой из них.
- В С#, длинный карты в System.Int64, но на другом языке программирования, длинный может сопоставиться с Int16 или Int32.Фактически, C++/CLI действительно рассматривает long как Int32.Кто-то, читающий исходный код на одном языке, может легко неправильно истолковать назначение кода, если он или она привыкли программировать на другом языке программирования.Фактически, большинство языков даже не обрабатывают длинный в качестве ключевого слова и не будет компилировать код, который его использует.
- FCL имеет множество методов, в именах которых есть имена типов.Например, БинарныйReader type предлагает такие методы, как Читать логическое значение, ReadInt32, ЧитатьSingle, и так далее, и Система.Конвертировать type предлагает такие методы, как ToBoolean, ТоИнт32, ToSingle, и так далее.Хотя написание следующего кода является законным, строка с плавающей запятой кажется мне очень неестественной, и неочевидно, что она верна:
BinaryReader br = new BinaryReader(...);
float val = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good
Итак, вот оно.Я думаю, что это все действительно хорошие моменты.Однако я не использую советы Джеффри в своем собственном коде.Возможно, я слишком застрял в своем мире C#, но в конечном итоге я пытаюсь сделать свой код похожим на код платформы.
string это зарезервированное слово, но String это просто имя класса.Это значит, что string не может использоваться как имя переменной само по себе.
Если по какой-то причине вам нужна переменная с именем нить, вы увидите только первую из этих компиляций:
StringBuilder String = new StringBuilder(); // compiles
StringBuilder string = new StringBuilder(); // doesn't compile
Если вы действительно хотите, чтобы имя переменной называлось нить вы можете использовать @ в качестве префикса:
StringBuilder @string = new StringBuilder();
Еще одно критическое отличие:Stack Overflow выделяет их по-разному.
Есть одно отличие - ты не можешь использовать String без using System; заранее.
Это было рассмотрено выше;однако вы не можете использовать string в отражении;ты должен использовать String.
System.String это строковый класс .NET - в C# string это псевдоним для System.String - так что в использовании они одинаковы.
Что касается рекомендаций, я бы не стал слишком увязнуть и просто использовал бы то, что вам хочется — в жизни есть более важные вещи, и код в любом случае будет тот же.
Если вы создаете системы, в которых необходимо указывать размер используемых вами целых чисел, и поэтому склонны использовать Int16, Int32, UInt16, UInt32 и т. д.тогда использование может выглядеть более естественным String - и при перемещении между разными языками .net это может сделать ситуацию более понятной - в противном случае я бы использовал string и int.
Я предпочитаю с большой буквы .NET типы (а не псевдонимы) по причинам форматирования.А .NET типы окрашены так же, как и другие типы объектов (в конце концов, типы значений являются настоящими объектами).
Условные и управляющие ключевые слова (например, if, switch, и return) написаны строчными буквами и окрашены в темно-синий цвет (по умолчанию).И я бы предпочел, чтобы не было разногласий в использовании и формате.
Учитывать:
String someString;
string anotherString;
string и String идентичны во всех отношениях (кроме заглавной буквы «S»).В любом случае никаких последствий для производительности нет.
строчные буквы string предпочтителен в большинстве проектов из-за подсветки синтаксиса
C# — это язык, который используется вместе с CLR.
string — это тип в C#.
System.String — это тип в CLR.
Когда вы используете C# вместе с CLR string будет сопоставлен с System.String.
Теоретически вы можете реализовать компилятор C#, который генерирует байт-код Java.Разумная реализация этого компилятора, вероятно, отобразит string к java.lang.String для взаимодействия с библиотекой времени выполнения Java.
Этот YouTube видео демонстрирует практически, чем они отличаются.
А теперь длинный текстовый ответ.
Когда мы говорим о .NET это две разные вещи, одна есть .NET framework и другие есть языки ( C# , VB.NET и т. д.), которые используют эту структуру.
"System.String", также известная как "Строка" (заглавная "S"), представляет собой .NET тип данных платформы, в то время как «строка» является C# тип данных.
Короче говоря, «Строка» — это псевдоним (одно и то же, называемое разными именами) «строки».Таким образом, технически оба приведенных ниже оператора кода дадут одинаковый результат.
String s = "I am String";
или
string s = "I am String";
Точно так же существуют псевдонимы для других типов данных С#, как показано ниже: -
объект: System.Object, нить: System.String, бул: System.Boolean, байт: System.Byte, сбайт: System.SByte, короткий: System.Int16 и так далее
Теперь вопрос на миллион долларов с точки зрения программиста. Итак, когда использовать «String» и «string»?
Прежде всего, чтобы избежать путаницы, используйте один из них последовательно.Но с точки зрения передового опыта, когда вы объявляете переменную, хорошо использовать «строку» (маленькая «s»), а когда вы используете ее в качестве имени класса, тогда предпочтительнее «String» (заглавная «S»).
В приведенном ниже коде левая часть представляет собой объявление переменной, объявленной с использованием «строки».С правой стороны мы вызываем метод, поэтому «String» более разумно.
string s = String.ToUpper() ;
Нижний регистр string это псевдоним для System.String.Они одинаковы в C#.
Ведутся споры о том, следует ли использовать системные типы (System.Int32, System.String, и т. д.) типов или C# aliases (int, string, и т. д).Я лично считаю, что вам следует использовать C# aliases, но это только мое личное предпочтение.
string это просто псевдоним для System.String.Компилятор будет относиться к ним одинаково.
Единственное практическое отличие - это подсветка синтаксиса, как вы упомянули, и вам нужно написать using System если ты используешь String.
Оба одинаковы.Но с точки зрения рекомендаций по кодированию лучше использовать string вместо String.Это то, что обычно используют разработчики.напримерВместо того, чтобы использовать Int32 мы используем int как int это псевдоним Int32
К вашему сведению «Строка ключевого слова - это просто псевдоним для предопределенного класса System.String. - C# языковая спецификация 4.2.3http://msdn2.microsoft.com/En-US/library/aa691153.aspx
Как говорят остальные, они одинаковы.Правила StyleCop по умолчанию обязывают вас использовать string как лучшая практика стиля кода C#, за исключением случаев ссылки System.String статические функции, такие как String.Format, String.Join, String.Concat, и т. д...
Новый ответ через 6 лет и 5 месяцев (прокрастинация).
Пока string — это зарезервированное ключевое слово C#, которое всегда имеет фиксированное значение, 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) скорее всего (в зависимости от usings) перейдите к методу расширения 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 это всегда фортепиано нить, MyPiano.String.Нет участника (static или нет) Format существует на нем (или наследуется от его базового класса).И ценность "Goodbye" не может быть преобразовано в него.
Использование системных типов упрощает портирование между C# и VB.Net, если вам нравятся подобные вещи.
В отличие от того, что кажется общепринятой практикой среди других программистов, я предпочитаю String над string, просто чтобы подчеркнуть тот факт, что String является ссылочным типом, как упомянул Джон Скит.
string это псевдоним (или сокращение) System.String.Это означает, что, набрав string мы имели в виду System.String.Вы можете прочитать больше в думающей ссылке: «строка» — это псевдоним/сокращение от System.String.
Нить (System.String) — это класс в библиотеке базовых классов.строка (нижний регистр) — это зарезервированная работа в C#, которая является псевдонимом для System.String.Int32 vs int — аналогичная ситуация, как и Boolean vs. bool.Эти ключевые слова, специфичные для языка C#, позволяют объявлять примитивы в стиле, аналогичном C.
Я просто хотел бы добавить это к ответу Ифаста из книги Ритчера:
В спецификации языка C# говорится: «В качестве стиля использование ключевого слова предпочитается в результате использования полного имени типа системы». Я не согласен с языковой спецификацией;Я предпочитаю использовать имена типов FCL и полностью избегать имен примитивных типов.На самом деле, я хотел бы, чтобы компиляторы даже не предлагали имена примитивных типов и вынужденные разработчики для использования имен типов FCL.Вот мои причины:
Я видел, как многие разработчики были в замешательстве, не зная, стоит ли использовать нитьили Нить в их коде.Потому что в С# нить (ключевое слово) точно соответствует Система.Строка (тип FCL), разницы нет, можно использовать любой из них.Точно так же я слышал, как некоторые разработчики говорят, что интервал Представляет 32-разрядное целое число, когда приложение работает на 32-разрядной ОС и представляет 64-разрядное целое число, когда приложение работает на 64-разрядной ОС.Это утверждение абсолютно неверно:в C#, интервал всегда карты System.Int32, и, следовательно, он представляет 32-разрядное целое число независимо от ОС, на которой работает код.Если бы программисты использовали Int32 В их коде это потенциальное путаницу также устраняется.
В С#, длинный карты в System.Int64, но на другом языке программирования, длинныйможет сопоставиться с Int16 или Int32.Фактически, C++/CLI лечит длинный как Int32.Кто -то, читающий исходный код на одном языке, может легко неверно истолковывать намерение кода, если он или она привыкли к программированию на другом языке программирования.Фактически, большинство языков даже не рассматривают длинный как ключевое слово и не будет компилировать код, который его использует.
FCL имеет множество методов, в именах которых есть имена типов.Например, БинарныйReader type предлагает такие методы, как Читать логическое значение, ReadInt32, ЧитатьSingle, и так далее, и Система.Конвертировать type предлагает такие методы, как ToBoolean, ТоИнт32, ToSingle, и так далее.Хотя законно писать следующий код, строка с плавать Мне кажется очень неестественным, и не очевидно, что линия верна:
BinaryReader br = new BinaryReader(...); float val = br.ReadSingle(); // OK, but feels unnatural Single val = br.ReadSingle(); // OK and feels goodМногие программисты, которые используют C# исключительно, склонны забывать, что другие языки программирования могут быть использованы против CLR, и из-за этого C# -ISMS проникают в код библиотеки классов.Например, FCL Microsoft почти исключительно написан в C#, а разработчики в команде FCL теперь ввели методы в библиотеку, такие как Множествох GetLongLength, который возвращает Int64 ценность, которая представляет собой длинный в C#, но не на других языках (например, C ++/CLI).Другой пример: System.Linq.Enumerableх ЛонгКаунт метод.
Я не узнал его мнения, пока не прочитал весь абзац.
String не является ключевым словом и может использоваться в качестве идентификатора, тогда как string является ключевым словом и не может использоваться в качестве идентификатора.И с функциональной точки зрения оба одинаковы.
Опоздал на вечеринку:Я использую типы CLR 100% времени (ну, за исключением случаев, когда принужденный использовать тип C#, но я не помню, когда это было в последний раз).
Первоначально я начал делать это много лет назад, согласно книгам Ричи по CLR.Для меня имело смысл, что все языки CLR в конечном итоге должны иметь возможность поддерживать набор типов CLR, поэтому использование типов CLR самостоятельно обеспечивает более понятный и, возможно, более «многоразовый» код.
Теперь, когда я делаю это уже много лет, это вошло в привычку, и мне нравится окраска, которую VS отображает для типов CLR.
Единственный недостаток заключается в том, что при автозаполнении используется тип C#, поэтому мне приходится перепечатывать автоматически сгенерированные типы, чтобы вместо этого указать тип CLR.
Кроме того, теперь, когда я вижу «int» или «string», мне это кажется совершенно неправильным, как будто я смотрю на код C 1970-х годов.
На самом деле это вопрос конвенции. string просто больше похоже на стиль C/C++.Общее соглашение заключается в использовании любых ярлыков, предусмотренных выбранным вами языком (int/Int для Int32).Это касается «объекта» и decimal также.
Теоретически это могло бы помочь перенести код в какой-нибудь будущий 64-битный стандарт, в котором «int» может означать Int64, но дело не в этом, и я ожидаю, что любой мастер обновления изменит любой int ссылки на Int32 в любом случае, просто на всякий случай.
Нет никакой разницы.
Ключевое слово С# string сопоставляется с типом .NET System.String - это псевдоним, соответствующий соглашениям об именах языка.
Сходным образом, int карты в System.Int32.
По этому вопросу есть цитата Книга Дэниела Солиса.
Все предопределенные типы отображаются непосредственно с основными типами .NET.Имена типов C# (String) являются просто псевдонимом для типов .NET (String или System.String), поэтому использование имен .NET работает нормально, хотя это обескуражено.В рамках программы C# вы должны использовать имена C#, а не имена .NET.
нить — это ключевое слово, и вы не можете использовать строку в качестве идентификатора.
Нить не является ключевым словом, и вы можете использовать его как идентификатор:
Пример
string String = "I am a string";
Ключевое слово string это псевдоним для System.String Помимо проблемы ключевых слов, они точно эквивалентны.
typeof(string) == typeof(String) == typeof(System.String)
Да, между ними нет никакой разницы, как и bool и Boolean.
Между ними нет разницы – string, однако, по-видимому, является предпочтительным вариантом при рассмотрении исходного кода других разработчиков.
