C# sizeof 关键字的使用

总目录

---

前言

在 C# 开发中，了解变量或数据类型占用的内存大小对于优化性能和内存使用非常重要。sizeof 关键字正是为此而生，它允许我们在编译时获取某个类型或变量的内存大小。今天，我们就来深入探讨一下 sizeof 关键字的使用方法、适用场景以及一些需要注意的地方。

---

一、sizeof 是什么？

1. 基本概念

• 在C#中，sizeof 是一个用于获取数据类型或结构体大小的操作符。它返回的是该类型实例在内存中所占的字节数。
• 需要注意 ：sizeof 只能应用于非托管代码中的值类型（包括内置值类型和用户定义的结构体），并且不能直接作用于引用类型。此外，在某些情况下，使用 sizeof 需要在不安全上下文中进行。

2. 核心作用

sizeof用于获取非托管类型或内置值类型在内存中的字节大小。其特点包括：

• 编译时计算 ：结果在编译阶段确定，而非运行时动态计算。
  • sizeof 的结果是在编译时确定的，而不是运行时。这意味着它不会引入额外的运行时开销。
  • sizeof 关键字在编译时计算类型大小，并返回一个整数值表示该类型的字节大小。
• 仅限值类型 ：适用于基本类型（如int、double、char）和用户定义的结构体（struct）。
• 托管内存视角：返回公共语言运行时（CLR）分配的内存大小，可能与实际物理内存布局存在差异。
• 平台差异：需要注意的是，sizeof 返回的值可能因运行代码的操作系统架构（32 位或 64 位）而有所不同。在 32 位系统中，int 通常占用 4 个字节；而在 64 位系统中，int 通常占用 8 个字节。

3. 使用限制

场景	是否支持	示例
引用类型（如类）	❌	sizeof(string)
动态数组长度	❌	sizeof(byte[])
运行时类型	❌	sizeof(obj.GetType())

说明：

• sizeof 主要用于值类型（如 int、double、struct 等），因为它们的大小是固定的。
• sizeof 不能用于引用类型（如 string、class 等），因为引用类型的大小取决于其内容和内存布局。对于引用类型，可以使用 System.Runtime.InteropServices.Marshal.SizeOf 方法来获取其大小，但这需要更多的上下文信息。

4. 典型应用场景

• 内存管理：在处理非托管资源时，了解数据类型的大小有助于更有效地分配和释放内存。
• 性能优化：在某些高性能应用场景中，了解数据类型的大小可以帮助优化数据结构的设计。
• 互操作性：当与非托管代码进行交互时，了解数据类型的大小可以确保正确的内存布局和数据传输。

二、sizeof 的基本用法

1. 语法与示例

int size = sizeof(Type);

• 参数 ：Type - 要查询大小的数据类型。
  • type：可以是任何值类型，例如 int, float, double，也可以是一个用户定义的结构体。
• 返回值：该类型在内存中占用的字节数。

2. 获取基本数据类型的大小

sizeof 可以直接用于获取基本数据类型（如 int、double、char 等）的大小。

Console.WriteLine(sizeof(int));       // 输出：4
Console.WriteLine(sizeof(double));    // 输出：8
Console.WriteLine(sizeof(char));      // 输出：2
Console.WriteLine(sizeof(bool));      // 输出：1

在这个例子中，sizeof 返回了不同基本数据类型占用的字节数。

using System;

class Program
{
    unsafe static void Main()
    {
        Console.WriteLine($"Size of byte: {sizeof(byte)}"); // 输出: 1
        Console.WriteLine($"Size of int: {sizeof(int)}");   // 输出: 4
        Console.WriteLine($"Size of long: {sizeof(long)}"); // 输出: 8
        Console.WriteLine($"Size of float: {sizeof(float)}"); // 输出: 4
        Console.WriteLine($"Size of double: {sizeof(double)}"); // 输出: 8
        Console.WriteLine($"Size of char: {sizeof(char)}"); // 输出: 2 (Unicode)
    }
}

3. 获取自定义结构体的大小

sizeof 也可以用于获取自定义结构体的大小。结构体的大小取决于其成员变量的大小和内存对齐方式。

public struct Point
{
    public int X;
    public int Y;
}

Console.WriteLine(sizeof(Point));     // 输出：8

在这个例子中，Point 结构体包含两个 int 类型的成员变量，每个 int 占用 4 字节，因此 Point 的大小为 8 字节。

