В чем разница между String и string в C#?

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

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

Например.

string place = "world";

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

например.

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

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

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

в <!-- язык-всем: Лэнг-в C# --&ГТ; Просто для полноты картины, здесь'ы свалки мозга, связанных с информацией...

Как уже отмечалось, строка - это псевдоним для системы.Строка. Они компилируются в один и тот же код, поэтому во время выполнения, разницы нет. Это просто один из псевдонимов в 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 и объект, псевдонимы-все это типы значений. десятичное число является типом значения, а не примитивного типа в среде CLR. Единственный примитивный тип, который не'т иметь систему псевдоним.Указателя IntPtr.

В спец, тип значения псевдонимы известных как "простых" по. Литералы могут использоваться для постоянных значений каждого простого типа; другие типы значение имеют буквальные формы. (Сравните это с VB, который позволяет Датавремя литералы, и присвоен псевдоним для нее тоже.)

Есть одно обстоятельство, в котором вы должны использовать псевдонимы: при явном указании типа enum'ы базового типа. Например:

public enum Foo : UInt32 {} // Invalid
public enum Bar : uint   {} // Valid

Что's просто вопрос как спецификация определяет перечисление деклараций - часть после двоеточия должно быть интегральный-тип производства, который является одним из маркеров типа sbyte, байт, короткий, ushort, инт, uint с, долго, тип ulong, голец... в отличие от типа производство как объявления переменных например. Это не'т указать любые другие значения.

Наконец, когда дело доходит до использования: лично я использую псевдонимы повсеместно для реализации, но типа CLR для любой API. Это действительно не'т имеет значения, слишком много, которые вы используете в плане реализации - согласованность между вашей команде это конечно хорошо, но никто не будет заботиться. С другой стороны, это'ы действительно важно, что если вы ссылаетесь на тип в API, вы делаете это на нейтральном языке. Метод, называемый ReadInt32 является однозначным, в то время как метод, называемый ReadInt требует толкования. Абонент может с помощью языка, которая определяетинтпсевдонимтипа INT16, например. Интернет .Чистая рамки дизайнеры последовали этому образцу, хорошие примеры в метода bitconverter, BinaryReader и преобразование классов.

Строка расшифровывается как системы.String и это .Сетка рамочного типа. строка - это псевдоним в языке C# для системы.Строка. Оба они составляются в систему.String в ил (промежуточный язык), так что нет никакой разницы. Выбирайте, что вам нравится, и использовать это. Если вы код в C#, я'д предпочитают строку, как это'ы на C# псевдоним типа и известные программисты c#.

Я могу сказать то же самое о (инт, системы.Типа int32) и т. д..

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

&ГТ; - я'вэ видел ряд застройщиков в замешательстве, не зная, следует ли использовать строка или строка в своем коде. Потому что в C# строки (ключевое слово) карты именно для системы.Строки (в ГКЛ типа), разницы нет и можно использовать.

• В C#, длиной карты системы.Типа int64, но на другом языке программирования, длиной бы на типа INT16 или типа int32. В самом деле, в C++действительно долго лечить как типа int32. Кто-то читая исходный код на одном языке, мог бы легко интерпретировать код'намерение, если он или она были использованы для программирования на другом языке программирования. В действительности, большинство языков выиграл'т даже лечить долго в качестве ключевого слова и выиграл'т скомпилировать код, который использует его.
• ГКЛ имеет много методов, которые имеют имена типа как часть их имен методов. Например, BinaryReader типа предлагает такие методы, как ReadBoolean, ReadInt32, ReadSingle, и так далее, и системы.Преобразования типа предлагает такие методы, как ToBoolean, ToInt32, ToSingle, и так далее. Хотя он'ы права написать следующий код, в соответствии с поплавковым чувствует себя очень неестественно для меня, и это's не очевидно, что линия правильная:

BinaryReader БР = новый BinaryReader(...); поплавок Вэл = БР.ReadSingle(); // ОК, но неестественно Один Вэл = БР.ReadSingle(); // ОК и чувствует себя хорошо

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

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

Если по каким-то причинам вы хотели переменной называется строки, вы'd см. только первый из них составляет:

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

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

StringBuilder @string = new StringBuilder();

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

Разница - вы можете'т использовать строку `безс использованием системы;` заранее.

Это'ы были охвачены выше; однако, вы можете'т использовать строку `в размышления; вы должны использоватьстрока`.

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

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

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

в <!-- язык-всем: Лэнг-в C# --&ГТ; Я предпочитаю капитализируются .Чистые типы (а не псевдонимы) для форматирования причинам. Этот.Типа сетка не окрашена так же, как и другие типы объектов (типы значений являются настоящими объектами, в конце концов).

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

