должен ли я использовать int или int32

<p>в c # <code>int</code> и <code>int32</code> - это одно и то же, но я несколько раз читал, что <code>int</code> предпочтительнее <code>int32</code> без объяснения причин. есть ли причина, и я должен заботиться?</p>

<p> <a href="https://www.ecma-international.org/publications/standards/ecma-334.htm">ecma-334</a> : 2006 <em> c # language specification </em> (p18):</p><blockquote> <p>каждый из предопределенных типов является сокращением для системного типа. например, ключевое слово <code>int</code> относится к структуре <code>system.int32</code>. в качестве стиля использование ключевого слова предпочтительнее использования полного имени типа системы.</p> </blockquote>

<p>два действительно являются синонимами; <code>int</code> будет немного более знакомым, <code>int32</code> делает 32-битность более понятной для тех, кто читает ваш код. я был бы склонен использовать <code>int</code> там, где мне просто нужно "целое число", <code>int32</code>, где важен размер (криптографический код, структуры), чтобы будущие сопровождающие знали, что при необходимости безопасно увеличивать <code>int</code>, но следует позаботиться об изменении <code>int32</code>s в так же.</p><p>результирующий код будет идентичен: разница только в удобочитаемости или внешнем виде кода.</p>

<p>они оба объявляют 32-битные целые числа, и, как заявили другие авторы, какой из них вы используете, это в основном вопрос синтаксического стиля. однако они не всегда ведут себя одинаково. например, компилятор c # не допустит этого:</p><pre><code>public enum myenum : int32 { member1 = 0 } </code></pre><p>но это позволит:</p><pre><code>public enum myenum : int { member1 = 0 } </code></pre><p>пойди разберись.</p>

<p>я всегда использую системные типы - например, int32 вместо int. я применил эту практику после прочтения <em> <a href="https://rads.stackoverflow.com/amzn/click/com/0735614229">прикладное программирование на .net framework</a> </em> - автор джеффри рихтер хорошо обосновывает использование полных имен типов , вот две вещи, которые застряли со мной:</p><ol> <li> <p>имена типов могут отличаться в разных языках .net. например, в c # <code>long</code> сопоставляется с system.int64, а в c++ с управляемыми расширениями <code>long</code> сопоставляется с int32. поскольку языки могут смешиваться и сочетаться при использовании .net, вы можете быть уверены, что использование явного имени класса всегда будет более понятным, независимо от предпочтительного языка читателя.</p> </li> <li> <p>многие методы каркаса имеют имена типов как часть своих имен методов:</p> <p><code>binaryreader br = new binaryreader( /* ... */ );</code></p> <p><code>float val = br.readsingle(); // ok, but it looks a little odd...</code></p> <p><code>single val = br.readsingle(); // ok, and is easier to read</code></p> </li> </ol>

<p>int является ключевым словом c # и является однозначным.</p><p>большую часть времени это не имеет значения, кроме двух вещей, которые идут против int32:</p><ul> <li>вы должны иметь "использование системы"; заявление. использование "int" не требует использования оператора.</li> <li>можно определить свой собственный класс с именем int32 (который был бы глупым и запутанным). int всегда означает int.</li> </ul>

<p>как уже говорилось, <code>int</code> = <code>int32</code>. для безопасности всегда используйте <code>int.minvalue</code>/<code>int.maxvalue</code> при реализации всего, что заботится о границах типа данных. предположим, что .net решил, что <code>int</code> теперь будет <code>int64</code>, ваш код будет меньше зависеть от границ.</p>

