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




сравнение строк c# (20)

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

string является типом в C #.

System.String является типом в CLR.

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

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

Пример ( обратите внимание на случай ):

string s = "Hello world!";
String s = "Hello world!";

Каковы правила использования каждого из них? И в чем различия ?


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


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

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

Я приведу два примера, где using директив не поможет .

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

class MySequence<TElement>
{
  public IEnumerable<TElement> String { get; set; }

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

Выше не будет компилироваться, потому что IEnumerable<> не имеет нестатического члена с именем Format , и методы расширения не применяются. В вышеупомянутом случае все еще возможно использовать String в других контекстах, где тип является единственной возможностью синтаксически. Например String local = "Hi mum!"; может быть в порядке (в зависимости от пространства имен и using директив).

Хуже того: Saying 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 . Это то, что обычно используют разработчики. Например, вместо Int32 мы используем int как int является псевдонимом Int32

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


Это было покрыто выше; тем не менее, вы не можете использовать string в отражении; Вы должны использовать String .


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

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

Рассмотреть возможность:

String someString; 
string anotherString; 

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

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

например

string place = "world";

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

например

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

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

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


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

То же самое можно сказать о ( int , System.Int32 ) и т. Д.


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

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

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


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

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

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

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

StringBuilder @string = new StringBuilder();

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


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

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


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

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


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


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

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

пример

string String = "I am a string";

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

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

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

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

Аналогично, intкарты для System.Int32.


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

Спецификация языка C # гласит: «По стилю, использование ключевого слова предпочтительнее, чем использование полного имени типа системы». Я не согласен с языковой спецификацией; Я предпочитаю использовать имена типов FCL и полностью избегать имен примитивных типов. На самом деле, я бы хотел, чтобы компиляторы даже не предлагали имена примитивных типов и заставляли разработчиков использовать вместо них имена типов FCL. Вот мои причины:

  • Я видел, что некоторые разработчики были сбиты с толку, не зная, использовать ли в своем коде строку или строку . Поскольку в C # string (ключевое слово) отображается точно на System.String (тип FCL), нет никакой разницы, и любой из них может быть использован. Точно так же я слышал, что некоторые разработчики говорят, что int представляет 32-разрядное целое число, когда приложение работает в 32-разрядной ОС, и что оно представляет 64-разрядное целое число, когда приложение выполняется в 64-разрядной ОС. Это утверждение абсолютно неверно: в C # int всегда отображается в System.Int32 , и поэтому оно представляет 32-разрядное целое число независимо от ОС, в которой выполняется код. Если программисты будут использовать Int32 в их коде эта потенциальная путаница также устранена.

  • В C # 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
  • Многие программисты, использующие исключительно C #, склонны забывать, что против CLR могут использоваться другие языки программирования, и из-за этого C # -измы проникают в код библиотеки классов. Например, FCL Microsoft, почти исключительно написан на C # и разработчики в команде FCL теперь ввели методы в библиотеке , такой как массив «s GetLongLength , который возвращает Int64 значение , которое является длинным в C # , но не на других языках (например , C ++ / CLI). Другим примером может служить System.Linq.Enumerable «ы LongCount метод.

Я не получил его мнение, прежде чем я прочитал полный параграф.


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


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


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

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


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






alias