4. 获取枚举类型大小

sizeof 也可以用于获取枚举类型的大小，其大小取决于基础数据类型。

using System;

enum Color : byte
{
    Red,
    Green,
    Blue
}

class Program
{
    unsafe static void Main()
    {
        Console.WriteLine($"Size of Color enum: {sizeof(Color)}"); // 输出: 1
    }
}

在这个例子中，我们定义了一个基于 byte 类型的枚举 Color，因此它的大小为 1 字节。

5. 获取指针大小

在不安全上下文中，sizeof 也可以用于获取指针的大小。指针的大小取决于平台架构（32位或64位）。

using System;

unsafe class Program
{
    static void Main()
    {
        Console.WriteLine($"Size of IntPtr: {sizeof(IntPtr)}"); // 在32位系统上输出: 4, 在64位系统上输出: 8
    }
}

在这个例子中，我们使用 sizeof 获取了 IntPtr 的大小，这取决于当前运行环境是32位还是64位。

unsafe 
{
    int* ptr;
    Console.WriteLine(sizeof(int*)); // 32位系统输出4，64位输出8
}

指针大小与系统架构相关。

三、注意事项

尽管 sizeof 关键字非常有用，但在实际应用中也有一些需要注意的地方：

1. 仅限于值类型

sizeof 只能用于值类型，不能直接用于引用类型（如 string, object 等）。对于引用类型，它们的实际大小取决于对象的内容和托管堆的管理方式。

2. 字段对齐和填充

在计算结构体大小时，字段对齐和填充会影响最终结果。为了提高内存访问效率，编译器会自动对字段进行对齐处理，这可能导致额外的填充字节。

1）字段对齐规则

• 默认情况下，结构体中的字段按其自然对齐边界对齐。
• 对齐边界通常是字段大小的倍数（例如，int 需要 4 字节对齐）。
• 如果字段大小小于 4 字节，则按照 4 字节对齐。

2） 内存对齐与填充示例

在某些情况下，结构体的实际大小可能会因为内存对齐而大于其成员变量的总大小。这是因为编译器会在结构体的成员之间插入填充字节，以确保每个成员的地址对齐。

public struct Example
{
    public byte A;
    public int B;
}

Console.WriteLine(sizeof(Example));   // 输出：8

在这个例子中，Example 结构体包含一个 byte 类型的成员 A 和一个 int 类型的成员 B。理论上，它们的总大小应该是 5 字节（1 + 4），但由于内存对齐，编译器会在 A 和 B 之间插入填充字节（A与B对齐，由1➡4），使得结构体的大小为 8 字节。

public struct MyStruct 
{
    public char c;  // 2字节
    public int i;   // 4字节
    public char c2; // 2字节
}

unsafe 
{
    Console.WriteLine(sizeof(MyStruct)); // 输出：12（而非8）
}

原因 ：CLR会按最大成员类型（int的4字节）对齐内存，导致填充空位。

3）自定义内存布局

可以通过 [StructLayout] 属性手动控制字段对齐方式：

• LayoutKind.Sequential：保留声明顺序（默认）
• LayoutKind.Auto：允许CLR优化布局

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct PackedStruct
{
    public byte a;   // 1 byte
    public int b;    // 4 bytes
    public short c;  // 2 bytes
}

class Program
{
    unsafe static void Main()
    {
        Console.WriteLine($"Size of PackedStruct: {sizeof(PackedStruct)}"); // 输出: 7
    }
}

在这个例子中，通过设置 Pack = 1，我们禁用了默认的字段对齐，使得结构体的实际大小为 7 字节。

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Auto)]
struct PackedStruct
{
    public byte a;   // 1 byte
    public int b;    // 4 bytes
    public short c;  // 2 bytes
}

class Program
{
    unsafe static void Main()
    {
        Console.WriteLine($"Size of PackedStruct: {sizeof(PackedStruct)}"); // 输出: 7
    }
}

在这个例子中，通过设置 LayoutKind.Auto，允许CLR优化布局，使得结构体的实际大小为 8 字节。

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Auto)]
struct PackedStruct
{
    public byte a;   // 1 byte
    public int b;    // 4 bytes
    public short c;  // 2 bytes
}

class Program
{
    unsafe static void Main()
    {
        Console.WriteLine($"Size of PackedStruct: {sizeof(PackedStruct)}"); // 输出: 12
    }
}