<p>размер байта для типов не слишком интересен, когда вам приходится иметь дело только с одним языком (и для кода, который вам не нужно напоминать себе о математических переполнениях). интересной становится часть, когда вы соединяете один язык с другим, c # с com-объектом и т.д., или вы выполняете какое-то переключение битов или маскирование, и вам нужно напомнить себе (и вашим коллегам по пересмотру кода) размера данных.</p><p>на практике я обычно использую int32 только для того, чтобы напомнить себе, какого они размера, потому что я пишу управляемый c++ (например, для соединения с c #), а также неуправляемый/нативный c++.</p><p>как вы, наверное, знаете, в c # он 64-битный, но в нативном c++ он заканчивается как 32-битный, или char является unicode/16-битным, в то время как в c++ он 8-битный. но откуда мы это знаем? ответ таков, потому что мы посмотрели его в руководстве и сказали, что так.</p><p>со временем и опытом вы начнете быть более добросовестным, когда будете писать коды для связи между c # и другими языками (некоторые читатели здесь думают: "почему бы вам?"), но я думаю, что это лучшая практика, потому что я не могу вспомнить, что я кодировал на прошлой неделе (или мне не нужно указывать в своем документе api, что "этот параметр является 32-разрядным целым числом").</p><p>в <a href="http://en.wikipedia.org/wiki/f\_sharp\_%28programming\_language%29">f #</a> (хотя я никогда не использовал его) они определяют <em> int </em>, <em> int32 </em> и <em> nativeint </em>. тот же самый вопрос должен подняться: "какой из них я использую?". как уже упоминали другие, в большинстве случаев это не должно иметь значения (должно быть прозрачным). но я бы, например, выбрал int32 и uint32, чтобы убрать неясности.</p><p>полагаю, это будет зависеть от того, какие приложения вы кодируете, кто его использует, какие практики кодирования вы и ваша команда выполняете, и т.д., чтобы обосновать, когда следует использовать int32.</p>

<p>нет разницы между <code>int</code> и <code>int32</code>, но так как <code>int</code> является ключевым словом языка, многие люди предпочитают его стилистически (так же, как с <code>string</code> vs <code>string</code>).</p>

<p>по моему опыту это было условностью. я не знаю каких-либо технических причин для использования int поверх int32, но это:</p><ol> <li>быстрее печатать.</li> <li>более знакомый типичному разработчику c #.</li> <li>другой цвет в подсветке синтаксиса visual studio по умолчанию.</li> </ol><p>я особенно люблю этот последний. :)</p>

<p>я всегда использую псевдонимы типа (int, string и т.д.) при определении переменной и реальное имя при доступе к статическому методу:</p><pre><code>int x, y; ... string.format ("{0}x{1}", x, y); </code></pre><p>просто кажется уродливым видеть что-то вроде int.tryparse (). нет другой причины, по которой я делаю это, кроме стиля.</p>

<p>хотя они (в основном) идентичны (см. ниже разницу [одна ошибка]), вам определенно следует позаботиться об этом и использовать int32.</p><ul> <li> <p>имя для 16-разрядного целого числа - int16. для 64-разрядного целого числа это int64, а для 32-разрядного целого числа интуитивно понятный выбор: int или int32?</p> </li> <li> <p>вопрос о размере переменной типа int16, int32 или int64 является самостоятельным, но вопрос о размере переменной типа int является совершенно правильным вопросом, и вопросы, какими бы тривиальными они ни были, отвлекают, приводят путанице, тратить время, мешать обсуждению и т. д. (факт, что этот вопрос существует, подтверждает это).</p> </li> <li> <p>использование int32 способствует тому, что разработчик осознает свой выбор типа. насколько велика снова инт? ах да, 32. вероятность того, что размер шрифта будет фактически учтен, больше, когда размер включен в имя. использование int32 также способствует знанию других вариантов. когда люди не вынуждены по крайней мере признавать, что есть альтернативы, для int становится слишком легко стать "целочисленным типом".</p> </li> <li> <p>класс в рамках, предназначенный для взаимодействия с 32-разрядными целыми числами, называется int32. еще раз, что: более интуитивно понятно, менее запутанно, отсутствует (ненужный) перевод (не перевод в системе, а в сознании разработчика) и т.д. <code>int lmax = int32.maxvalue</code> или <code>int32 lmax = int32.maxvalue</code>?</p> </li> <li> <p>int не является ключевым словом во всех языках .net.</p> </li> <li> <p>хотя есть аргументы, почему он вряд ли когда-либо изменится, int не всегда может быть int32.</p> </li> </ul><p>недостатками являются два дополнительных символа для ввода и [ошибка].</p><p>это не скомпилируется</p><pre><code>public enum myenum : int32 { aenum = 0 } </code></pre><p>но это будет:</p><pre><code>public enum myenum : int { aenum = 0 } </code></pre>

