it-swarm-ru.tech

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

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

339
Graham

ECMA-334 : 2006 C # Language Specification (p18):

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

125
SpaceghostAli

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

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

265
James Sutherland

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

public enum MyEnum : Int32
{
    member1 = 0
}

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

public enum MyEnum : int
{
    member1 = 0
}

Пойди разберись.

84
raven

Я всегда использую системные типы - например, 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

48
Remi Despres-Smyth

int является ключевым словом C # и является однозначным.

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

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

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

13
spoulson

Размер байта для типов не слишком интересен, когда вам приходится иметь дело только с одним языком (и для кода, который вам не нужно напоминать себе о математических переполнениях). Интересной становится часть, когда вы соединяете один язык с другим, 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.

9
HidekiAI

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

8
Simon Steele

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

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

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

7
Greg D

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

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

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

6
Mark A. Nicolosi

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

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

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

  • Использование Int32 способствует тому, что разработчик осознает свой выбор типа. Насколько велика снова инт? Ах да, 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
}
5
unknown (yahoo)

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

5
Raithlin

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

4
yhdezalvarez

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

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

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

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

3
devstuff

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

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

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

3
Jack Bolding

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

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

3
Joel Coehoorn

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 # сохранят свое текущее отображение. "

3
Ray Hayes

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

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

2
David Basarab

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

2
Jesper Kihlberg

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

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

2
chrisb

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

1
Jim T

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

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

0
bovium

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

0
Schmuli

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

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

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

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

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

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

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

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

0
user11211

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

0
Stacker

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

0
Michael Meadows

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

Смотрите также мой ответ здесь на связанный вопрос.

0
Keith

Согласно 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
0
Selim

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

0
Chris Pietschmann