String и string в чем разница

String и string в С#: больше, чем просто стиль?

Обзор

Во-первых, давайте рассмотрим оба типа:

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

При компиляции на языке-посреднике обе переменные описываются одинаковым способом.

Рекомендации

Visual Studio также рекомендует такой вариант как часть правила IDE0049: «Используйте дескрипторы языка вместо дескрипторов среды для ссылки на типы»:

Проблема со String

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

Контраргументы

Конечно, имеется ряд контраргументов, о которых также стоит упомянуть:

Выводы

Приложение: типы

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

Источник

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

пример (Примечание делу):

что такое рекомендации для каждого? И каковы различия?

30 ответов

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

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

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

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

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

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

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

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

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

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

другое критическое отличие: переполнение стека выделяет их иначе.

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

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

string тип в C#.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Источник

В чем разница между String[] и String. в Java?

как я должен объявить main() метод в Java?

в чем на самом деле разница между String[] и String. если какие-то?

5 ответов

как я должен объявить метод main () в Java?

String[] и String. то же самое внутренне, я. e., массив строк. Разница в том, что при использовании параметра varargs ( String. ) вы можете вызвать метод, как:

и когда вы объявляете параметр как массив строк, вы должны позвоните сюда:

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

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

тогда как вам нужно вызвать метод, который принимает такой массив:

на main метод это не имеет значения.

String[] args принимает в качестве аргумента массив.

String. args принимает в качестве аргумента произвольное количество строк и создает из них массив.

надеюсь, что это очищает ваши запросы 🙂

позволяет понять разницу через пример и его очень легко

Метод getid принимает массив типа int.

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

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

2)вы ничего не можете передать при использовании «. »
В Примере два вы ничего не можете передать при вызове метода «getid», и они будут работать без каких-либо ошибок, что очень полезно, чтобы сделать программу более стабильной, например

Но если мы вызовем метод «getid» и не передадим аргумент при использовании » [ ]», то он покажет ошибку при компиляции время

Источник

Как мне объявить метод main() в Java?

Как мне объявить метод main () в Java?

И когда вы объявляете параметр как массив String, вы MUST вызываете так:

Соглашение состоит в том, чтобы использовать String[] в качестве основного параметра метода, но использование String. также работает, так как при использовании varargs вы можете вызывать метод таким же образом, как вы вызываете метод с массивом в качестве параметра, а сам параметр будет массивом внутри тело метода.

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

тогда как вам нужно вызвать метод, который принимает массив следующим образом:

Для метода main это не имеет значения.

String[] args принимает аргумент массива.

String. args принимает произвольное количество строк в качестве аргумента и создает из них массив.

Давайте поймем разницу на примере и его супер просто

Метод getid принимает массив типа int.

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

теперь методу все еще нужен массив, но теперь мы можем передать прямое значение этому методу и «. » автоматически преобразовать его в массив
посмотрите пример ниже

2) Вы не можете ничего передать, используя «. »
Во втором примере вы можете ничего не передавать при вызове метода «getid», и они будут работать без каких-либо ошибок, что очень полезно, например, для повышения стабильности программы.

Но если мы вызовем метод «getid» и не передадим аргумент при использовании «[]», то он покажет ошибку во время компиляции

Источник

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

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

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

ОТВЕТЫ

Ответ 1

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

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

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

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

Ответ 2

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

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

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

Ответ 3

Ответ 4

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

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

Ответ 5

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

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

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

Ответ 6

Ответ 7

Ответ 8

Ответ 9

Ответ 10

Ответ 11

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

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

Ответ 12

Ответ 13

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

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

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

Ответ 14

Ответ 15

Ответ 16

Ответ 17

Ответ 18

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

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

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

Ответ 19

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

Ответ 20

Ответ 21

Ответ 22

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

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

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

В С#, long maps to System.Int64, но на другом языке программирования, long может отображать Int16 или Int32. В самом деле, C++/CLI это лечить долго, как Int32. Кто-то, читающий исходный код на одном языке, может легко неверно интерпретировать намерение кодов, если он или она использовались для программирования на другом языке программирования. На самом деле, большинство языков даже долго не будут рассматривать ключевое слово и не будут компилировать код, который его использует.

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

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

Ответ 23

Ответ 24

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

Ответ 25

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

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

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

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

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

Ответ 26

Ответ 27

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

Ответ 28

Вот цитата из этой статьи из книга Даниэля Солиса.

Ответ 29

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

Пример

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

Ответ 30

Источник