<p>я знаю, что лучше всего использовать int, а весь код msdn использует int. однако нет никаких причин, кроме стандартизации и последовательности, насколько я знаю.</p>

<p>тебя это не должно волновать. вы должны использовать <code>int</code> большую часть времени. это поможет в будущем перенести вашу программу на более широкую архитектуру (в настоящее время <code>int</code> является псевдонимом <code>system.int32</code>, но это может измениться). только когда битовая ширина переменной имеет значение (например, для управления макетом в памяти <code>struct</code>), вы должны использовать <code>int32</code> и другие (со связанным "<code>using system;</code>").</p>

<p>я бы порекомендовал использовать microsoft <a href="http://code.msdn.microsoft.com/sourceanalysis">stylecop</a> .</p><p>это как <a href="http://en.wikipedia.org/wiki/fxcop">fxcop</a> , но для вопросов, связанных со стилем. конфигурация по умолчанию соответствует внутренним руководствам по стилю microsoft, но ее можно настроить для вашего проекта.</p><p>это может занять некоторое время, чтобы привыкнуть, но это определенно делает ваш код приятнее.</p><p>вы можете включить его в процесс сборки, чтобы автоматически проверять наличие нарушений.</p>

<p>int такой же, как system.int32, и при компиляции он превратится в то же самое в <a href="http://en.wikipedia.org/wiki/common\_intermediate\_language">cil</a> .</p><p>мы используем int по соглашению в c #, так как c # хочет выглядеть как c и c++ (и java), и это то, что мы используем там ...</p><p>кстати, я в конечном итоге использую system.int32 при объявлении импорта различных функций windows api. я не уверен, является ли это определенным соглашением или нет, но это напоминает мне, что я иду на внешнюю dll ...</p>

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

<p>int является ярлыком языка c # для system.int32</p><p>хотя это действительно означает, что microsoft может изменить это отображение, в посте обсуждений fogcreek говорится <a href="http://discuss.fogcreek.com/dotnetquestions/default.asp?cmd=show&ixpost=1988">[источник]</a> </p><p><em> "что касается 64-битной проблемы - microsoft действительно работает над 64-битной версией .net framework, но я почти уверен, что int не будет отображаться на 64-битную в этой системе. </em></p><p><em> причины: </em></p><p><em> 1. стандарт c # ecma, в частности, гласит, что int 32-битный, а long 64-битный. </em></p><p><em> 2. microsoft ввела дополнительные свойства и методы в framework версии 1.1, которые возвращают длинные значения вместо значений int, такие как array.getlonglength в дополнение к array.getlength. </em></p><p><em> так что я думаю, что можно с уверенностью сказать, что все встроенные типы c # сохранят свое текущее отображение. "</em></p>

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

<p><code>int</code> и <code>int32</code> одинаковы. <code>int</code> является псевдонимом для <code>int32</code>.</p>

<p>на практике это не имеет значения, и со временем вы примете собственное соглашение. я склонен использовать ключевое слово при назначении типа и версию класса при использовании статических методов и тому подобное:</p><p>int total = int32.parse ("1009");</p>

