365

在 C# 中，int并且Int32是相同的东西，但我已经阅读了很多次，但int没有Int32给出任何理由。有什么原因吗，我应该关心吗？

4

32 回答 32

282

两者确实是同义词；int看起来会更熟悉一些，Int32使 32 位对阅读您的代码的人来说更加明确。我倾向于int在只需要“整数”的地方使用，Int32其中大小很重要（加密代码、结构），因此未来的维护者会知道如果合适的话放大 s 是安全的int，但应该注意Int32以同样的方式更改 s 。

结果代码将是相同的：差异纯粹是可读性或代码外观之一。

于 2008-09-15T12:55:54.907 回答
144

ECMA-334 :2006 C# 语言规范(p18):

每个预定义类型都是系统提供类型的简写。例如，关键字int指的是 struct System.Int32。作为风格问题，使用关键字优于使用完整的系统类型名称。

于 2008-09-15T13:14:26.750 回答
89

它们都声明了 32 位整数，并且正如其他海报所述，您使用哪一个主要是句法风格问题。但是，它们的行为方式并不总是相同。例如，C# 编译器不允许这样做：

public enum MyEnum : Int32
{
    member1 = 0
}

但它会允许这样做：

public enum MyEnum : int
{
    member1 = 0
}

去搞清楚。

于 2008-09-15T13:21:39.260 回答
51

我总是使用系统类型 - 例如，Int32而不是int. 在阅读了Applied .NET Framework Programming之后，我采用了这种做法——作者 Jeffrey Richter 为使用完整类型名称提供了一个很好的案例。以下是困扰我的两点：

  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
于 2008-09-15T15:18:28.950 回答
21

int 是一个 C# 关键字并且是明确的。

大多数时候它并不重要，但有两件事与 Int32 背道而驰：

  • 你需要有一个“使用系统”；陈述。使用“int”不需要 using 语句。
  • 可以定义您自己的名为 Int32 的类（这将是愚蠢和混乱的）。int 总是意味着 int。
于 2008-09-15T13:03:49.757 回答
12

如前所述，int= Int32。为了安全起见，在实现任何关心数据类型边界的事情时，请务必始终使用int.MinValue/ 。int.MaxValue假设 .NET 决定int现在是Int64，您的代码将较少依赖边界。

于 2008-09-15T12:59:03.073 回答
11

当您只需要处理一种语言时（并且对于您不必提醒自己有关数学溢出的代码），类型的字节大小并不太有趣。变得有趣的部分是当您在一种语言与另一种语言、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# 之间的桥接/InterOp'ing，本机类型匹配，所以不用担心；我很少需要在 F# 中显式定义类型（如果不使用类型推断，这几乎是一种罪过）。在 Rust 中，他们完全消除了这种歧义，你必须使用i32vs u32; 总而言之，减少歧义有助于减少错误。

于 2008-09-15T14:00:32.303 回答
8

int和之间没有区别Int32，但是作为int一个语言关键字，许多人在风格上更喜欢它（就像stringvs一样String）。

于 2008-09-15T12:56:19.850 回答
7

以我的经验，这是一个约定俗成的事情。我不知道在 Int32 上使用 int 的任何技术原因，但它是：

  1. 打字更快。
  2. 对典型的 C# 开发人员来说更熟悉。
  3. 默认 Visual Studio 语法突出显示中的不同颜色。

我特别喜欢最后一个。:)

于 2008-09-15T12:57:37.507 回答
7

我在定义变量时总是使用别名类型（int、string 等），在访问静态方法时使用真实名称：

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

看到像 int.TryParse() 这样的东西似乎很难看。除了风格，我这样做没有其他原因。

于 2008-09-28T20:32:06.337 回答
6

尽管它们（大部分）是相同的（见下文中的一个 [bug] 差异），但您绝对应该关心并且应该使用 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。

缺点是要输入两个额外的字符和 [bug]。

这不会编译

public enum MyEnum : Int32
{
    AEnum = 0
}

但这将：

public enum MyEnum : int
{
    AEnum = 0
}
于 2008-09-15T20:32:18.320 回答
5

我知道最好的做法是使用 int，所有 MSDN 代码都使用 int。但是，据我所知，除了标准化和一致性之外，没有其他原因。

于 2008-09-15T12:55:27.903 回答
4

你不应该在乎。您应该int大部分时间使用。它将有助于将来将您的程序移植到更广泛的体系结构（目前int是一个别名，System.Int32但可能会改变）。只有当变量的位宽很重要时（例如：控制 a 内存中的布局struct），您才应该使用int32和其他（带有关联的“ using System;”）。

