В чем разница между строкой и строкой в C #?

Просто ради полноты, здесь мозговой свалкой связанной информации...

Как отмечали другие, 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 - зарезервированное слово, но string - это просто имя класса. Это означает, что string не может использоваться как имя переменной сам по себе.

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

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

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

StringBuilder @string = new StringBuilder();

Другое критическое различие: переполнение стека подчеркивает их по-разному.

Существует одна разница - вы не можете использовать String без using System; заранее.

Это было рассмотрено выше; однако вы не можете использовать 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; 

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

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

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

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

System.String - это тип в CLR.

При использовании С# вместе с CLR string будет отображаться System.String.

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

Это видео 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 является псевдонимом для 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

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" не может быть преобразовано в него.

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

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

Пример

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 по соглашению.

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

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

строка - это псевдоним для 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 ]

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

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

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

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

Ссылка.

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

Объект 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 - это короткое имя 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=""; Обратите внимание, что оба они являются ссылочными типами.

Простой способ: строка - тип данных, Строка - это класс.

Факты о строке:

• String - это класс System.String
• Строка - это тип ссылки   (класс)
• string - это псевдоним String class, созданный        Microsoft Строка

• - тип значения (тип данных) - это ключевое слово C#

• string - это ярлык компилятора для System.String class