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

avatar
Peter O.
10 августа 2008 в 07:18
1175928
63
6969

Пример ( обратите внимание на регистр ):

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

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

Источник
Kirk Woll
2 декабря 2014 в 03:05
88

@ O.R.Mapper, но факт остается фактом: string - это лексическая конструкция грамматики C # , тогда как System.String - это просто тип. Независимо от какого-либо явного различия, упомянутого в какой-либо спецификации, все же существует это неявное различие, которое может быть учтено с некоторой двусмысленностью. Сам язык должен поддерживать string таким образом, что реализация (совсем) не обязана учитывать для конкретного класса в BCL.

O. R. Mapper
2 декабря 2014 в 08:22
123

@KirkWoll: Согласно спецификации языка, сам язык должен рассматривать string как точно такой же, как тип BCL System.String, и ничего больше. Это совсем не двусмысленно. Конечно, вы можете реализовать свой собственный компилятор, используя грамматику C #, и использовать все найденные подобные токены для чего-то произвольного, не связанного с тем, что определено в спецификации языка C #. Однако полученный язык будет похож только на C #, он не может считаться C #.

Wilsu
30 ноября 2015 в 08:52
102

Вы можете использовать string без директивы using для System. Вы не можете этого сделать с String.

George Birbilis
10 мая 2016 в 17:39
0

читать о боксе / распаковке тоже кстати. - msdn.microsoft.com/en-us/library/yz2be5wk.aspx - «Концепция упаковки и распаковки лежит в основе унифицированного представления C # системы типов, в котором значение любого типа может рассматриваться как объект"

Roland
20 декабря 2016 в 00:24
17

Для тех, кто пришел из Algol и Fortran, это обсуждение показывает, что с string что-то не так. Это необходимо для сокращения System.String, но в качестве псевдонима это похоже, но не совсем то же самое. Однако после нескольких лет использования C #, я бы сказал, безопасно просто использовать string и string.Format() и не беспокоиться о System.String.

Sangeeta
29 ноября 2018 в 09:53
0

С 2014 года соглашения в .NET Framework сильно изменились. Теперь при объявлении переменных не существует String (capital s). доступна только строка псевдонима (маленькие буквы). Microsoft может захотеть убрать запутанный подход к программированию!

Craig Tullis
8 декабря 2018 в 02:14
12

@Sangeeta Что ты говоришь? Класс System.String все еще существует, и ключевое слово string по-прежнему является его псевдонимом. Так же, как System.Int32 и int. Это буквально одно и то же.

elnaz jangi
12 июня 2020 в 12:46
0

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

SacredGeometry
31 декабря 2020 в 01:37
0

System.String myString = "Ха!"; @Wilsu Нет? Я только что сделал.

Ответы (63)

avatar
Derek Park
22 января 2019 в 18:50
6544

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

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

например

string place = "world";

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

например,

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

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

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

Dominic Zukiewicz
22 мая 2012 в 22:36
177

Если вы решите использовать StyleCop и будете следовать этому, это будет означать использование типов, специфичных для языка. Итак, для C # у вас будет строка (вместо String), int (вместо Int32), float (вместо Single) - stylecop.soyuz5.com/SA1121.html

Rob
12 октября 2012 в 23:25
163

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

Sami Kuhmonen
22 декабря 2014 в 05:21
46

Visual Studio 2015 говорит, что String.Format следует заменить на string.Format, поэтому я думаю, что Microsoft идет по этому пути. Я также всегда использовал String для статических методов.

jmoreno
13 октября 2020 в 21:37
0

Что вы скажете о том, что вы можете определить свой собственный тип «String», но не можете сделать то же самое для «string», поскольку это ключевое слово, как описано в coderhelper.com/questions/7074/…

Rob L
29 ноября 2020 в 06:50
0

Тогда я догадываюсь ... Просто будьте последовательны. Используйте строку или строку или используйте определенный в конкретном случае, но всегда в этом случае.

avatar
18 декабря 2021 в 17:20
0

По сути, нет никакой разницы между string и String в C #.

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

