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

В С#, int и Int32 - это одно и то же, но я читал несколько раз, что int предпочтительнее Int32 без объяснения причин. Есть ли причина, и мне все равно?

Ответ 1

ECMA-334: Спецификация языка С# 2006 (p18):

Каждый из предопределенных типов является сокращением для системного типа. Например, ключевое слово int относится к struct System.Int32. В зависимости от стиля использование ключевого слова предпочтительнее использования полного имени типа системы.

Ответ 2

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

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

Ответ 3

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

public enum MyEnum : Int32
{
    member1 = 0
}

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

public enum MyEnum : int
{
    member1 = 0
}

Показать рисунок.

Ответ 4

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

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

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

Ответ 5

int - ключевое слово С# и недвусмысленно.

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

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

Ответ 6

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

Ответ 7

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

Ответ 8

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

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

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

Со временем и опытом вы начнете быть более добросовестными, когда будете писать коды для перехода между С# и другими языками (некоторые читатели здесь думают "зачем вам?" ), но IMHO Я считаю, что это лучше, потому что я не могу вспомнить, что я закодировал на прошлой неделе (или мне не нужно указывать в моем документе API, что "этот параметр является 32-битным целым числом" ).

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

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

Ответ 9

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

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

Я особенно люблю этот последний.:)

Ответ 10

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

Ответ 11

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

Имя для 16-разрядного целого - Int16. Для 64-битного целого числа Int64, а для 32-битного целого - интуитивный выбор: int или Int32?
Вопрос о размере переменной типа Int16, Int32 или Int64 является самореференцией, но вопрос о размере переменной типа int является вполне правильным вопросом и вопросами, независимо от того, как тривиальны, отвлекают, приводят к путанице, времени отходов, препятствуют обсуждению и т.д. (факт, что этот вопрос существует, доказывает суть).
Использование Int32 способствует тому, что разработчик осознает свой выбор типа. Насколько велика int 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
}

Ответ 12

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

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

Кажется уродливым увидеть что-то вроде int.TryParse(). Нет другой причины, по которой я делаю это иначе, чем стиль.

Ответ 13

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

Ответ 14

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

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

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

Ответ 15

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

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

Ответ 16

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

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

"В 64-разрядной версии - Microsoft действительно работает над 64-разрядной версией .NET Framework, но я уверен, что int не будет отображаться на 64-битной системе.

Причины:

1. В стандарте С# ECMA указано, что int 32 бит и длиной 64 бит.

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

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

Ответ 17

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

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

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

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

Ответ 18

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

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

Ответ 19

int и Int32 - то же самое. int является псевдонимом для Int32.

Ответ 20

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

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

Ответ 21

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

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

То же самое относится к любому типу ключевых слов.

Ответ 22

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

Ответ 23

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

Ответ 24

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

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

Ответ 25

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

Ответ 26

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

Ответ 27

В то время как я работал над проектом с 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

Ответ 28

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

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

Ответ 29

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

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

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

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

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

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

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

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

Ответ 30

В соответствии с 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