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

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

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

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

вопрос задан 10.08.2008
Lance Fisher
16538 репутация

58 ответов


  • 0 рейтинг

    строка является псевдонимом для строки в. NET Framework.

    Где "Строка" на самом деле System.String.

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

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

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

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

    ответ дан Vijay Singh Rana, с репутацией 645, 11.06.2014
  • 0 рейтинг

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

    ответ дан TraumaPony, с репутацией 7569, 19.10.2008
  • 0 рейтинг

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

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

    ответ дан artur02, с репутацией 4121, 18.10.2008
  • 0 рейтинг

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

    с 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");
    }
    
    ответ дан Anuja Lamahewa, с репутацией 521, 7.04.2015
  • 0 рейтинг

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

    ответ дан Lloyd Cotten, с репутацией 2103, 19.10.2008
  • 0 рейтинг

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

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

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

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

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

    ответ дан Rasmus Faber, с репутацией 37120, 17.03.2009
  • 0 рейтинг

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

    ответ дан Həsən Cəfərov, с репутацией 432, 12.01.2018
  • 0 рейтинг

    Использование типов системы упрощает перенос между C # и VB. Нет, если вы в такой вещи.

    ответ дан Ishmael, с репутацией 20175, 22.09.2008
  • 0 рейтинг

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

    ответ дан Dot NET, с репутацией 2987, 24.08.2011
  • 0 рейтинг

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

    ответ дан RolandK, с репутацией 410, 31.05.2011
  • 0 рейтинг

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

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

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

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

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

    • Я видел, что несколько разработчиков были сбиты с толку, не зная, использовать ли строку или строку в своем коде. Потому что в C # строка (ключевое слово) отображается точно в систему. Строка (тип FCL), нет никакой разницы, и любой из них может быть использован.
    • В C #, long сопоставляется с System. Int64 , но на другом языке программирования длиной можно сопоставить с Int16 или Int32 . На самом деле, C ++ / CLI действительно обрабатывает как Int32 . Кто-то, читающий исходный код на одном языке, может легко неверно истолковать намерение кода, если он или она привыкли к программированию на другом языке программирования. На самом деле, большинство языков даже не будут рассматривать длиной как ключевое слово и не будут компилировать код, который его использует.
    • В FCL есть много методов, имена которых являются частью имен их методов. Например, тип BinaryReader предлагает такие методы, как ReadBoolean , ReadInt32 , ReadSingle и т. Д., И систему . Тип преобразования предлагает такие методы, как ToBoolean , ToInt32 , ToSingle и т. Д. Хотя написать следующий код законно, строка с плавающей точкой кажется мне неестественной, и не очевидно, что строка правильная:
    BinaryReader br = new BinaryReader(...);
    float val  = br.ReadSingle(); // OK, but feels unnatural
    Single val = br.ReadSingle(); // OK and feels good
    

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

    ответ дан Luke Foust, с репутацией 1731, 15.08.2008
  • 0 рейтинг

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

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

    Рассмотрим:

    String someString; 
    string anotherString; 
    
    ответ дан Anthony Mastrean, с репутацией 13938, 3.09.2008
  • 0 рейтинг

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

    Все предопределенные типы отображаются непосредственно в лежащий в основе. Чистые типы. Имена типов C # (строка) являются просто псевдонимами для , Типы NET (Строка или Система. Строка), поэтому с помощью. NET имена хорошо работает синтаксически, хотя это не рекомендуется. В программе C # вы должны использовать имена C # а не. Чистые имена.

    ответ дан user2771704, с репутацией 3351, 1.11.2013
  • 0 рейтинг

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

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

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


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

    class MySequence
    {
      public IEnumerable String { get; set; }
    
      void Example()
      {
        var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
      }
    }
    

    Выше не будет компилироваться, потому что IEnumerable<> не имеет нестатического члена с именем Format, и методы расширения не применяются. В вышеупомянутом случае все еще может быть возможно использовать String в других контекстах, где тип 3230269583 является единственной возможностью синтаксически. Например, 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" не может быть преобразовано в него.

    ответ дан Jeppe Stig Nielsen, с репутацией 41844, 15.01.2015
  • 0 рейтинг

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

    ответ дан user3296, с репутацией 389, 27.08.2008
  • 0 рейтинг

    В C # строка - это короткая версия System. Строка (String). Они в основном означают одно и то же.

    Как кто-то упоминал, это так же, как bool и Boolean, не большая разница. ,

    ответ дан Taslim, с репутацией 1039, 5.01.2018
  • 0 рейтинг

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

    ответ дан Coder, с репутацией 629, 8.10.2012
  • 0 рейтинг

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

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

    string является ключевым словом в C#

    ответ дан Pritam Jyoti Ray, с репутацией 219, 20.01.2016
  • 0 рейтинг

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

    К вашему сведению «Строка ключевого слова - это просто псевдоним для предопределенного класса System.String. ”- C # Language Specification 4. 2. 3 http: // msdn2. Microsoft. ком / En-US / библиотека / aa691153. aspx

    ответ дан Pradeep Kumar Mishra, с репутацией 9674, 18.10.2008
  • 0 рейтинг

    В C # string - это псевдоним для класса System.String в. NET Framework. Фактически, каждый тип C # имеет эквивалент в. СЕТЬ. В качестве другого примера, short и int в C # отображаются на System.Int16 и System.Int32 в. СЕТЬ.

    Итак, технически нет никакой разницы между string и String, но это обычная практика объявлять переменную, используя ключевые слова C #. Я почти не видел, чтобы кто-нибудь объявлял целое число с Int32.

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

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

    String.Format();
    
    ответ дан Chow, с репутацией 43, 10.05.2016
  • 0 рейтинг

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

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

    Пример

    string String = "I am a string";
    

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

     typeof(string) == typeof(String) == typeof(System.String)
    
    ответ дан Neel, с репутацией 9750, 11.06.2014
  • 0 рейтинг

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

    ответ дан user576533, с репутацией 91, 25.04.2011
  • 0 рейтинг

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

    ответ дан BerBar, с репутацией 100, 22.07.2018
  • 0 рейтинг

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

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

    ответ дан DavidWainwright, с репутацией 1999, 18.10.2017
  • 0 рейтинг

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

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

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

    ответ дан claudioalpereira, с репутацией 61, 28.01.2011
  • 0 рейтинг

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

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

    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.

    ответ дан hubot, с репутацией 313, 4.06.2016
  • 0 рейтинг

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

    Как уже отмечалось, string является псевдонимом для System.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
    

    Это всего лишь вопрос того, как спецификация определяет объявления enum - деталь после двоеточия должна быть 3230269583 целочисленного типа , что является одним из токенов sbyte, byte, short, ushort, int, uint, 26671747497, 2567844497, 256784443, 2565 char. , , в отличие от типа , используемого, например, в объявлениях переменных. Это не указывает на другую разницу.

    Наконец, когда речь заходит о том, что использовать: лично я использую псевдонимы везде для реализации, но тип CLR для любых API. На самом деле не имеет большого значения, какой вы используете с точки зрения реализации - согласованность в вашей команде - это хорошо, но больше никого не волнует. С другой стороны, действительно важно, что если вы ссылаетесь на тип в API, вы делаете это не зависящим от языка способом. Метод с именем ReadInt32 является однозначным, тогда как метод с именем ReadInt требует интерпретации. Вызывающая сторона может использовать язык, который определяет псевдоним int, например, для Int16. . Разработчики фреймворков NET следовали этому шаблону. Хорошие примеры - классы BitConverter, BinaryReader и Convert.

    ответ дан Jon Skeet, с репутацией 1057123, 18.10.2008
  • 0 рейтинг

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

    System.String str;
    

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

    string str;
    
    ответ дан Saurabh, с репутацией 507, 25.03.2017
  • 0 рейтинг

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

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

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

    Для получения дополнительной информации об неизменяемости строк см. Раздел Immutability и класс StringBuilder в msdn.

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

    Примечание: ответ извлечен из справочного раздела msdn. Вы можете увидеть полное содержимое здесь, в теме msdn String Class в разделе замечаний

    .
    ответ дан Jineesh Uvantavida, с репутацией 339, 10.11.2017
  • 0 рейтинг

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

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

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

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

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

    ответ дан Michael Ray Lovett, с репутацией 1880, 24.08.2012
  • 0 рейтинг

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

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

    ответ дан Zaid Masud, с репутацией 8828, 3.10.2012
  • 0 рейтинг

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

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

    Ссылка .

    ответ дан InfZero, с репутацией 1226, 26.07.2014
  • 0 рейтинг

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

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

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

    ответ дан yazan_ati, с репутацией 255, 28.12.2015
  • 0 рейтинг

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

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

    ответ дан Mel, с репутацией 1788, 18.08.2008
  • 0 рейтинг

    String - это псевдоним класса String. Если вы хотите использовать функции класса string, вам следует использовать String, иначе вам следует придерживаться строки. Например, если вы хотите отформатировать строку, вы должны использовать класс String для использования String.Format(), но если вы просто хотите определить строку, то вы должны использовать string test=""; Обратите внимание, что оба они являются ссылочными типами.

    ответ дан Pratikgcet, с репутацией 11, 6.04.2016
  • 0 рейтинг

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

    Но теперь для длинного текстового ответа.

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

    enter image description here

    "System.String" а. к. «String» (заглавная «S») - это тип данных фреймворка .NET, а «string» - тип данных C#.

    enter image description here

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

    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»?

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

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

    string s = String.ToUpper() ;
    
    ответ дан Shivprasad Koirala, с репутацией 15205, 15.01.2014
  • 0 рейтинг

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

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

    Это говорит о том, что строка является Системой. Строка, верно? Документация находится по адресу https: // msdn. Microsoft. ком / EN-US / библиотека / 362314fe. aspx . Второе предложение гласит: «строка - это псевдоним для строки в. NET Framework. ».

    ответ дан wild coder, с репутацией 307, 8.02.2018
  • 0 рейтинг

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

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

    эл. г.

    string place = "world";
    

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

    эл. г.

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

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

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

    ответ дан Derek Park, с репутацией 38852, 10.08.2008
  • 0 рейтинг

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

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

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

    ответ дан Ronnie, с репутацией 6068, 10.08.2008
  • 0 рейтинг

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

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

    ответ дан urini, с репутацией 19152, 10.08.2008
  • 0 рейтинг

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

    ответ дан JeeShen Lee, с репутацией 2070, 21.10.2011
  • 0 рейтинг

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

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

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

    ответ дан Inverted Llama, с репутацией 423, 4.10.2012
  • 0 рейтинг

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

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

    ответ дан Developer, с репутацией 1508, 20.06.2014
  • 0 рейтинг

    строка является псевдонимом для системы . Строка . Они компилируются в один и тот же код, поэтому во время выполнения нет никакой разницы. Это только один из псевдонимов в 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
    
    ответ дан Rae Lee, с репутацией 2453, 22.02.2016
  • 0 рейтинг

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

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

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

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

    StringBuilder @string = new StringBuilder();
    

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

    ответ дан Simon_Weaver, с репутацией 68158, 24.02.2009
  • 0 рейтинг

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

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

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

    ответ дан Jaider, с репутацией 8582, 12.07.2018
  • 0 рейтинг

    Существует одно практическое различие между 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   |
    
    ответ дан BanksySan, с репутацией 10617, 18.01.2018
  • 0 рейтинг

    Нет разницы.

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

    Аналогично, int сопоставляется с System.Int32.

    ответ дан Oded, с репутацией 401142, 14.01.2012
  • 0 рейтинг

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

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

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

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

    ответ дан v.slobodzian, с репутацией 88, 1.02.2018