Должен ли я использовать int или Int32

Тебе все равно. Если размер важен, я бы использовал byte, short, int, затем long. Единственная причина, по которой вы могли бы использовать int больше int32, - это если вам нужно число больше 2147483647 или меньше -2147483648.

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

Я знаю, что лучше всего использовать int, а весь код MSDN использует int. Однако, насколько мне известно, нет причин, кроме стандартизации и согласованности.

Эти два понятия действительно синонимичны; int будет немного более знакомым, Int32 делает 32-битность более явной для тех, кто читает ваш код. Я был бы склонен использовать int там, где мне просто нужно `` целое число '', Int32, где важен размер (криптографический код, структуры), поэтому будущие специалисты по сопровождению будут знать, что можно безопасно увеличивать int, если это необходимо, но должны позаботиться об изменении Int32 в так же.

Полученный код будет идентичным: разница заключается исключительно в удобочитаемости или внешнем виде кода.

Нет никакой разницы между int и Int32, но поскольку int является ключевым словом языка, многие люди предпочитают его стилистически (так же, как string против String).

int и Int32 одинаковы. int - это псевдоним Int32.

По моему опыту, это было условностью. Я не знаю какой-либо технической причины использовать int вместо Int32, но это:

1. Быстрее печатать.
2. Более знакомо типичному разработчику C#.
3. Другой цвет в выделении синтаксиса Visual Studio по умолчанию.

Последнее мне особенно нравится. :)

Как уже говорилось, int = Int32. На всякий случай всегда используйте int.MinValue / int.MaxValue при реализации всего, что касается границ типов данных. Предположим, .NET решил, что int теперь будет Int64, ваш код будет меньше зависеть от границ.

int - это то же самое, что и System.Int32, и при компиляции он превратится в то же самое в CIL.

Мы используем int по соглашению в C#, поскольку C# хочет выглядеть как C и C++ (и Java), и это то, что мы там используем ...

Кстати, я в конечном итоге использую System.Int32 при объявлении импорта различных функций Windows API. Я не уверен, является ли это определенным соглашением или нет, но это напоминает мне, что я собираюсь использовать внешнюю DLL ...

Байты, которые может содержать int, зависят от того, для чего вы его скомпилировали, поэтому, когда вы компилируете свою программу для 32-битных процессоров, она содержит числа от 2 ^ 32/2 до -2 ^ 32/2 + 1, а скомпилированная для 64-битной версии может удерживайте от 2 ^ 64/2 до -2 ^ 64/2 + 1. int32 всегда будет содержать 2 ^ 32 значения.

Редактировать: Не обращайте внимания на мой ответ, я не видел C#. Мой ответ был предназначен для C и C++. Я никогда не использовал C#

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

int total = Int32.Parse("1009");

Вы не должны заботиться о большинстве языков программирования, если вам не нужно писать очень конкретные математические функции или код, оптимизированный для одной конкретной архитектуры ... Просто убедитесь, что размера типа достаточно для вас (используйте что-то большее, чем Int, если вы знать вам понадобится, например, более 32 бит)

int - это ключевое слово C#, которое однозначно.

В большинстве случаев это не имеет значения, но две вещи идут вразрез с Int32:

• У вас должна быть «система использования»; утверждение. использование "int" не требует использования оператора.
• Можно определить свой собственный класс с именем Int32 (что было бы глупо и запутанно). int всегда означает int.

Неважно. int - это ключевое слово языка, а Int32 - его фактический тип системы.

См. Также мой ответь здесь по соответствующему вопросу.

Когда-то тип данных int был привязан к размеру регистра машины, на которую нацелился компилятор. Так, например, компилятор для 16-битной системы будет использовать 16-битное целое число.

Однако мы, к счастью, больше не видим много 16-битных, и когда 64-битные стали популярными, люди были больше озабочены тем, чтобы сделать их совместимыми со старым программным обеспечением, а 32-битные версии существовали так давно, что для большинства компиляторов int просто предполагается, что он составляет 32 бита.

int - это ярлык языка C# для System.Int32

Хотя это означает, что Microsoft может изменить это сопоставление, в сообщении в обсуждениях FogCreek говорится: [источник]

«Что касается 64-битной проблемы - Microsoft действительно работает над 64-битной версией .NET Framework, но я почти уверен, что int НЕ будет отображать 64-битную версию в этой системе.

Причины:

1. В стандарте C# ECMA специально сказано, что int - 32-битное, а long - 64-битное.

2. Microsoft представила дополнительные свойства и методы в Framework версии 1.1, которые возвращают длинные значения вместо значений типа int, такие как Array.GetLongLength в дополнение к Array.GetLength.

Поэтому я думаю, что можно с уверенностью сказать, что все встроенные типы C# сохранят свое текущее отображение ».

ECMA-334: 2006 Спецификация языка C# (стр.18):