于 2008-09-15T15:38:43.533 回答
3

int 与 System.Int32 相同，编译后它将在CIL中变成相同的东西。

我们在 C# 中按照惯例使用 int，因为 C# 希望看起来像 C 和 C++（以及 Java），而这正是我们在那里使用的......

顺便说一句，在声明各种 Windows API 函数的导入时，我确实最终使用了 System.Int32。我不确定这是否是一个已定义的约定，但它提醒我我要去一个外部 DLL ......

于 2008-09-15T13:00:26.003 回答
3

曾几何时，int 数据类型与编译器所针对的机器的寄存器大小挂钩。因此，例如，16 位系统的编译器将使用 16 位整数。

然而，幸运的是，我们再也看不到 16 位了，当 64 位开始流行时，人们更关心使其与旧软件兼容，而 32 位已经存在了很长时间，以至于对于大多数编译器来说，int只是假设为 32 位。

于 2008-09-15T13:05:31.187 回答
3

int 是 System.Int32 的 C# 语言的快捷方式

虽然这确实意味着微软可以改变这种映射，但在 FogCreek 的讨论中发表的一篇文章指出[来源]

“关于 64 位问题——微软确实在开发 .NET Framework 的 64 位版本，但我很确定 int 不会映射到该系统上的 64 位。

原因：

1. C# ECMA 标准明确规定 int 为 32 位，long 为 64 位。

2. Microsoft 在 Framework 1.1 版本中引入了额外的属性和方法，这些属性和方法返回 long 值而不是 int 值，例如除了 Array.GetLength 之外的 Array.GetLongLength。

所以我认为可以肯定地说所有内置的 C# 类型都将保留它们当前的映射。”

于 2008-09-15T13:09:49.897 回答
3

我建议使用微软的StyleCop。

它类似于FxCop，但用于与样式相关的问题。默认配置与 Microsoft 的内部样式指南相匹配，但可以针对您的项目进行自定义。

可能需要一点时间来适应，但它肯定会让你的代码更好。

您可以将其包含在构建过​​程中以自动检查违规行为。

于 2008-12-15T03:41:49.927 回答
2

你不应该在意。如果大小是一个问题，我会使用字节，短，整数，然后长。使用大于 int32 的 int 的唯一原因是您需要大于 2147483647 或小于 -2147483648 的数字。

除此之外，我不在乎，还有很多其他的项目需要关注。

于 2008-09-15T12:53:15.630 回答
2

int和Int32是一样的。int是 的别名Int32。

于 2008-09-15T12:56:24.687 回答
2

这在实践中没有任何区别，并且随着时间的推移，您将采用自己的约定。我倾向于在分配类型时使用关键字，在使用静态方法时使用类版本等：

int total = Int32.Parse("1009");
于 2008-09-15T13:01:52.443 回答
1

如果 Microsoft 将整数的默认实现更改为某个新的版本（我们称之为 Int32b），我会使用 int。

然后，Microsoft 可以将 int 别名更改为 Int32b，我不必更改我的任何代码即可利用他们新的（希望改进的）整数实现。

任何类型关键字也是如此。

于 2008-09-15T13:37:57.600 回答
1

int是 的别名System.Int32，如下表中所定义： 内置类型表（C# 参考）

于 2008-09-15T14:02:03.343 回答
0

你不应该关心大多数编程语言，除非你需要编写非常具体的数学函数，或者为一种特定架构优化的代码......只要确保类型的大小对你来说足够（如果你使用比 Int 更大的东西例如，知道您需要超过 32 位）

于 2008-09-15T13:02:24.720 回答
0

没关系。int 是语言关键字，而 Int32 是它的实际系统类型。

另请参阅我对相关问题的回答。

于 2008-09-15T13:04:58.410 回答
0

使用该Int32类型需要对 的命名空间引用System或完全限定 ( System.Int32)。我倾向于int，因为它不需要命名空间导入，因此在某些情况下减少了命名空间冲突的机会。当编译成 IL 时，两者没有区别。

于 2008-09-15T14:26:43.503 回答
0

还要考虑 Int16。如果您需要在应用程序的内存中存储一​​个整数并且您担心使用的内存量，那么您可以使用 Int16，因为它使用更少的内存并且具有比 Int32 更小的最小/最大范围（这就是 int 是.)

