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

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

например

string place = "world";

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

например

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

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

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

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

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

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

string в нижнем регистре - это псевдоним System.String. В C# они такие же.

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

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

• I've seen a number of developers confused, not knowing whether to use string or String in their code. Because in C# the string (a keyword) maps exactly to System.String (an FCL type), there is no difference and either can be used.
• In C#, long maps to System.Int64, but in a different programming language, long could map to an Int16 or Int32. In fact, C++/CLI does in fact treat long as an Int32. Someone reading source code in one language could easily misinterpret the code's intention if he or she were used to programming in a different programming language. In fact, most languages won't even treat long as a keyword and won't compile code that uses it.
• The FCL has many methods that have type names as part of their method names. For example, the BinaryReader type offers methods such as ReadBoolean, ReadInt32, ReadSingle, and so on, and the System.Convert type offers methods such as ToBoolean, ToInt32, ToSingle, and so on. Although it's legal to write the following code, the line with float feels very unnatural to me, and it's not obvious that the line is correct:

BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

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

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

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

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

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

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

Учитывать:

String someString; 
string anotherString; 

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

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

string в нижнем регистре предпочтительнее в большинстве проектов из-за подсветки синтаксиса

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

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

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

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

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

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

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

Как отмечали другие, string - это псевдоним System.String. Предполагая, что ваш код, использующий String, компилируется в System.String (т.е. у вас нет директивы using для некоторого другого пространства имен с другим типом 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.

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

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

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

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

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

StringBuilder @string = new StringBuilder();

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

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

string - это тип в C#.

System.String - это тип в среде CLR.

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

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

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

The C# language specification states, “As a matter of style, use of the keyword is favored over use of the complete system type name.” I disagree with the language specification; I prefer to use the FCL type names and completely avoid the primitive type names. In fact, I wish that compilers didn’t even offer the primitive type names and forced developers to use the FCL type names instead. Here are my reasons:

• I’ve seen a number of developers confused, not knowing whether to use string or String in their code. Because in C# string (a keyword) maps exactly to System.String (an FCL type), there is no difference and either can be used. Similarly, I’ve heard some developers say that int represents a 32-bit integer when the application is running on a 32-bit OS and that it represents a 64-bit integer when the application is running on a 64-bit OS. This statement is absolutely false: in C#, an int always maps to System.Int32, and therefore it represents a 32-bit integer regardless of the OS the code is running on. If programmers would use Int32 in their code, then this potential confusion is also eliminated.

• In C#, long maps to System.Int64, but in a different programming language, long could map to an Int16 or Int32. In fact, C++/CLI does treat long as an Int32. Someone reading source code in one language could easily misinterpret the code’s intention if he or she were used to programming in a different programming language. In fact, most languages won’t even treat long as a keyword and won’t compile code that uses it.

• The FCL has many methods that have type names as part of their method names. For example, the BinaryReader type offers methods such as ReadBoolean, ReadInt32, ReadSingle, and so on, and the System.Convert type offers methods such as ToBoolean, ToInt32, ToSingle, and so on. Although it’s legal to write the following code, the line with float feels very unnatural to me, and it’s not obvious that the line is correct:

  BinaryReader br = new BinaryReader(...);
  float val = br.ReadSingle(); // OK, but feels unnatural
  Single val = br.ReadSingle(); // OK and feels good
  

• Many programmers that use C# exclusively tend to forget that other programming languages can be used against the CLR, and because of this, C#-isms creep into the class library code. For example, Microsoft’s FCL is almost exclusively written in C# and developers on the FCL team have now introduced methods into the library such as Array’s GetLongLength, which returns an Int64 value that is a long in C# but not in other languages (like C++/CLI). Another example is System.Linq.Enumerable’s LongCount method.

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

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

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

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

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

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

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

Точно так же int соответствует System.Int32.

String (System.String) - это класс в библиотеке базовых классов. строка (нижний регистр) - это зарезервированная работа в C#, которая является псевдонимом для System.String. Int32 vs 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 относится к строковому объекту, который имеет различные функции для управления содержащейся строкой.

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

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

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

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

All the predefined types are mapped directly to underlying .NET types. The C# type names (string) are simply aliases for the .NET types (String or System.String), so using the .NET names works fine syntactically, although this is discouraged. Within a C# program, you should use the C# names rather than the .NET names.

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

Но теперь длинный текстовый ответ.

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

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

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

String s = "I am String";

или же

string s = "I am String";

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

объект: System.Object, строка: System.String, bool: System.Boolean, байт: System.Byte, sbyte: System.SByte, короткий: System.Int16 и т. д.

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

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

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

string s = String.ToUpper() ;

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

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

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

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

Пример

string String = "I am a string";

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

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

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

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

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

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

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

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

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

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

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

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

Ссылка.

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

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

Новый ответ через 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), скорее всего, (в зависимости от using) перейдет к методу расширения 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" не может быть преобразовано в него.

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