Регистрация полного имени обоих типов может подтвердить это

string s1= "hello there 1";
String s2 = "hello there 2";
        
Console.WriteLine(s1.GetType().FullName); // System.String
Console.WriteLine(s2.GetType().FullName); // System.String

Рекомендуется использовать string вместо String, но это действительно вопрос выбора. Большинство разработчиков используют string для объявления переменных в C # и используют класс System.String для использования любых встроенных строковых методов, таких как, например, метод String.IsNullOrEmpty().

avatar
Taslim Oseni
14 июля 2021 в 00:00
13

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

Это похоже на bool и Boolean, без большой разницы ..

Michael Adams
5 июля 2021 в 14:12
0

«короткая версия» - насколько это коротко? Заглавная буква делает слово длиннее?

Taslim Oseni
14 июля 2021 в 00:00
1

Привет, @MichaelAdams, спасибо, что указали на это. Я имею в виду, что string - это сокращенная версия System.String.

avatar
1 марта 2021 в 20:12
2

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

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

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

string str = "Hello";

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

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

avatar
Shivprasad Koirala
26 января 2021 в 09:38
185

Это видео YouTube на практике демонстрирует их различия.

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

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

enter image description here

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

enter image description here

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

String s = "I am String";

или

string s = "I am String";

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

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

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

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

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

string s = String.ToUpper() ;

Wouter
18 февраля 2021 в 16:25
0

Но теперь у вас есть 2 стиля в одной строке? :)

avatar
aloisdg
26 января 2021 в 00:42
56

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

string vs. String - это не дискуссия о стиле

[...]

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

Идентификатор String, хотя не имеет конкретного значения в C #. Это идентификатор, который проходит через все правила поиска имени как Widget, Student и т. Д. Он может быть привязан к строке или может быть привязан к типу в другой сборке, цели которого могут быть полностью отличными от string. Хуже того, он может быть определен таким образом, чтобы код вроде String s = "hello"; продолжал компилировать.

class TricksterString { 
  void Example() {
    String s = "Hello World"; // Okay but probably not what you expect.
  }
}

class String {
  public static implicit operator String(string s) => null;
}

Фактическое значение String всегда будет зависеть от разрешения имени. Это означает, что это зависит от всех исходных файлов в проекте и всех типы, определенные во всех сборках, на которые есть ссылки. Короче это требуется довольно много контекста, чтобы знать , что это означает.

Верно, что в подавляющем большинстве случаев String и string будут привязаны к того же типа. Но использование String по-прежнему означает уход разработчиков свою программу вплоть до интерпретации в местах, где есть только один правильный ответ. Когда String привязывается к неправильному типу, он может оставить разработчики часами отлаживают, регистрируют ошибки в команде компилятора и обычно напрасная трата времени, которое можно было бы сэкономить, используя string.

Другой способ визуализировать разницу - использовать этот пример:

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

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

[...]

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

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

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

shoelzer
7 декабря 2020 в 20:58
0

Рад найти здесь этот ответ. Есть разница, и это важно.

avatar
Jon Skeet
18 октября 2020 в 05:47
3626

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

Как отмечали другие, string - это псевдоним для System.String. Предполагая, что ваш код, использующий String, компилируется в System.String (т.е. у вас нет директивы using для некоторого другого пространства имен с другим типом String), они компилируются в один и тот же код, поэтому во время выполнения нет разницы как бы то ни было. Это всего лишь один из псевдонимов в C #. Полный список:

object:  System.Object
string:  System.String
bool:    System.Boolean
byte:    System.Byte
sbyte:   System.SByte
short:   System.Int16
ushort:  System.UInt16
int:     System.Int32
uint:    System.UInt32
long:    System.Int64
ulong:   System.UInt64
float:   System.Single
double:  System.Double
decimal: System.Decimal
char:    System.Char

За исключением string и object, все псевдонимы относятся к типам значений. decimal - это тип значения, но не примитивный тип в среде CLR. Единственный примитивный тип, у которого нет псевдонима, - это System.IntPtr.

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