Each of the predefined types is shorthand for a system-provided type. For example, the keyword int refers to the struct System.Int32. As a matter of style, use of the keyword is favoured over use of the complete system type name.

Оба они объявляют 32-битные целые числа, и, как указано в других плакатах, вопрос о том, какое из них вы используете, в основном зависит от синтаксического стиля. Однако они не всегда ведут себя одинаково. Например, компилятор C# этого не допустит:

public enum MyEnum : Int32
{
    member1 = 0
}

но это позволит:

public enum MyEnum : int
{
    member1 = 0
}

Иди разберись.

Я использую int в том случае, если Microsoft меняет реализацию по умолчанию для целого числа на какую-то новую версию (назовем ее Int32b).

Затем Microsoft может изменить псевдоним int на Int32b, и мне не нужно менять какой-либо код, чтобы воспользоваться их новой (и, надеюсь, улучшенной) реализацией целых чисел.

То же самое касается любого ключевого слова типа.

Размер байта для типов не слишком интересен, когда вам нужно иметь дело только с одним языком (и для кода, который вам не нужно напоминать себе о математических переполнениях). Часть, которая становится интересной, - это когда вы переходите от одного языка к другому, от C# к COM-объекту и т. д., Или вы выполняете битовый сдвиг или маскировку, и вам нужно напоминать себе (и вашим соавторам по проверке кода) размера данных.