string для переменных

String предназначен для вызова других методов класса String

Нравиться:

string fName = "John";
string lName = "Smith";

string fullName = String.Concat(fName,lName);

if (String.IsNullOrEmpty(fName))
{
  Console.WriteLine("Enter first name");
}

В случае, если действительно полезно увидеть, что нет разницы между 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.

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

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

Между ними нет разницы. Вы можете использовать любой из них в своем коде.

System.String - это класс (ссылочный тип), определенный как mscorlib в пространстве имен System. Другими словами, System.String - это тип CLR.

string - это ключевое слово в C#.

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

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

Нить: представляет класс

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

It's just a coding convention from microsoft .

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

System.String str;

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

string str;

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

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

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

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

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

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

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

Примечание: ответ взят из раздела справки msdn. Вы можете увидеть полное содержание темы здесь в msdn String Class в разделе «Примечания».

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

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

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

Между 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   |

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

Another way to think of this is that the C# compiler automatically assumes that you have the following using directives in all of your source code files:

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

I’ve seen a number of developers confused, not knowing whether to use string or String in their code. Because in C# string (a keyword) maps exactly to System.String (an FCL type), there is no difference and either can be used.

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

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

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

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

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

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

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

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

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

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

string vs. String is not a style debate

[...]

The keyword string has concrete meaning in C#. It is the type System.String which exists in the core runtime assembly. The runtime intrinsically understands this type and provides the capabilities developers expect for strings in .NET. Its presence is so critical to C# that if that type doesn’t exist the compiler will exit before attempting to even parse a line of code. Hence string has a precise, unambiguous meaning in C# code.

The identifier String though has no concrete meaning in C#. It is an identifier that goes through all the name lookup rules as Widget, Student, etc … It could bind to string or it could bind to a type in another assembly entirely whose purposes may be entirely different than string. Worse it could be defined in a way such that code like String s = "hello"; continued to compile.

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;
}

The actual meaning of String will always depend on name resolution. That means it depends on all the source files in the project and all the types defined in all the referenced assemblies. In short it requires quite a bit of context to know what it means.

True that in the vast majority of cases String and string will bind to the same type. But using String still means developers are leaving their program up to interpretation in places where there is only one correct answer. When String does bind to the wrong type it can leave developers debugging for hours, filing bugs on the compiler team, and generally wasting time that could’ve been saved by using string.

Another way to visualize the difference is with this sample:

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

Many will argue that while this is information technically accurate using String is still fine because it’s exceedingly rare that a codebase would define a type of this name. Or that when String is defined it’s a sign of a bad codebase.

[...]

You’ll see that String is defined for a number of completely valid purposes: reflection helpers, serialization libraries, lexers, protocols, etc … For any of these libraries String vs. string has real consequences depending on where the code is used.

So remember when you see the String vs. string debate this is about semantics, not style. Choosing string gives crisp meaning to your codebase. Choosing String isn’t wrong but it’s leaving the door open for surprises in the future.

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

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

String.Format()

Переменная

string name = "";

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

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).

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

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

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

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

Б. Они различаются феймворком и контекстами, отличными от 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.

Хороший вопрос! Простыми словами:

string - datatype 

String - class Name

Бывший:

string Name = "tata"; //datatype is string => Happy Compiler :)

и

String Name = "tata"; // Unknown datatype => Unhappy Compiler :(

Вот что, когда вы наводите курсор на String, компилятор говорит использовать

System.String Name = "tata";

Не запутайтесь! Надеюсь это поможет!

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

string str1= "Hello";
String str2 = "World!";
            
Console.WriteLine(str1.GetType().FullName); // System.String
Console.WriteLine(str2.GetType().FullName); // System.String

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

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

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

string str = "Hello";

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

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