Существует одно обстоятельство, при котором у вас есть для использования псевдонимов: при явном указании базового типа перечисления. Например:

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

Это просто вопрос того, как спецификация определяет объявления перечисления - часть после двоеточия должна быть продукцией целочисленного типа , которая является одним токеном sbyte, byte, short, ushort, int, uint, long, ulong, char ... в отличие от типа , используемого в производстве, как используется в производстве переменных Других отличий он не указывает.

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

avatar
MicroservicesOnDDD
18 августа 2019 в 01:51
3

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

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

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

Б. Они различаются феймворком и контекстами, отличными от C #. Разное ...

  1. на ДРУГИЕ языки, НЕ являющиеся C #
  2. в оптимизированном контексте CIL (был MSIL) (язык ассемблера .NET VM)
  3. в контексте, ориентированном на платформу - .NET Framework или Mono или любая область типа CIL
  4. в книге, ориентированной на несколько языков .NET (например, VB.NET, F # и т. Д.)

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

С. Подводя итог ...

Вы используете string и int и другие типы C # в целевой аудитории, предназначенной только для C # (задайте вопрос, кто будет читать этот код или использовать эту библиотеку). Для вашей внутренней компании, если вы используете только C #, придерживайтесь типов C #.

... и вы используете System.String и System.Int32 в многоязычной целевой аудитории или целевой аудитории (когда C # не единственная аудитория). Для своей внутренней организации, если вы также используете VB.NET, F # или любой другой язык .NET или разрабатываете библиотеки для использования клиентами, которые могут, тогда вам следует использовать типы «Frameworky» в этих контекстах, чтобы каждый мог понять ваш интерфейс. , независимо от того, из какой они вселенной. (Во всяком случае, что такое клингон для System.String?)

HTH.

mins
20 сентября 2019 в 10:11
0

« Б. Они различаются в Famework и в контекстах, отличных от C # »: Хотя это может быть правдой, ответ не говорит о различиях, а только перечисляет контексты, в которых они могут появиться. Технически он не отвечает на вопрос и, к сожалению, не помогает больше, чем выбранный ответ.

mins
5 октября 2019 в 13:34
0

" Они ОДИНАКОВЫЕ (точно такие же) ": нет, попробуйте это: string s = nameof (string), чтобы убедиться.

avatar
Ahmad
16 июля 2019 в 04:33
2

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

необходимо импортировать пространство имен
avatar
25 июня 2019 в 12:06
6

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

public static void Main()
{
    var s = "a string";
}

скомпилируйте его и откройте .exe с помощью ildasm, чтобы увидеть

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       8 (0x8)
  .maxstack  1
  .locals init ([0] string s)
  IL_0000:  nop
  IL_0001:  ldstr      "a string"
  IL_0006:  stloc.0
  IL_0007:  ret
} // end of method Program::Main

затем измените var на string и String, скомпилируйте, откройте с ildasm и см. IL не изменится. Это также показывает, что создатели языка предпочитают только string при определении переменных (спойлер: при вызове членов они предпочитают String).

Ted Mucuzany
4 июля 2019 в 13:28
0

Насколько мне известно, string против String - это вопрос стиля кодирования.

Ted Mucuzany
4 июля 2019 в 13:29
0

А string стремится к победе.

avatar
14 мая 2019 в 15:15
4

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

String.Format()

Переменная

string name = "";
Lance U. Matthews
21 июня 2020 в 19:03
0

Почему? Чем String.Format() отличается от string.Format() или string name = ""; от String name = "";? Я понимаю, что в этой части вопроса требуются рекомендации по использованию, но каков источник или основа этих рекомендаций?

avatar
Otiel
5 декабря 2018 в 09:34
82

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

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

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

  • В C #, long сопоставляется с System.Int64 , но на другом языке программирования, <12> long69310474> может отображаться на Int16 или Int32 . Фактически, C ++ / CLI обрабатывает long как Int32 . Кто-то, читающий исходный код на одном языке, может легко неверно истолковать его намерение, если он или она привыкли программировать на другом языке программирования. Фактически, большинство языков даже не рассматривают long как ключевое слово и не компилируют код. который его использует.

  • У FCL есть много методов, которые имеют имена типов как часть их имен методов. Для Например, тип BinaryReader предлагает такие методы, как ReadBoolean , ReadInt32 , ReadSingle и т. Д., А тип System.Convert предлагает такие методы, как ToBoolean , ToInt32 , ToSingle и т. Д. Хотя законно писать следующие кода, строка с float кажется мне очень неестественной, и не очевидно, что эта строка правильно:

    BinaryReader br = new BinaryReader(...);
    float val = br.ReadSingle(); // OK, but feels unnatural
    Single val = br.ReadSingle(); // OK and feels good
    
  • Многие программисты, использующие исключительно C #, склонны забывать, что другое программирование языки могут использоваться против CLR, и из-за этого C # -измы проникают в код библиотеки классов. Например, Microsoft FCL почти полностью написана на C # и разработчики из команды FCL добавили в библиотеку такие методы, как Массив 's GetLongLength , который возвращает значение Int64 , которое является длиной C69, но не для длинного # 354474 на других языках (например, C ++ / CLI). Другой пример: System.Linq.Enumerable Метод LongCount .

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

avatar
1 декабря 2018 в 17:44
7

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

avatar
16 октября 2018 в 17:32
6

String - это класс string. Если вы удалите пространство имен System из операторов using, вы увидите, что String ушел, но string все еще здесь. string - ключевое слово для строки. Нравится
int and Int32
short and Int16
long and Int64

Таким образом, ключевые слова - это всего лишь некоторые слова, в которых используется класс. Эти ключевые слова определены C # (то есть Microsoft, потому что C # принадлежит Microsoft). Вкратце, разницы нет. Используя string or String. Это не имеет значения. Они такие же.

avatar
Mel
3 октября 2018 в 04:24
71

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

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

avatar
BerBar
4 августа 2018 в 06:12
7

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

avatar
12 июля 2018 в 01:35
7

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

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

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

avatar
Luke Foust
4 июля 2018 в 11:05
542

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

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

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

avatar
habib
27 июня 2018 в 16:47
8

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

avatar
zap92
8 июня 2018 в 20:47
21

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

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

avatar
Pritam Jyoti Ray
27 апреля 2018 в 18:40
9

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

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

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

avatar
wild coder
8 февраля 2018 в 09:58
12

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

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

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

Heriberto Lugo
14 февраля 2018 в 16:13
4

так что внутренне они такие же. это означает, что они указывают на одно и то же и могут использоваться как взаимозаменяемые. их различие заключается в том, что String - это имя фактической структуры, как определено, тогда как string - это псевдоним, который указывает на ту же самую структуру. it (строка), являющаяся псевдонимом, делает его ключевым словом, поэтому VS показывает их как разные цвета. Если вы щелкните правой кнопкой мыши, чтобы просмотреть определение строки, вы увидите структуру String.

avatar
Ronnie
6 февраля 2018 в 12:39
284

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

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

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

avatar
1 февраля 2018 в 13:13
10

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

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

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

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

avatar
18 января 2018 в 13:40
22

Между 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   |
mins
20 сентября 2019 в 10:32
1

В конце концов, кто-то может указать реальную разницу ... вы также можете добавить необходимость в директиве using System; перед использованием типа String вместо ключевого слова C # string. Это должен быть выбранный ответ или, по крайней мере, получивший высокую оценку.

avatar
Majid khalili
8 января 2018 в 04:08
14

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

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

avatar
Simon_Weaver
27 декабря 2017 в 17:33
485

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

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

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

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

StringBuilder @string = new StringBuilder();

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

avatar
10 ноября 2017 в 11:34
8

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

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

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

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

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

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

avatar
18 октября 2017 в 15:11
8

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

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

avatar
Pradeep Kumar Mishra
14 августа 2017 в 05:16
151

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

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

avatar
urini
14 августа 2017 в 04:33
176

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

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

Quarkly
29 мая 2015 в 20:23
7

Проблема в том, что это не псевдонимы C #, а псевдонимы C. В языке C # нет собственных 'string' или 'int', только синтаксический сахар.

aiodintsov
24 февраля 2016 в 06:57
19

не уверен, откуда взялось «C», поскольку спецификация языка C # 5 гласит: «Строка ключевого слова - это просто псевдоним для предопределенного класса System.String». на стр. 85, п. 4.2.4. Все языки высокого уровня являются синтаксическим сахаром над наборами инструкций ЦП и байт-кодом.

avatar
25 марта 2017 в 05:04
8

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

System.String str;

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

string str;
avatar
user2771704
11 декабря 2016 в 05:27
48

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

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

avatar
11 декабря 2016 в 00:38
7

Строка : представляет класс

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

Это просто соглашение о кодировании от Microsoft.

avatar
JeeShen Lee
8 октября 2016 в 18:50
86

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

avatar
user3296
3 октября 2016 в 18:32
424

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

avatar
StuartLC
28 сентября 2016 в 11:58
228

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

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

Рассмотрим:

String someString; 
string anotherString; 
avatar
Inverted Llama
12 августа 2016 в 18:42
15

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

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

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

Andy
8 октября 2016 в 18:53
0

Не забудьте назвать эти другие языки, потому что я не знаю ни одного в .net, где строка! = System.String. Кроме того, литерал не имеет ничего общего со строкой и строкой ...

Dawood ibn Kareem
21 февраля 2019 в 01:17
0

Действительно ли 26 избирателей считают, что это правильно?

Inverted Llama
21 февраля 2019 в 01:36
0

@Andy Я работал с Java, когда я ответил на это, где это имеет значение, не уверен, что вопрос указан .net, когда я ответил на него, поскольку с тех пор он был отредактирован

avatar
hubot
4 июня 2016 в 11:31
9

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

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

string a = new string(new char[] { 'x', 'y', 'z' });
string b = new String(new char[] { 'x', 'y', 'z' });
String c = new string(new char[] { 'x', 'y', 'z' });
String d = new String(new char[] { 'x', 'y', 'z' });
MessageBox.Show((a.GetType() == typeof(String) && a.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((b.GetType() == typeof(String) && b.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((c.GetType() == typeof(String) && c.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((d.GetType() == typeof(String) && d.GetType() == typeof(string)).ToString()); // shows true

@JonSkeet в моем компиляторе

public enum Foo : UInt32 { }

работает. У меня есть сообщество Visual Studio 2015.

avatar
tic
6 мая 2016 в 09:38
16

Если действительно полезно увидеть, нет никакой разницы между 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 ]
Mark Hurd
26 октября 2015 в 09:03
2

Я дал вам +1, но ваши фактические методы при включенной оптимизации + идентичны return "Hello World!";. Чтобы на самом деле гарантировать, что типы «учитываются», вы можете использовать return (string)(object)typeof(string).Name; и return (System.String)(System.Object)typeof(System.String).Name;, что подтверждает, что System.Object тоже идентичен object :-)

avatar
CoreDeveloper
16 марта 2016 в 19:35
42

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

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

Пример

string String = "I am a string";

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

 typeof(string) == typeof(String) == typeof(System.String)
Uttam
4 марта 2018 в 09:29
2

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

Rick the Scapegoat
4 июня 2019 в 13:36
0

Существуют простые варианты использования, в которых оператор равенства не работает ... Например, определение типа String вызова в пространстве имен blah и импорт этого пространства имен в файл, в котором выполняется оператор равенства.

avatar
28 декабря 2015 в 09:03
8

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

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

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

avatar
Coder
25 декабря 2015 в 12:55
42

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

avatar
Rasmus Faber
25 декабря 2015 в 12:55
200

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

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

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

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

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

avatar
7 апреля 2015 в 10:30
26

Оба они одинаковы. Разница в том, как вы их используете. Условное обозначение:

s строка предназначена для переменных

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

Нравится:

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

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

if (String.IsNullOrEmpty(fName))
{
  Console.WriteLine("Enter first name");
}
Massimiliano Kraus
4 ноября 2016 в 14:04
2

Это соглашение больше не действует: если вы используете Visual Studio 2015 и пытаетесь использовать String, программа предлагает вам «упростить код», перенеся его на string.

avatar
15 января 2015 в 14:21
113

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

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

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


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

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

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

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

Хуже того: выражение String.Concat(someSequence) скорее всего (в зависимости от using 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 всегда пианино струна, MyPiano.String. В нем нет члена (static или нет) Format (или он унаследован от его базового класса). И значение "Goodbye" не может быть преобразовано в него.

avatar
Singh
15 января 2015 в 11:37
7

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

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

avatar
John Ortiz Ordoñez
15 января 2015 в 11:36
8

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

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

Ссылка .

avatar
11 июня 2014 в 11:15
6

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

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

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

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

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

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

avatar
Ryan
20 мая 2014 в 14:47
9

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

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

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

  • string обычно используется для объявления, а String используется для доступа к статическим строковым методам
  • Вы можете использовать 'string' для объявления полей, свойств и т.д., которые используют предопределенный тип 'string', поскольку спецификация C # говорит мне, что это хороший стиль.
  • Вы можете использовать 'String' для использования системных методов, таких как String.Compare и т. Д. Они изначально определены в System.String, а не в строке. 'string' в данном случае просто псевдоним.
  • Вы также можете использовать 'String' или System.Int32 при взаимодействии с другой системой, особенно если они совместимы с CLR. то есть - если я получу данные из другого места, я бы десериализовал их в System.Int32, а не в int, если бы источник по определению был чем-то другим, кроме системы C #.
Jay Sullivan
24 сентября 2014 в 14:56
1

Где ты это достаешь? Все это полная чушь: String и string - одно и то же.

Neo
7 ноября 2019 в 00:49
0

@JaySullivan Я бы хотел не согласиться.

avatar
Joe Alfano
24 декабря 2013 в 04:50
74

Строка (System.String) - это класс в библиотеке базовых классов. строка (нижний регистр) - это зарезервированная работа в C #, которая является псевдонимом для System.String. Int32 vs int - аналогичная ситуация, как и Boolean vs. bool. Эти ключевые слова, специфичные для языка C #, позволяют объявлять примитивы в стиле, аналогичном C.

avatar
3 октября 2012 в 10:52
29

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

System.String - это ссылочный тип, а имена ссылочных типов по соглашению имеют паскальский регистр .

P Daddy
23 апреля 2013 в 21:14
3

-1 Все имена типов по соглашению записаны в паскальском регистре. Но все ключевые слова C # пишутся в нижнем регистре.

Zaid Masud
24 апреля 2013 в 13:24
0

@PDaddy да, и string действительно ключевое слово C #. Здесь задается вопрос, предпочтительнее ли использовать ключевое слово или имя типа. В моем ответе говорится, что, хотя вы, очевидно, можете выбрать ключевое слово, одним из аргументов в пользу использования имени типа является то, что ключевое слово they string, которое является псевдонимом для String, в конечном итоге является ссылочным типом. >, напротив, является псевдонимом для Int32, который является типом значения.

P Daddy
24 апреля 2013 в 15:34
4

Соглашения о регистре не различаются между ссылочными типами и типами значений, о чем свидетельствует упомянутый вами тип Int32. Нет смысла отказываться от ключевого слова в пользу имени класса, чтобы соблюдать какое-то воображаемое ограничение, согласно которому ссылочные типы следуют другим соглашениям об именах, чем типы значений.

Zaid Masud
24 апреля 2013 в 18:40
0

@PDaddy да, ты прав. Я переносил сюда соглашения Java, где примитивы - это camelCase.

avatar
24 августа 2012 в 15:22
68

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

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

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

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

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

avatar
Oded
15 января 2012 в 00:30
51

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

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

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

avatar
Hallgrim
3 декабря 2011 в 19:53
164

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

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

Joe Ratzer
18 октября 2008 в 19:24
0

Для использования String вам не нужно использовать префикс System.

Ronald
16 октября 2009 в 17:53
20

Вы должны включить using System при использовании String, иначе вы получите следующую ошибку: The type or namespace name 'String' could not be found (are you missing a using directive or an assembly reference?)

avatar
artur02
3 декабря 2011 в 19:53
766

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

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

Nyerguds
28 апреля 2016 в 11:41
7

Лично я предпочитаю использовать "Int32", поскольку он сразу показывает диапазон значения. Представьте, если бы они обновили тип int в более поздних системах с более высоким битом. 'int' в c очевидно рассматривается как "целочисленный тип, с которым целевой процессор наиболее эффективно работает" , и определяется как "не менее 16 бит". Я бы предпочел здесь предсказуемую последовательность, большое вам спасибо.

Peter - Reinstate Monica
21 января 2017 в 17:39
4

@MyDaftQuestions Я согласен. Во всяком случае, имеет смысл последовательно использовать типы .net , потому что они не знают языка, а тип очевиден, независимо от любого языка (знаю ли я все особенности F # или VB?).

Craig Tullis
8 декабря 2018 в 02:47
12

@Nyerguds Есть две причины не беспокоиться об этом. Во-первых, int определен в спецификации языка C # как 32-битное целое число независимо от оборудования. C #, несмотря на общее наследие в глубине веков, на самом деле не является C. Изменение int на 64-битное целое число было бы серьезным изменением в спецификации и языке. Это также потребует переопределения long, поскольку long в настоящее время является 64-битным целым числом. Другая причина не волноваться не имеет значения, поскольку типы никогда не изменятся, но .NET достаточно абстрактна, чтобы в 99% случаев вам все равно не приходилось об этом думать. ;-)

Nyerguds
9 декабря 2018 в 02:29
8

@Craig Я копаюсь во многих старых проприетарных форматах игр, где мне действительно приходится постоянно об этом думать. И затем использование Int16, Int32 и Int64 является лотом более прозрачным в коде, чем использование довольно неинформативных short, <int10> и <1502>

Craig Tullis
14 октября 2020 в 15:49
3

Но short, not, long, float, double и др. являются описательными, потому что они указаны в спецификации языка. C # - это не C. Я предпочитаю их в объявлениях, потому что они краткие, маленькие и эстетично. Я предпочитаю имена библиотек Torre в API, в которых API зависит от типа данных.

avatar
TheSoftwareJedi
19 ноября 2011 в 09:37
207

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

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

avatar
TraumaPony
19 ноября 2011 в 09:36
332

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

Jeppe Stig Nielsen
24 мая 2019 в 12:04
15

Я не понимаю, что означает этот ответ и почему за него проголосовали. Вы можете использовать typeof(string) в отражении. Пример первый: if (someMethodInfo.ReturnType == typeof(string)) { ... } Пример второй: var p = typeof(string).GetProperty("FirstChar", BindingFlags.NonPublic | BindingFlags.Instance); Где вы должны использовать String, а не string? Если вы попробуете такие вещи, как Type.GetType("String") или Type.GetType("string"), ни один из них не найдет класс, потому что пространство имен отсутствует. Если по какой-то глупой причине вы сравниваете .Name типа с "string" с учетом регистра, вы правы.

avatar
Lloyd Cotten
19 ноября 2011 в 09:35
127

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

avatar
user576533
19 ноября 2011 в 09:35
69

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

avatar
RolandK
19 ноября 2011 в 09:35
93

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

Roland
20 апреля 2021 в 12:20
0

Хорошая точка зрения. Если бы не была изобретена «струна», у нас не было бы путаницы и не было бы нужды в этом бессмысленном обсуждении. Все наши приложения будут нормально работать со String. 'int' кажется полезным, если вы не заботитесь о размере битов, что происходит в большинстве случаев, а 'string' добавляется только для согласованности.

avatar
Dot NET
19 ноября 2011 в 09:34
37

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

avatar
22 сентября 2008 в 19:40
105

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