На практике я обычно использую Int32, просто чтобы напомнить себе, какого они размера, потому что я пишу управляемый C++ (например, для соединения с C#), а также неуправляемый / собственный C++.

Как вы, наверное, знаете, в C# 64-битный, но в родном C++ он заканчивается как 32-битный, или char - это unicode / 16-бит, а в C++ - 8-бит. Но откуда мы это знаем? Ответ таков, потому что мы искали это в руководстве, и там написано так.

Со временем и опытом вы начнете более внимательно относиться к типам, когда будете писать коды для перехода между C# и другими языками (некоторые читатели здесь думают: «Почему бы вам?»), Но ИМХО, я считаю, что это лучшая практика, потому что Я не могу вспомнить, что я кодировал на прошлой неделе (или мне не нужно указывать в моем документе API, что «этот параметр является 32-битным целым числом»).

В F# (хотя я никогда не использовал его) они определяют int, int32 и nativeint. Возникает тот же вопрос: «какой из них использовать?». Как отмечали другие, в большинстве случаев это не имеет значения (должно быть прозрачным). Но я бы выбрал int32 и uint32, чтобы устранить двусмысленность.

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

Дополнение: Между прочим, поскольку я ответил на этот вопрос несколько лет назад, я начал использовать как F#, так и Rust. F#, это все о выводе типов и соединении / взаимодействии между C# и F#, нативные типы совпадают, так что не беспокойтесь; Мне редко приходилось явно определять типы в F# (это почти грех, если вы не используете вывод типов). В Rust они полностью устранили такую ​​двусмысленность, и вам придется использовать i32 против u32; В общем, уменьшение двусмысленности помогает уменьшить количество ошибок.

int - это псевдоним для System.Int32, как определено в этой таблице: Таблица встроенных типов (Справочник по C#)

Для использования типа Int32 требуется ссылка на пространство имен System или полное определение (System.Int32). Я предпочитаю int, потому что он не требует импорта пространства имен, что снижает вероятность коллизии пространства имен в некоторых случаях. При компиляции в IL между ними нет никакой разницы.

Также рассмотрите Int16. Если вам нужно сохранить целое число в памяти в вашем приложении, и вас беспокоит объем используемой памяти, вы можете использовать Int16, поскольку он использует меньше памяти и имеет меньший диапазон min / max, чем Int32 (это то, что int .)

Я всегда использую системные типы - например, Int32 вместо int. Я принял эту практику после прочтения Прикладное программирование .NET Framework - автор Джеффри Рихтер приводит хороший аргумент в пользу использования полных имен типов. Вот два момента, которые меня запомнили:

1. Имена типов могут различаться в зависимости от языка .NET. Например, в C# long сопоставляется с System.Int64, а в C++ с управляемыми расширениями long сопоставляется с Int32. Поскольку языки могут быть смешаны и сопоставлены при использовании .NET, вы можете быть уверены, что использование явного имени класса всегда будет более ясным, независимо от предпочтительного языка читателя.

2. Многие методы фреймворка имеют имена типов как часть имен методов:

   BinaryReader br = new BinaryReader( /* ... */ );
   float val = br.ReadSingle();     // OK, but it looks a little odd...
   Single val = br.ReadSingle();    // OK, and is easier to read
   

Тебе все равно. Вы должны использовать int большую часть времени. Это поможет перенести вашу программу на более широкую архитектуру в будущем (в настоящее время int является псевдонимом System.Int32, но это может измениться). Только когда разрядность переменной имеет значение (например: для управления компоновкой в ​​памяти struct), вы должны использовать int32 и другие (с соответствующим «using System;»).

Некоторое время назад я работал над проектом с Microsoft, когда к нам приехал кто-то из группы разработки продукта Microsoft .NET CLR. Этот человек кодировал примеры, и когда он определял свои переменные, он использовал «Int32» вместо «int» и «String» против «string».

Я вспомнил, что видел этот стиль в другом примере кода от Microsoft. Итак, я провел небольшое исследование и обнаружил, что все говорят, что нет никакой разницы между «Int32» и «int», за исключением окраски синтаксиса. Фактически, я нашел много материалов, в которых предлагалось использовать «Int32», чтобы сделать код более читабельным. Итак, я перенял этот стиль.

На днях я действительно нашел разницу! Компилятор не позволяет вам набирать enum с помощью «Int32», но это возможно, когда вы используете «int». Не спрашивайте меня, почему, потому что я еще не знаю.

Пример:

public  enum MyEnum : Int32
{
    AEnum = 0
}

Это работает.

public enum MyEnum : int
{
    AEnum = 0
}

Взято из: Нотация Int32 против int

Хотя они (в основном) идентичны (см. Ниже одно различие [ошибка]), вам определенно следует позаботиться и использовать Int32.

• Имя 16-битного целого числа - Int16. Для 64-битного целого числа это Int64, а для 32-битного целого числа интуитивно понятный выбор: int или Int32?

• Вопрос о размере переменной типа Int16, Int32 или Int64 ссылается на саму себя, но вопрос о размере переменной типа int - вполне допустимый вопрос, и вопросы, какими бы тривиальными они ни были, отвлекают, приводят к сбивать с толку, тратить время, мешать дискуссии и т. д. (факт существования этого вопроса подтверждает точку зрения).

• Использование Int32 способствует тому, что разработчик осознает свой выбор типа. Насколько велик снова int? Ах да, 32. Вероятность того, что размер шрифта действительно будет учтена, выше, когда размер включен в название. Использование Int32 также способствует знанию других вариантов. Когда людей не заставляют хотя бы признать, что есть альтернативы, для int становится слишком легко стать «целочисленным типом».

• Класс в структуре, предназначенный для взаимодействия с 32-разрядными целыми числами, называется Int32. Еще раз, что: более интуитивно понятное, менее запутанное, отсутствует (ненужный) перевод (не перевод в системе, а в уме разработчика) и т. д. int lMax = Int32.MaxValue или Int32 lMax = Int32.MaxValue?

• int не является ключевым словом во всех языках .NET.

• Хотя есть аргументы, почему это вряд ли когда-либо изменится, int не всегда может быть Int32.

Недостатки - два дополнительных символа для ввода и [ошибка].

Это не скомпилируется

public enum MyEnum : Int32
{
    AEnum = 0
}

Но это будет:

public enum MyEnum : int
{
    AEnum = 0
}

Использование Int или Int32 - это одно и то же. Int - это просто сахар для упрощения кода для читателя.

Используйте вариант, допускающий значение NULL, Int? или Int32? когда вы работаете с базами данных по полям, содержащим null. Это избавит вас от множества проблем во время выполнения.

Некоторые компиляторы имеют разные размеры для int на разных платформах (не для C#)

Некоторые стандарты кодирования (MISRA C) требуют, чтобы для всех используемых типов был указан размер (например, Int32, а не int).

Также хорошо указать префиксы для переменных разных типов (например, b для 8-битного байта, w для 16-битного слова и l для 32-битного слова => Int32 lMyVariable)

Вам следует проявлять осторожность, потому что это делает ваш код более переносимым и более удобным в обслуживании.

Portable может быть неприменим к C#, если вы всегда собираетесь использовать C#, и спецификация C# никогда не изменится в этом отношении.

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

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

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

Я всегда использую типы с псевдонимом (int, string и т. д.) При определении переменной и использую настоящее имя при доступе к статическому методу:

int x, y;
...
String.Format ("{0}x{1}", x, y);

Просто уродливо видеть что-то вроде int.TryParse (). У меня нет другой причины, кроме стиля.

Я бы рекомендовал использовать Microsoft StyleCop.

Это похоже на FxCop, но для проблем, связанных со стилем. Конфигурация по умолчанию соответствует внутренним руководствам по стилю Microsoft, но ее можно настроить для вашего проекта.

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

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

Согласно Immediate Window в Visual Studio 2012 Int32 - это int, Int64 - длинный. Вот результат:

sizeof(int)
4
sizeof(Int32)
4
sizeof(Int64)
8
Int32
int
    base {System.ValueType}: System.ValueType
    MaxValue: 2147483647
    MinValue: -2147483648
Int64
long
    base {System.ValueType}: System.ValueType
    MaxValue: 9223372036854775807
    MinValue: -9223372036854775808
int
int
    base {System.ValueType}: System.ValueType
    MaxValue: 2147483647
    MinValue: -2147483648