Почему .NET использует int вместо uint в определенных классах?

Ответ 1

UInt32 не совместимый с CLS, поэтому он может быть недоступен на всех языках, ориентированных на Common Language Specification. Int32 является CLS-совместимым и, следовательно, гарантированно существует на всех языках.

Ответ 2

int, в c, определенно определяется как целочисленный тип процессора по умолчанию и поэтому считается самым быстрым для общих числовых операций.

Ответ 3

Другая причина использования int:

Скажем, у вас есть for -loop вот так:

for (i = someList.Count - 1; i >= 0; i--) {
  // Stuff
}

очевидно, если бы someList.Count был нулем, а unsigned, у вас возникла бы проблема.

Ответ 4

Если число действительно неподписанным по своему внутреннему характеру, я объявляю его неподписанным int. Однако, если я просто использую число (пока) в положительном диапазоне, то я бы назвал его int.

Основные причины:

• Он избегает необходимости делать много типов, поскольку большинство методов/функций записывается для принятия int, а не без знака int.
• Он устраняет возможные предупреждения об усечении.
• Вы всегда можете пожелать, чтобы вы могли присвоить отрицательное значение числу, которое вы изначально считали всегда положительным.

Только несколько быстрых мыслей, которые приходят на ум.

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

Ответ 5

UInt32 не совместим с CLS. http://msdn.microsoft.com/en-us/library/system.uint32.aspx

Я думаю, что на протяжении многих лет люди пришли к выводам, что использование неподписанных типов на самом деле не дает такой выгоды. Лучший вопрос заключается в том, что вы получите, сделав Count UInt32?

Ответ 6

Неподписанные типы ведут себя как целые числа, если сумма или произведение знака с подписью и без знака будет иметь тип подписанного типа, достаточно большой для хранения любого операнда, и если разница между двумя значениями без знака является значащим значением, достаточно большим, чтобы удерживать любые результат. Таким образом, код, который значительно использует UInt32, часто должен вычислять значения как Int64. Операции со знаком целочисленных типов могут не работать как целые числа, когда операнды слишком велики, но они будут вести себя разумно, когда операнды малы. Операции над непродвинутыми аргументами неподписанных типов создают проблемы, даже если операнды малы. Например, при UInt32 x; неравенство x-1 < x не будет выполнено для x==0, если тип результата UInt32, а неравенство x<=0 || x-1>=0 будет терпеть неудачу при больших значениях x, если тип результата равен Int32. Только если операция выполняется по типу Int64, могут поддерживаться оба неравенства.

Хотя иногда полезно определять поведение беззнакового типа способами, которые отличаются от арифметики целого числа, значения, которые представляют такие вещи, как counts, обычно должны использовать типы, которые будут вести себя как целые числа - что-то неподписанные типы обычно не делают если они меньше основного целочисленного типа.

Ответ 7

Некоторые вещи используют int, чтобы они могли возвращать -1, как если бы это было "null" или что-то в этом роде. Как ComboBox вернет -1 для него SelectedIndex, если у него нет выбранного элемента.

Ответ 8

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