<p><code>int</code> - это псевдоним для <code>system.int32</code>, как определено в этой таблице: <a href="http://msdn.microsoft.com/en-us/library/ya5y69ds.aspx">таблица встроенных типов (c # reference)</a> </p>

<p>использование int или int32 - это то же самое, что просто упрощение кода для читателя.</p><p>использовать nullable вариант int? или int32? при работе с базами данных на полях, содержащих ноль. это избавит вас от многих проблем во время выполнения.</p>

<p>некоторое время назад я работал над проектом с microsoft, когда нас посетил кто-то из команды microsoft .net clr. этот человек закодировал примеры, и когда он определил свои переменные, он использовал "int32" против "int" и "string" против "string".</p><p>я вспомнил, как видел этот стиль в другом примере кода от microsoft. итак, я провел небольшое исследование и обнаружил, что все говорят, что нет разницы между "int32" и "int", за исключением раскраски синтаксиса. на самом деле, я нашел много материала, предлагающего вам использовать "int32", чтобы сделать ваш код более читабельным. итак, я принял стиль.</p><p>на днях я нашел разницу! компилятор не позволяет вам набирать enum с помощью "int32", но он делает, когда вы используете "int". не спрашивайте меня почему, потому что я еще не знаю.</p><p>пример:</p><pre><code>public enum myenum : int32 { aenum = 0 } </code></pre><p>это работает.</p><pre><code>public enum myenum : int { aenum = 0 } </code></pre><p>взято из: <a href="http://geekswithblogs.net/caustin/archive/2005/08/05/49267.aspx">int32 нотация против int</a> </p>

<p>некоторые компиляторы имеют разные размеры для int на разных платформах (не специфично для c #)</p><p>некоторые стандарты кодирования (misra c) требуют, чтобы все используемые типы имели заданный размер (то есть int32, а не int).</p><p>также полезно указывать префиксы для переменных разных типов (например, b для 8-битного байта, w для 16-битного word и l для 32-битного word => int32 lmyvariable)</p><p>вы должны быть осторожны, потому что это делает ваш код более переносимым и более легким в обслуживании.</p><p>переносимость может быть неприменима к c #, если вы всегда собираетесь использовать c # и спецификация c # никогда не изменится в этом отношении.</p><p>поддерживаемое ihmo всегда будет применимо, потому что человек, обслуживающий ваш код, может не знать об этой конкретной спецификации c # и пропустить ошибку, если время от времени int становится больше 2147483647.</p><p>в простом цикле for, который подсчитывает, например, месяцы года, вас это не волнует, но когда вы используете переменную в контексте, где она может перетекать, вам следует позаботиться.</p><p>вам также следует позаботиться о том, чтобы выполнять над ним побитовые операции.</p>

<p>вы не должны заботиться о большинстве языков программирования, если вам не нужно писать очень специфические математические функции или код, оптимизированный для одной конкретной архитектуры ... просто убедитесь, что вам достаточно размера типа (используйте что-то большее, чем int, если вы <strong>знаю</strong> вам понадобится более 32 бит, например)</p>

<p>использование типа <code>int32</code> требует ссылки пространства имен на <code>system</code> или полной квалификации (<code>system.int32</code>). я склоняюсь к <code>int</code>, потому что он не требует импорта пространства имен, поэтому в некоторых случаях снижает вероятность конфликта пространства имен. при компиляции в il нет никакой разницы между ними.</p>

<p>это не важно int - это ключевое слово языка, а int32 - фактический тип системы.</p><p>смотрите также мой <a href="https://stackoverflow.com/questions/9734/cnet-case-insensitive-string#9747">ответ здесь</a> на связанный вопрос.</p>

<p>согласно immediate window в visual studio 2012 int32 - это int, int64 - это длинный. вот вывод:</p><pre><code>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 </code></pre>

<p>также рассмотрим int16. если вам нужно хранить целое число в памяти в вашем приложении и вас беспокоит объем используемой памяти, вы можете использовать int16, поскольку он использует меньше памяти и имеет меньший минимальный/максимальный диапазон, чем int32 (то есть, что такое int .)</p>