Рассмотрим:

String someString; 
string anotherString; 

String и строка являются идентичными во всех отношениях (за исключением заглавных и quot;Ы" - а). Нет никаких последствий для производительности в любом случае.

Строчные "строка" является предпочтительным в большинстве проектов из-за подсветки синтаксиса

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

строку тип в C#.

Система.Строку - это типа в среде CLR.

Когда вы используете C# вместе с в среде CLR строку будут сопоставлены с Система.Строку.

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

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

Но сейчас долгое текстового ответа.

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

" и системы.Строка" а.к.а "строка" в ( столичный "Ы", У) является .Чистая системой тип данных, а quot;в строке &quot и; это иC#` тип данных.

Короче "в строке" это псевдоним ( то же самое называться по разному) и quot;строка" и. Так что технически как ниже код даст тот же результат.

String s = "I am String";

или

string s = "I am String";

Точно так же есть алиасы для другой тип данных C#, как показано ниже:-

объект: система.Объект, строку:системы.Строка, боол: система.Логическое, байт: система.Байт, типа sbyte: система.Тип sbyte, короткие: система`.Типа INT16 и т. д.

Теперь вопрос на миллион долларов от программиста'с точки зрения поэтому, когда в использовании и quot;строка" и "строка" у?

Первым делом, чтобы избежать путаницы, используйте один из них последовательно. Но с точки зрения лучших практик, когда ты объявлении переменной она's хорошо, чтобы использовать "в строке" и ( маленький и quot;Ы", У) и когда вы используете его в качестве имени класса потом "строка" в ( столичный "Ы", У) является предпочтительным.

В приведенном ниже коде левой стороне-это объявление переменной и она объявила, используя quot;в строке &quot и;. На правой стороне мы называем метод, так и quot;строка" это более разумно.

string s = String.ToUpper() ;

Строка в нижнем регистре string является псевдонимом для System.String. В C# они одинаковы.

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

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

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

Оба такие же. Но от принципов кодирования перспективе он's лучше, чтобы использовать эту строку вместо строка. Это, как правило, разработчики используют. например, вместо типа int32 мы используем как int в int является псевдоним типа int32

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

Как говорят другие, они'вновь так же. Правила StyleCop, по умолчанию, будет обеспечивать вам использовать строку, как в C# код стиль лучшие практики, кроме как при обращении к системе.Статические функции строку, например, строку.Формат,Строки.Присоединяйтесь К,Строки.Функция concat`, и т. д...

Новый ответ после 6 лет и 5 месяцев (прокрастинация).

В то время как строка - это зарезервированное ключевое слово C#, который всегда имеет фиксированный смысл, строка - это просто обычный identifier которые могли относиться ни к чему. В зависимости от членов рода тока, текущего пространства имен и директивы, применяемые через и их размещение, строка может быть значение или тип отличается от глобальной::системы.Строка`.

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

Во-первых, когда "строка" представляет собой значение текущего типа (или локальной переменной):

class MySequence
{
  public IEnumerable String { get; set; }

  void Example()
  {
    var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
  }
}

Выше не будет компилироваться, потому что интерфейс IEnumerable&ЛТ;&ГТ;нет нестатических членов называемый "формат", и не применять методы расширения. В приведенном выше случае, все-таки можно использоватьstring` в других контекстах, где type является единственной возможностью синтаксически. Например, строка местные = то "Здравствуйте, мамы!&и quot;; может быть ОК (в зависимости от пространства имен и использование директив).

Хуже: Говорю Строку.Функция concat(someSequence), скорее всего (в зависимости от использования) уходит на перечисляемый метод расширения для LINQ.Функция concat. Он не пойдет в строку статический метод.Функция concat`.

Во-вторых, когда "нить" другой тип, вложенная в текущие типа:

class MyPiano
{
  protected class String
  {
  }

  void Example()
  {
    var test1 = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
    String test2 = "Goodbye";
  }
}

Ни одно утверждение в "примере" метод компилирует. Вот "нить" - это всегда фортепиано строки, MyPiano.Строка. Ни один член ("static" или нет) формат `существует на нем (или наследуются из его базового класса). И значение"прощай"` не может быть преобразован в него.

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

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

строка - это псевдоним (или скоропись) системы.Строка. Это значит, вписавстрока, мы имели в виду систему.Строка. Вы можете узнать более подробно в ссылке думаю: 'строки' - это псевдоним/стенографии системы.Строку.