于 2008-09-15T14:36:52.510 回答
0

不久前，当我们受到 Microsoft .NET CLR 产品团队的某个人的访问时，我正在与 Microsoft 合作一个项目。这个人编写了示例，当他定义他的变量时，他使用了“Int32”与“int”和“String”与“string”。

我记得在 Microsoft 的其他示例代码中看到过这种风格。所以，我做了一些研究，发现每个人都说“Int32”和“int”除了语法着色之外没有区别。事实上，我发现很多材料建议您使用“Int32”来使您的代码更具可读性。所以，我采用了这种风格。

前几天我确实发现了不同之处！编译器不允许您使用“Int32”键入枚举，但是当您使用“int”时它可以。不要问我为什么，因为我还不知道。

例子：

public  enum MyEnum : Int32
{
    AEnum = 0
}

这行得通。

public enum MyEnum : int
{
    AEnum = 0
}

取自：Int32 表示法与 int

于 2008-09-15T16:17:12.490 回答
0

Int 或 Int32 的使用是相同的 Int 只是为读者简化代码的糖。

使用 Nullable 变体 Int? 还是 Int32？当您在包含 null 的字段上使用数据库时。这将使您免于许多运行时问题。

于 2008-09-16T05:48:51.820 回答
0

一些编译器在不同平台上对 int 有不同的大小（不是 C# 特定的）

一些编码标准 (MISRA C) 要求使用的所有类型都指定大小（即 Int32 而不是 int）。

为不同类型的变量指定前缀也是很好的（例如，b 代表 8 位字节，w 代表 16 位字，l 代表 32 位长字 => Int32 lMyVariable）

您应该关心，因为它使您的代码更便携和更易于维护。

如果您总是要使用 C#，那么 Portable 可能不适用于 C#，并且 C# 规范在这方面永远不会改变。

可维护的 ihmo 将始终适用，因为维护您的代码的人可能不知道这个特定的 C# 规范，并且在 int 偶尔超过 2147483647 时会错过一个错误。

在一个简单的 for 循环中，例如计算一年中的几个月，您不会关心，但是当您在可能溢出的上下文中使用变量时，您应该关心。

您还应该关心是否要对其进行按位操作。

于 2008-09-16T06:12:52.433 回答
0

根据 Visual Studio 2012 中的即时窗口 Int32 是 int，Int64 是 long。这是输出：

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
于 2013-07-03T12:44:53.683 回答
0

现在是 2021 年，我已经阅读了所有答案。大多数人说它基本上是一样的（它是一个别名），或者，它取决于“你喜欢什么”，或者“按照惯例使用 int ...”没有答案让你清楚何时、何地以及为什么使用Int32over int。这就是我在这里的原因。

98% 的情况下，您都可以侥幸逃脱int，这完全没问题。剩下的 2% 是什么？

带有记录的 IO（结构、本机类型、组织和压缩）。有人说无用的应用程序可以读取和操作数据，但实际上不能将新数据写入定义的存储。但是为了不重新发明轮子，在某些时候，那些处理旧数据的人必须检索有关如何阅读它们的文档。很可能它们是从along始终是 32 位整数的时代编译的。

以前发生过，有些人记不住 adb是一个字节，adw是一个字，add是一个双字，但那是多少位呢？这很可能会在一个平台上再次发生...... C# 43.0（256-bits未来的）男孩从未听说过“按照惯例，使用 int 而不是 Int32 ”。这就是Int32重要的 2% int。MSDN 说今天推荐使用int无关紧要，它通常适用于当前的 C# 版本，但在未来的 MSDN 页面中，可能会在 2028 年或 2034 年被丢弃？WORD今天拥有和遇到的人越来越少DWORD，然而，在二十年前，它们很常见。同样的事情也会发生int，在处理精确固定长度数据的情况下。

在内存中，a ushort( UInt16) 可以是a Decimal，只要它的小数部分为null，可以是正数或null，并且不超过65535。但是在文件中，它必须是a short，16 位长。当您阅读有关另一个时代的文件结构的文档（在源代码中）时，您会意识到有 3545 条记录定义，其中一些嵌套在其他记录中，每条记录都有几个到数百个不同类型的字段。

