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

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

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

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

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

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

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

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

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

@JaredPar (разработчик компилятора C # и активный пользователь SO!) написал отличное сообщение в блоге по этой проблеме. Думаю, здесь стоит поделиться. Это хороший взгляд на нашу тему.

string vs. String - это не дискуссия о стиле

[...]

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

Однако идентификатор String не имеет конкретного значения в C #. Это идентификатор, который проходит через все правила поиска имени как Widget, Student и т. Д. Он может связываться со строкой или он может связываться с типом в другой сборке, цели которой могут быть полностью отличными от string. Хуже того, его можно определить таким образом, чтобы код типа String s = "hello"; продолжал компилировать.

class TricksterString { 
  void Example() {
    String s = "Hello World"; // Okay but probably not what you expect.
  }
}

class String {
  public static implicit operator String(string s) => null;
}

Фактическое значение String всегда будет зависеть от разрешения имени. Это означает, что это зависит от всех исходных файлов в проекте и всех типов, определенных во всех сборках, на которые есть ссылки. Короче говоря, чтобы знать, что это означает, требуется довольно много контекста.

Верно, что в подавляющем большинстве случаев String и string будут привязаны к одному и тому же типу. Но использование String по-прежнему означает, что разработчики оставляют свою программу на усмотрение в тех местах, где есть только один правильный ответ. Когда String привязывается к неправильному типу, разработчики могут часами заниматься отладкой, фиксировать ошибки в команде компилятора и, как правило, тратить время, которое можно было бы сэкономить, используя string.

Другой способ визуализировать разницу - использовать этот пример:

string s1 = 42; // Errors 100% of the time  
String s2 = 42; // Might error, might not, depends on the code

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

[...]

Вы увидите, что String определен для ряда вполне допустимых целей: помощники отражения, библиотеки сериализации, лексеры, протоколы и т. Д. Для любой из этих библиотек String против string есть реальные последствия в зависимости от того, где используется код.

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

Примечание: я скопировал / вставил большинство сообщений в блоге для архивных целей. Я игнорирую некоторые части, поэтому рекомендую пропустить и прочитать сообщение в блоге, если можете.

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

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

Точно так же int отображается на System.Int32.

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

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

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

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

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

Пример

string String = "I am a string";

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

 typeof(string) == typeof(String) == typeof(System.String)

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

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

System.String - это ссылочный тип, а имена ссылочных типов по соглашению записываются в паскальском регистре.

Оба они одинаковы, разница в том, как вы их используете. Конвенция,

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.

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   |

Разницы практически нет

Строка ключевого слова C # сопоставляется с типом .NET System.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 ]

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

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

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

Для использования string не требуется пространство имен import (с использованием System;), поскольку это глобальный псевдоним System.String.

Чтобы узнать больше о псевдонимах, перейдите по этой ссылке.

В C # строка - это сокращенная версия System.String (String). По сути, они означают одно и то же.

Прямо как bool и Boolean, особой разницы нет ..

Прежде всего, оба (строка и строка) не совпадают. Есть разница: строка не является ключевым словом и может использоваться как идентификатор, тогда как строка является ключевым словом и не может использоваться как идентификатор.

Я пытаюсь объяснить это на другом примере: во-первых, когда я помещаю строку s; в Visual Studio и наведите на него курсор (без цвета):

Это говорит о том, что эта строка - System.String, верно? Документация находится по адресу https://msdn.microsoft.com/en-us/library/362314fe.aspx. Во втором предложении говорится: «строка - это псевдоним для String в .NET Framework.».

Джеффри Рихтер написал:

Другой способ подумать об этом - компилятор C # автоматически предполагает, что у вас есть следующие директивы using во всех ваших файлах исходного кода:

using int = System.Int32;
using uint = System.UInt32;
using string = System.String;
...

Я видел, как многие разработчики были сбиты с толку, не зная, использовать ли в своем коде строку или строку. Поскольку в C # строка (ключевое слово) точно соответствует System.String (тип FCL), нет никакой разницы, и любой из них может использоваться.

String: объект String называется неизменяемым (только для чтения), потому что его значение нельзя изменить после того, как он был создан. Методы, которые кажутся модифицирующими объект String, фактически возвращают новый объект String, содержащий модификацию. Если необходимо изменить фактическое содержимое строкового объекта

строка: Тип строки представляет собой последовательность из нуля или более символов Юникода. string - это псевдоним для String в .NET Framework. string - это внутренний тип данных C # и псевдоним для предоставленного системой типа "System.String". В спецификации C # указано, что с точки зрения стиля ключевое слово (строка) предпочтительнее полного имени типа системы (System.String или String). Хотя строка является ссылочным типом, операторы равенства (== и! =) Определены для сравнения значений строковых объектов, а не ссылок. Это делает тестирование на равенство строк более интуитивным. Например:

Разница между строкой и строкой:

• string обычно используется для объявления, а String используется для доступа к статическим строковым методам.
• Вы можете использовать 'string' для объявления полей, свойств и т. Д., Которые используют предопределенный тип 'string', поскольку спецификация C # говорит мне, что это хороший стиль.
• Вы можете использовать 'String' для использования системных методов, таких как String.Compare и т. Д. Они изначально определены в 'System.String', а не в 'string'. 'string' в данном случае просто псевдоним.
• Вы также можете использовать 'String' или System.Int32 при взаимодействии с другой системой, особенно если они совместимы с CLR. то есть - если я получаю данные из другого места, я бы десериализовал их в System.Int32, а не в int, если источник по определению был чем-то другим, кроме системы C #.

Честно говоря, на практике обычно нет разницы между System.String и string.

Все типы в C # являются объектами и производными от класса System.Object. Одно отличие состоит в том, что строка является ключевым словом C #, а String можно использовать в качестве имени переменной. System.String - стандартное имя этого типа в .NET, а строка - удобное имя C #. Вот простая программа, которая показывает разницу между 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#

В контексте документации MSDN класс String задокументирован, как и любой другой тип данных (например,, XmlReader, StreamReader) в BCL.

И string задокументирован как ключевое слово (справочник по C #) или как любая базовая конструкция языка C # (например,, for, while, default).

Справочник.

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

Как бы то ни было, я использую строку для объявления типов - переменных, свойств, возвращаемых значений и параметров. Это согласуется с использованием других типов систем - int, bool, var и т. Д. (Хотя Int32 и Boolean также верны).

Я использую String при использовании статических методов класса String, например String.Split() или String.IsNullOrEmpty(). Я считаю, что это имеет больше смысла, потому что методы принадлежат классу, и это согласуется с тем, как я использую другие статические методы.

строка равна System.String
в VS2015, если вы напишете это

System.String str;

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

string str;

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

Если вы щелкните правой кнопкой мыши ключевое слово string и выберите Go to definition в контекстном меню, вы попадете в класс String - это просто синтаксический сахар, но он улучшает читаемость imo.

Строка - это последовательный набор символов, который используется для представления текста.

Объект String - это последовательный набор объектов System.Char, представляющих строку; объект System.Char соответствует кодовой единице UTF-16.

Значение объекта String - это содержимое последовательной коллекции объектов System.Char, и это значение является неизменным (то есть доступно только для чтения).

Дополнительные сведения о неизменности строк см. В разделе «Неизменяемость и класс StringBuilder» в msdn.

Максимальный размер объекта String в памяти составляет 2 ГБ или около 1 миллиарда символов.

Примечание: ответ взят из раздела справки msdn. Вы можете увидеть полное содержимое здесь, в строке msdn Тема курса в разделе "Примечания"

string - это краткое название System.String . String или System.String - имя строки в CTS(Common Type System).

Насколько мне известно, string - это просто псевдоним для System.String, и похожие псевдонимы существуют для bool, object, _5 _... единственное небольшое различие состоит в том, что вы можете использовать string без директивы "using System;", в то время как String требует этого ( в противном случае вы должны указать System.String полностью).

Что лучше использовать, думаю, дело вкуса. Лично я предпочитаю string, но это не религиозный вопрос.

Строка: представляет класс.

строка: представляет псевдоним

Это просто соглашение о кодировании от Microsoft.

Как вы уже знаете, string - это просто псевдоним для System.String. Но что мне использовать? это просто личные предпочтения.

В моем случае я предпочитаю использовать string, а не System.String, потому что String требует пространства имен using System; или полного имени System.String.

Я считаю, что псевдоним string был создан для простоты, и мне он нравится!

строка - это ярлык для System.String. Единственная разница в том, что вам не нужно ссылаться на пространство имен System.String. Так что было бы лучше использовать строку, чем String.

Обычно переменную объявляют с помощью ключевых слов C #. Фактически, каждый тип C # имеет эквивалент в .NET. Другой пример: short и int в C # сопоставляются с Int16 и Int32 в .NET. Итак, технически нет разницы между строкой и строкой, но в C # строка является псевдонимом для класса String в .NET framework.

string - это псевдоним для String в .NET Framework.

Где "String" на самом деле System.String.

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

Хотя было бы лучше согласиться с тем, какой из них вы использовали.

Как бы то ни было, я использую string для объявления типов - переменных, свойств, возвращаемых значений и параметров. Это согласуется с использованием других типов систем - int, bool, var и т. Д. (Хотя Int32 и Boolean также верны).

Я использую String при использовании статических методов класса String, например String.Split() или String.IsNullOrEmpty(). Я считаю, что это имеет больше смысла, потому что методы принадлежат классу, и это согласуется с тем, как я использую другие статические методы.

String - это класс string. Если вы удалите System пространство имен из операторов using, вы увидите, что String ушел, но string все еще здесь. string - ключевое слово для String. Like
int and Int32
short and Int16
long and Int64
Таким образом, ключевые слова - это всего лишь некоторые слова, в которых используется класс. Эти ключевые слова определены C # (то есть Microsoft, потому что C # принадлежит Microsoft). Вкратце, разницы нет. Используя string or String. Это не имеет значения. Они такие же.

Все вышесказанное в принципе правильно. Это можно проверить. Просто напишите короткий метод

public static void Main()
{
    var s = "a string";
}

скомпилируйте его и откройте .exe с помощью ildasm, чтобы увидеть

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       8 (0x8)
  .maxstack  1
  .locals init ([0] string s)
  IL_0000:  nop
  IL_0001:  ldstr      "a string"
  IL_0006:  stloc.0
  IL_0007:  ret
} // end of method Program::Main

затем измените var на string и String, скомпилируйте, откройте с помощью ildasm и увидите, что IL не изменится. Это также показывает, что создатели языка предпочитают просто string при определении переменных (спойлер: при вызове членов они предпочитают String).

объявить строковую переменную со строкой, но использовать класс String при доступе к одному из его статических членов:

String.Format()

Переменная

string name = "";

Их много (например, Джеффри Рихтер в его книге CLR Via C #), которые говорят, что нет никакой разницы между System.String и string, а также System.Int32 и int, но мы должны различать немного глубже, чтобы действительно выжать сок из этого вопроса, чтобы мы могли получить все его питательная ценность (напишите лучший код).

А. Они такие же ...

1. компилятору.
2. разработчику. (Мы знаем №1 и в конечном итоге достигли автопилота.)

Б. Они разные в Famework и в контекстах, отличных от C #. Другой...

1. на ДРУГИЕ языки, НЕ являющиеся C #
2. в оптимизированном контексте CIL (был MSIL) (язык ассемблера .NET VM)
3. в контексте, ориентированном на платформу - .NET Framework или Mono или любая область типа CIL
4. в книге, ориентированной на несколько языков .NET (например, VB.NET, F # и т. д.)

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

C. Подводя итоги ...

Вы используете string и int и другие типы C # в целевой аудитории, предназначенной только для C # (задайте вопрос, кто будет читать этот код или использовать эту библиотеку). Что касается вашей внутренней компании, если вы используете только C #, придерживайтесь типов C #.

... и вы используете System.String и System.Int32 в многоязычной целевой аудитории или целевой аудитории (когда C # не единственная аудитория). Для своей внутренней организации, если вы также используете VB.NET, F # или любой другой язык .NET или разрабатываете библиотеки для использования клиентами, которые могут, тогда вам следует использовать типы «Frameworky» в этих контекстах, чтобы каждый мог понять ваш интерфейс. , независимо от того, из какой они вселенной. (Во всяком случае, что такое клингон для System.String?)

HTH.

Результат изображения для строки и строки www.javatpoint.com В C # string является псевдонимом для String класса в. NET Framework. Фактически, каждый тип C # имеет эквивалент в .NET.
Еще одно небольшое отличие заключается в том, что если вы используете класс String, вам нужно импортировать пространство имен System, тогда как у вас нет для импорта пространства имен при использовании ключевого слова string

Нет большой разницы между string и String в C #.

String - это класс в платформе .NET в пространстве имен System. Полное имя - System.String. Строка в нижнем регистре - это псевдоним System.String.

Но рекомендуется использовать string при объявлении таких переменных, как:

string str = "Hello";

И мы можем использовать String при использовании любого встроенного метода для таких строк, как String.IsNullOrEmpty().

Также есть одно различие между этими двумя: перед использованием String мы должны импортировать системное пространство имен в файл cs, и string можно использовать напрямую.