在这个例子中，使用默认布局，使得结构体的实际大小为 12 字节。

3. 不安全上下文

sizeof 关键字只能在不安全上下文中使用。需要在方法或块前加上 unsafe 关键字，并确保项目启用了不安全代码的支持。

1） 启用不安全代码支持

• 方式1：在 Visual Studio 中：

  • 右键点击项目 -> 属性 -> 构建 -> 允许不安全代码。

• 方式2：在 .csproj 文件中添加以下内容：

  <PropertyGroup>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>

  

2）代码中使用不安全上下文

using System;

unsafe class Program
{
    static void Main()
    {
        Console.WriteLine($"Size of int: {sizeof(int)}"); // 输出: 4
    }
}

在这个例子中，我们在 Program 类前加上了 unsafe 关键字，并确保项目启用了不安全代码的支持。

using System;
class Program
{
    unsafe static void Main()
    {
        Console.WriteLine($"Size of int: {sizeof(int)}"); // 输出: 4
    }
}

在这个例子中，我们在 Main 方法前加上了 unsafe 关键字，并确保项目启用了不安全代码的支持。

unsafe 
{
    Console.WriteLine(sizeof(int));    // 输出：4
    Console.WriteLine(sizeof(double)); // 输出：8
    Console.WriteLine(sizeof(bool));   // 输出：1
}

在这个例子中，我们在 在unsafe代码块中调用，并确保项目启用了不安全代码的支持。

四、实战案例

1. 优化内存分配

在某些性能敏感的应用中，了解数据类型的大小可以帮助我们优化内存分配。例如，我们可以根据结构体的大小选择合适的内存池大小。

public struct Point
{
    public int X;
    public int Y;
}

int size = sizeof(Point);
byte[] buffer = new byte[size * 1000]; // 分配足够大小的内存

在这个例子中，我们根据 Point 结构体的大小分配了一个足够大的内存缓冲区。

2. 计算内存占用

在处理大量数据时，了解数据类型的大小可以帮助我们估算内存占用，从而避免内存不足的问题。

int[] array = new int[1000000];
long totalSize = array.Length * sizeof(int);
Console.WriteLine($"Total size: {totalSize} bytes"); // 输出：Total size: 4000000 bytes

在这个例子中，我们根据数组的长度和每个元素的大小计算了数组的总内存占用。

五、与 Marshal.SizeOf 的区别

Marshal.SizeOf() 方法通常用于在与非托管代码进行交互时获取数据类型或结构的大小。它可以处理值类型和自定义结构。它的行为和适用场景与 sizeof 操作符有所不同。

1. 使用 Marshal.SizeOf

Marshal 类 位于 System.Runtime.InteropServices 命名空间下。

以下是一个示例，展示如何使用 Marshal.SizeOf() 来获取自定义结构的大小：

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
struct MyStruct
{
    public int Field1;
    public double Field2;
}

class MarshalSizeOfExample
{
    static void Main()
    {
        Console.WriteLine("Size of MyStruct: " + Marshal.SizeOf(typeof(MyStruct)));
    }
}

在上述示例中，[StructLayout(LayoutKind.Sequential)] 属性用于指定结构的布局方式。

2. sizeof vs Marshal.SizeOf

• sizeof 是在编译时确定值类型的大小，而 Marshal.SizeOf() 是在运行时计算。
• 使用 Marshal.SizeOf() 时要确保结构的布局与预期的一致，特别是在与非托管代码交互的场景中。
• sizeof关注托管内存，Marshal.SizeOf针对非托管内存布局。
  • sizeof返回托管内存大小
  • Marshal.SizeOf返回非托管内存大小，二者可能不同

六、关键点总结

• 用途：获取指定类型在托管堆或非托管环境中所占用的字节数。从而更好地进行内存管理和性能优化。
• 适用范围：仅限于基本数据类型和结构体，不能直接用于引用类型。
• 字段对齐和填充：在计算结构体大小时，需考虑字段对齐和填充的影响。
• 不安全上下文 ：sizeof 关键字只能在不安全上下文中使用，需启用不安全代码支持。

---

结语

回到目录页：C#/.NET 知识汇总

希望以上内容可以帮助到大家，如文中有不对之处，还请批评指正。

---

参考资料：
sizeof 运算符 - 确定给定类型的内存需求