在 2028 年的某个地方，一个男孩认为他可以通过 Ctrl-H-ing int to Int32、仅全字并匹配大小写来逃脱……整个解决方案中的约 67000 处变化。点击运行，仍然获得 CTD。拍拍拍拍。想想int你应该改成Int32哪些，你应该改成哪些var。还值得指出的Pointers是，当您处理 TB 级数据时（在某个云上拥有整个星球的虚拟表示，按需下载并渲染到用户屏幕）时，它很有用。在大约 1% 的情况下，指针非常快，因为需要实时计算大量数据，您必须使用不安全的代码进行交易。同样，它要提出一个实际有用的应用程序，而不是花哨并浪费时间移植到托管。所以，要小心，IntPtr已经是 32 位还是 64 位了？您可以在不关心您读取/跳过多少字节的情况下摆脱您的代码吗？或者只是去(Int32*) int32Ptr = (Int32*) int64Ptr;...

一个更实际的例子是一个包含数据处理及其各自命令（源代码中的方法）的文件，例如内部分支（如果测试失败，则有条件继续或跳转到）：

IfTest文件中的记录说：如果 value 等于 someConstant，则跳转到address. whereaddress是一个16-bits整数，表示文件内的相对指针（您可以返回文件开头最多 32768 个字节，或向下最多 32767 个字节）。但是 10 年后，平台可以处理更大的文件和更大的数据，现在你有了32-bits相对地址。您在源代码中的方法已命名IfTestMethod(...)，现在您将如何命名新方法？IfTestMethodInt()还是IfTestMethod32()？您还会重命名旧方法吗IfTestMethodShort()？IfTestMethod16()然后十年后，您会得到一个具有长（Int64）相对地址的新命令......大约 10 年后的 128 位命令呢？保持一致！原则很好，但有时逻辑更好。

问题不在于我或您今天编写代码，而且对我们来说似乎没问题。它代替了一个人试图理解我们在10 或 20 年后写的东西，想出一个有效的更新代码需要多少时间（= 金钱）？明确或写多余的评论实际上会节省时间。你更喜欢哪一个？Int32 val;或var val; // 32-bits。

此外，使用来自其他平台的外部数据或编译指令是一个概念（今天涉及 Interop、COM、PInvoke ......）这是一个我们无法摆脱的概念，无论哪个时代，因为更新（重新格式化）需要时间数据（例如通过序列化）将 DLL 升级到托管代码也需要时间。我们花了一些时间把汇编程序抛在脑后，转而使用全 C。我们正在花时间从 32 位数据转移到 64 位，但是，我们仍然需要关心 8 位和 16 位。未来的下一步是什么？从 128 位移动到 256 或直接移动到 1024？不要假设一个明确的关键字对于 20 年后阅读您文档的人来说仍然是明确的（并且文档通常包含错误，主要是因为复制/粘贴）。

所以这里是：今天在哪里使用 Int32 而不是 int ？

当您正在生成对数据大小敏感的代码（IO、网络、跨平台数据......）时，并且在未来的某个时候- 可能是几十年后 - 必须有人理解和移植您的代码。关键原因在于时代。1000行代码，可以用int，100000行，不行了。这是一项只有少数人必须做的罕见任务，而且地狱是的，他们有斗争，如果只有一些更明确一点，而不是依赖“按照惯例”或“它在 IDE 中看起来很漂亮，Int32 太丑了”或者“它们是一样的，别费心了，写那两个数字并按住shift键是浪费时间”，int 是明确的”，或者“那些不喜欢 int 的人只是 VB 的粉丝 - 去学习 C# 你是菜鸟”（是的，这就是这里一些评论的潜在含义）

不要将我所写的内容视为笼统的看法，也不要试图在所有情况下推广 Int32。我清楚地说明了具体情况（在我看来，这在其他答案中并不清楚），以提倡少数人因写作花哨而被主管指责，Int32同时同一位主管不理解需要什么这么长时间将 C DLL 重写为 C#。这是一个边缘案例，但至少对于那些阅读，“Int32”在其生命中至少有一个目的。

可以通过将问题反过来来进一步讨论这一点：为什么不干脆去掉Int32，Int64以及未来 C# 规范中的所有其他变体？那意味着什么？

于 2021-09-14T09:37:02.337 回答
-1

字节 int 可以容纳取决于您编译它的目的，因此当您为 32 位处理器编译程序时，它可以容纳从 2^32/2 到 -2^32/2+1 的数字，而编译为 64 位它可以保持从 2^64/2 到 -2^64/2+1。int32 将始终保存 2^32 个值。

编辑：忽略我的回答，我没有看到 C#。我的答案是针对 C 和 C++ 的。我从来没有用过C#

于 2008-09-15T13:01:19.013 回答