C#6.0语言规范(十八) 不安全代码

前面章节中定义的核心C＃语言与C和C ++的区别在于它省略了作为数据类型的指针。相反，C＃提供了引用和创建由垃圾收集器管理的对象的能力。这种设计与其他功能相结合，使C＃成为比C或C ++更安全的语言。在核心C＃语言中，根本不可能有一个未初始化的变量，一个“悬空”指针，或一个索引超出其边界的数组的表达式。因此消除了常规困扰C和C ++程序的所有类别的错误。

虽然C或C ++中的每个指针类型构造实际上都具有C＃中的引用类型，但是有时候需要访问指针类型。例如，如果不访问指针，则可能无法实现与底层操作系统的接口，访问内存映射设备或实现时间关键算法。为了满足这种需求，C＃提供了编写不安全代码的能力。

在不安全的代码中，可以声明和操作指针，执行指针和整数类型之间的转换，获取变量的地址，等等。从某种意义上说，编写不安全的代码就像在C＃程序中编写C代码一样。

从开发人员和用户的角度来看，不安全代码实际上是一种“安全”功能。必须使用修饰符清楚地标记不安全的代码unsafe，因此开发人员不可能意外地使用不安全的功能，并且执行引擎可以确保不安全的代码无法在不受信任的环境中执行。

不安全的背景

C＃的不安全功能仅在不安全的上下文中可用。通过unsafe在类型或成员的声明中包含修饰符或使用unsafe_statement来引入不安全的上下文：

• 类，结构，接口或委托的声明可以包含unsafe修饰符，在这种情况下，该类型声明的整个文本范围（包括类，结构或接口的主体）被视为不安全的上下文。
• 字段，方法，属性，事件，索引器，运算符，实例构造函数，析构函数或静态构造函数的声明可以包括unsafe修饰符，在这种情况下，该成员声明的整个文本范围被视为不安全的上下文。
• 一个unsafe_statement使得内使用不安全上下文的块。相关块的整个文本范围被认为是不安全的上下文。

相关的语法产生如下所示。

class_modifier_unsafe
    : 'unsafe'
    ;

struct_modifier_unsafe
    : 'unsafe'
    ;

interface_modifier_unsafe
    : 'unsafe'
    ;

delegate_modifier_unsafe
    : 'unsafe'
    ;

field_modifier_unsafe
    : 'unsafe'
    ;

method_modifier_unsafe
    : 'unsafe'
    ;

property_modifier_unsafe
    : 'unsafe'
    ;

event_modifier_unsafe
    : 'unsafe'
    ;

indexer_modifier_unsafe
    : 'unsafe'
    ;

operator_modifier_unsafe
    : 'unsafe'
    ;

constructor_modifier_unsafe
    : 'unsafe'
    ;

destructor_declaration_unsafe
    : attributes? 'extern'? 'unsafe'? '~' identifier '(' ')' destructor_body
    | attributes? 'unsafe'? 'extern'? '~' identifier '(' ')' destructor_body
    ;

static_constructor_modifiers_unsafe
    : 'extern'? 'unsafe'? 'static'
    | 'unsafe'? 'extern'? 'static'
    | 'extern'? 'static' 'unsafe'?
    | 'unsafe'? 'static' 'extern'?
    | 'static' 'extern'? 'unsafe'?
    | 'static' 'unsafe'? 'extern'?
    ;

embedded_statement_unsafe
    : unsafe_statement
    | fixed_statement
    ;

unsafe_statement
    : 'unsafe' block
    ;

在这个例子中

public unsafe struct Node
{
    public int Value;
    public Node* Left;
    public Node* Right;
}

unsafestruct声明中指定的修饰符会导致struct声明的整个文本范围变为不安全的上下文。因此，可以将Left和Right字段声明为指针类型。上面的例子也可以写成

public struct Node
{
    public int Value;
    public unsafe Node* Left;
    public unsafe Node* Right;
}

这里，unsafe字段声明中的修饰符会使这些声明被视为不安全的上下文。

除了建立不安全的上下文，从而允许使用指针类型之外，unsafe修饰符对类型或成员没有影响。在这个例子中

public class A
{
    public unsafe virtual void F() {
        char* p;
        ...
    }
}

public class B: A
{
    public override void F() {
        base.F();
        ...
    }
}

方法中的unsafe修饰符简单地使文本范围成为不安全的上下文，其中可以使用该语言的不安全特征。在in的覆盖中，不需要重新指定修饰符 - 当然，除非该方法本身需要访问不安全的功能。FAFFBunsafeFB

当指针类型是方法签名的一部分时，情况略有不同

public unsafe class A
{
    public virtual void F(char* p) {...}
}

public class B: A
{
    public unsafe override void F(char* p) {...}
}

这里，因为F签名包含指针类型，所以它只能写在不安全的上下文中。但是，可以通过使整个类不安全来引入不安全的上下文，例如A，或者通过unsafe在方法声明中包含一个修饰符，就像在案例中那样B。

指针类型

在不安全的上下文中，类型（类型）可以是pointer_type以及value_type或reference_type。但是，pointer_type也可以用在不安全上下文之外的typeof表达式（匿名对象创建表达式）中，因为这样的使用不是不安全的。

type_unsafe
    : pointer_type
    ;

POINTER_TYPE被写成unmanaged_type或关键字void，随后*的令牌：

pointer_type
    : unmanaged_type '*'
    | 'void' '*'
    ;

unmanaged_type
    : type
    ;

前指定的类型*中的指针类型称为所指类型的指针类型。它表示指针类型的值所指向的变量的类型。

与引用（引用类型的值）不同，垃圾收集器不跟踪指针 - 垃圾收集器不知道指针和它们指向的数据。因此，不允许指针指向引用或包含引用的结构，并且指针的引用类型必须是unmanaged_type。

一个unmanaged_type是任何类型的不是reference_type或构造类型，并且不包含reference_type或构造类型字段在任何嵌套级别。换句话说，unmanaged_type是以下之一：

• sbyte，byte，short，ushort，int，uint，long，ulong，char，float，double，decimal，或bool。
• 任何enum_type。
• 任何pointer_type。
• 任何用户定义的struct_type，它不是构造类型，仅包含unmanaged_type字段。

混合指针和引用的直观规则是允许引用（对象）的引用包含指针，但不允许指针的引用包含引用。

指针类型的一些示例在下表中给出：

例	描述
byte*	指针 byte
char*	指针 char
int**	指向指针的指针 int
int*[]	指向的单维数组 int
void*	指向未知类型的指针

对于给定的实现，所有指针类型必须具有相同的大小和表示。

与C和C ++不同，当在同一个声明中声明多个指针时，在C＃中，*它只与底层类型一起写入，而不是作为每个指针名称的前缀标点符号。例如

int* pi, pj;    // NOT as int *pi, *pj;

具有类型的指针的值T*表示类型变量的地址T。指针间接运算符*（指针间接）可用于访问此变量。例如，给定一个P类型的变量int*，表达式*P表示在int包含的地址中找到的变量P。

像对象引用一样，指针可以是null。将间接运算符应用于null指针会导致实现定义的行为。具有值的指针null由all-bits-zero表示。

该void*类型表示指向未知类型的指针。因为引用类型是未知的，所以间接运算符不能应用于类型的指针void*，也不能对这样的指针执行任何算术运算。但是，类型的指针void*可以转换为任何其他指针类型（反之亦然）。

指针类型是一种单独的类型。与引用类型和值类型不同，指针类型不会继承，object并且指针类型和指针之间不存在转换object。特别是，指针不支持装箱和拆箱（装箱和拆箱）。但是，允许在不同指针类型之间以及指针类型和整数类型之间进行转换。这在Pointer转换中有所描述。

POINTER_TYPE不能用作类型参数（构造类型），和类型推断（类型推断）上，将已推断出类型参数是指针类型通用的方法调用失败。

POINTER_TYPE可以用作挥发性字段（类型挥发性字段）。

虽然指针可以作为被传递ref或out参数，但这样做可能会导致不确定的行为，由于指针可能被设置为指向本地变量不再存在所调用的方法返回时，或固定对象与它用于指向，已不再固定。例如：

using System;

class Test
{
    static int value = 20;

    unsafe static void F(out int* pi1, ref int* pi2) {
        int i = 10;
        pi1 = &i;

        fixed (int* pj = &value) {
            // ...
            pi2 = pj;
        }
    }

    static void Main() {
        int i = 10;
        unsafe {
            int* px1;
            int* px2 = &i;

            F(out px1, ref px2);

            Console.WriteLine("*px1 = {0}, *px2 = {1}",
                *px1, *px2);    // undefined behavior
        }
    }
}

方法可以返回某种类型的值，该类型可以是指针。例如，当给定指向ints 的连续序列的指针，该序列的元素计数和其他一些int值时，如果匹配发生，则以下方法返回该序列中该值的地址; 否则它返回null：

unsafe static int* Find(int* pi, int size, int value) {
    for (int i = 0; i < size; ++i) {
        if (*pi == value) 
            return pi;
        ++pi;
    }
    return null;
}

在不安全的上下文中，有几个构造可用于指针操作：

• 该*操作者可能被用来执行指针间接（间接指针）。
• 的->操作者可用于通过一个指针（访问结构的成员指针成员访问）。
• 的[]操作者可被用于索引的指针（指针元素访问）。
• 该&操作员可以被用于获得一个变量（的地址的地址的操作者）。
• 的++和--运算符可以用于递增和递减指针（指针递增和递减）。
• 的+和-运算符可能被用来执行指针运算（指针运算）。
• 的==，!=，<，>，<=，和=>运算符可能被用来比较指针（指针比较）。
• 的stackalloc操作者可用于从调用堆栈（分配存储器固定大小的缓冲器）。
• 该fixed语句可用于临时修复变量，以便获取其地址（固定语句）。

固定和可移动变量

运算符的地址（运算符的地址）和fixed语句（固定的语句）将变量分为两类：固定变量和可移动变量。

固定变量驻留在不受垃圾收集器操作影响的存储位置。（固定变量的示例包括局部变量，值参数和通过解除引用指针创建的变量。）另一方面，可移动变量驻留在由垃圾收集器进行重定位或处理的存储位置。（可移动变量的示例包括对象中的字段和数组的元素。）

的&操作者（所述地址的操作者）允许不受限制要获得的固定变量的地址。但是，由于可移动变量需要由垃圾回收器进行重定位或处理，因此只能使用fixed语句（固定语句）获取可移动变量的地址，并且该地址仅在该fixed语句的持续时间内有效。

准确地说，固定变量是以下之一：

• 由simple_name（简单名称）引用的变量，引用局部变量或值参数，除非该变量由匿名函数捕获。
• 由表单的member_access（成员访问）产生的变量V.I，其中V是struct_type的固定变量。
• 由表单的pointer_indirection_expression（指针间接），表单*P的pointer_member_access（指针成员访问）P->I或表单的pointer_element_access（指针元素访问）产生的变量P[E]。

所有其他变量都归类为可移动变量。

请注意，静态字段被分类为可移动变量。另请注意，即使为参数指定的参数是固定变量，a ref或out参数也会被归类为可移动变量。最后，请注意，通过取消引用指针生成的变量始终归类为固定变量。

指针转换

在不安全的上下文中，可用的隐式转换（隐式转换）集合被扩展为包括以下隐式指针转换：

• 从任何pointer_type到类型void*。
• 从null文字到任何pointer_type。

此外，在不安全的上下文中，可扩展的可用显式转换（显式转换）集扩展为包括以下显式指针转换：

• 从任何pointer_type到任何其他pointer_type。
• 从sbyte，byte，short，ushort，int，uint，long，或ulong以任何POINTER_TYPE。
• 从任何POINTER_TYPE到sbyte，byte，short，ushort，int，uint，long，或ulong。

最后，在不安全的上下文中，标准隐式转换集（标准隐式转换）包括以下指针转换：

• 从任何pointer_type到类型void*。

两种指针类型之间的转换永远不会改变实际指针值。换句话说，从一种指针类型到另一种指针类型的转换对指针给出的底层地址没有影响。

当一个指针类型转换为另一个指针类型时，如果生成的指针未针对指向类型正确对齐，则如果取消引用结果，则行为未定义。一般来说，“正确对齐”的概念是传递性的：如果指向类型的指针A正确地对齐指向类型的指针B，而指针又正确地对齐指向类型C的指针，则指向类型的指针A正确对齐指向类型的指针C。

考虑以下情况，其中通过指向不同类型的指针访问具有一种类型的变量：

char c = 'A';
char* pc = &c;
void* pv = pc;
int* pi = (int*)pv;
int i = *pi;         // undefined
*pi = 123456;        // undefined

当指针类型转换为指向byte的指针时，结果指向变量的最低寻址字节。结果的连续递增，直到变量的大小，产生指向该变量的剩余字节的指针。例如，以下方法将double中的八个字节中的每一个显示为十六进制值：

using System;

class Test
{
    unsafe static void Main() {
      double d = 123.456e23;
        unsafe {
           byte* pb = (byte*)&d;
            for (int i = 0; i < sizeof(double); ++i)
               Console.Write("{0:X2} ", *pb++);
            Console.WriteLine();
        }
    }
}

当然，产生的输出取决于字节序。

指针和整数之间的映射是实现定义的。但是，在具有线性地址空间的32 *和64位CPU架构上，指向或来自整数类型的指针的转换通常与这些整数类型的转换uint或ulong值分别完全相同。

指针数组

在不安全的上下文中，可以构造指针数组。在指针数组上只允许一些适用于其他数组类型的转换：

• 从任何array_type到它实现的接口的隐式引用转换（隐式引用转换）也适用于指针数组。但是，任何尝试访问数组元素或它实现的接口都会在运行时导致异常，因为指针类型不可转换为。System.ArraySystem.Arrayobject
• 从一维数组类型到其通用基接口的隐式和显式引用转换（隐式引用转换，显式引用转换）从不适用于指针数组，因为指针类型不能用作类型参数，并且没有来自指针类型为非指针类型。S[]System.Collections.Generic.IList<T>
• 从它实现的接口到任何array_type的显式引用转换（显式引用转换）适用于指针数组。System.Array
• 显式引用转换（显式引用转换）System.Collections.Generic.IList<S>和它的基本接口到一维数组类型T[]永远不会应用于指针数组，因为指针类型不能用作类型参数，并且没有指针类型到非指针类型的转换。

这些限制意味着foreach语句中foreach描述的数组语句的扩展不能应用于指针数组。相反，形式的foreach声明

foreach (V v in x) embedded_statement

其中type x是表单的数组类型T[,,...,]，N是维数减1和T或是V指针类型，使用嵌套for循环进行扩展，如下所示：

{
    T[,,...,] a = x;
    for (int i0 = a.GetLowerBound(0); i0 <= a.GetUpperBound(0); i0++)
    for (int i1 = a.GetLowerBound(1); i1 <= a.GetUpperBound(1); i1++)
    ...
    for (int iN = a.GetLowerBound(N); iN <= a.GetUpperBound(N); iN++) {
        V v = (V)a.GetValue(i0,i1,...,iN);
        embedded_statement
    }
}

变量a，i0，i1，...，iN是不可见的或不可访问x或embedded_statement或程序的任何其他源代码。该变量v在嵌入语句中是只读的。如果没有从（元素类型）到显式转换（指针转换），则会产生错误并且不会采取进一步的步骤。如果有值，则在运行时抛出a 。TVxnullSystem.NullReferenceException

表达式中的指针

在不安全的上下文中，表达式可能会产生指针类型的结果，但在不安全的上下文之外，表达式是指针类型的编译时错误。准确地说，在不安全的上下文之外，如果任何simple_name（简单名称），member_access（成员访问），invocation_expression（调用表达式）或element_access（元素访问）属于指针类型，则会发生编译时错误。

在不安全的上下文中，primary_no_array_creation_expression（主表达式）和unary_expression（一元运算符）产生允许以下附加构造：

primary_no_array_creation_expression_unsafe
    : pointer_member_access
    | pointer_element_access
    | sizeof_expression
    ;

unary_expression_unsafe
    : pointer_indirection_expression
    | addressof_expression
    ;

这些结构将在以下部分中描述。语法隐含了不安全运算符的优先级和相关性。

指针间接

pointer_indirection_expression由星号（的*），接着是unary_expression。

pointer_indirection_expression
    : '*' unary_expression
    ;

一元运算*符表示指针间接，用于获取指针指向的变量。评估的结果*P，其中P是指针类型的表达式，是类型T*的变量T。将一元运算*符应用于类型void*的表达式或不是指针类型的表达式是一个编译时错误。

将一元运算*符应用于null指针的效果是实现定义的。特别是，无法保证此操作会抛出一个System.NullReferenceException。

如果为指针分配了无效值，则一元运算*符的行为未定义。在由一元运算*符取消引用指针的无效值中，一个地址与指向的类型不一致（参见指针转换中的示例），以及变量在其生命周期结束后的地址。

出于明确赋值分析的目的，通过评估表单表达式生成的变量*P被认为是最初分配的（最初分配的变量）。

指针成员访问

pointer_member_access由一个的primary_expression，接着是“ ->”令牌，随后的标识符和可选的type_argument_list。

pointer_member_access
    : primary_expression '->' identifier
    ;

在表单的指针成员访问中P->I，P必须是指针类型以外的表达式void*，并且I必须表示该类型的可访问成员P。

表单的指针成员访问P->I完全被评估为(*P).I。有关指针间接运算符（*）的说明，请参阅指针间接寻址。有关成员访问运算符（.）的说明，请参阅成员访问。

在这个例子中

using System;

struct Point
{
    public int x;
    public int y;

    public override string ToString() {
        return "(" + x + "," + y + ")";
    }
}

class Test
{
    static void Main() {
        Point point;
        unsafe {
            Point* p = &point;
            p->x = 10;
            p->y = 20;
            Console.WriteLine(p->ToString());
        }
    }
}

->运算符用于通过一个指针访问字段并调用一个结构的方法。因为操作P->I恰好等同于(*P).I，所以该Main方法同样可以编写：

class Test
{
    static void Main() {
        Point point;
        unsafe {
            Point* p = &point;
            (*p).x = 10;
            (*p).y = 20;
            Console.WriteLine((*p).ToString());
        }
    }
}

指针元素访问

pointer_element_access由一个的primary_no_array_creation_expression随后封闭在“表达[”和“ ]”。

pointer_element_access
    : primary_no_array_creation_expression '[' expression ']'
    ;

在以下形式的指针元素访问P[E]，P必须比其他的指针类型的表达式void*，并且E必须是可以被隐式转换为表达式int，uint，long，或ulong。

表单的指针元素访问P[E]精确地评估为*(P + E)。有关指针间接运算符（*）的说明，请参阅指针间接寻址。有关指针加法运算符（+）的说明，请参见指针运算。

在这个例子中

class Test
{
    static void Main() {
        unsafe {
            char* p = stackalloc char[256];
            for (int i = 0; i < 256; i++) p[i] = (char)i;
        }
    }
}

指针元素访问用于初始化for循环中的字符缓冲区。因为操作P[E]恰好等同于*(P + E)，所以可以同样编写示例：

class Test
{
    static void Main() {
        unsafe {
            char* p = stackalloc char[256];
            for (int i = 0; i < 256; i++) *(p + i) = (char)i;
        }
    }
}

指针元素访问运算符不检查越界错误，并且未定义访问越界元素时的行为。这与C和C ++相同。

运算符的地址

一个addressof_expression由符号（&），接着是unary_expression。

addressof_expression
    : '&' unary_expression
    ;

给定一个E类型的表达式T并将其归类为固定变量（固定和可移动变量），该构造&E计算由给定的变量的地址E。结果的类型是T*和被分类为值。如果E未归类为变量，则E归类为编译时错误，如果归类为只读局部变量，或者E表示可移动变量。在最后一种情况下，固定语句（固定语句）可用于在获取其地址之前临时“修复”该变量。如成员访问中所述，在实例构造函数或定义的结构或类的静态构造函数之外readonly字段，该字段被视为值，而不是变量。因此，不能采取其地址。同样，不能采用常量的地址。

的&操作者并不需要它的参数被明确赋值，但以下内容的&操作中，变量被施加操作者在其中发生动作的执行路径视为已明确赋值。程序员有责任确保在这种情况下确实正确地初始化变量。

在这个例子中

using System;

class Test
{
    static void Main() {
        int i;
        unsafe {
            int* p = &i;
            *p = 123;
        }
        Console.WriteLine(i);
    }
}

i被认为是在&i用于初始化的操作之后明确分配的p。实际的赋值*p初始化i，但是包含这个初始化是程序员的责任，如果删除了赋值，则不会发生编译时错误。

&存在对运算符的明确赋值的规则，从而可以避免局部变量的冗余初始化。例如，许多外部API采用指向由API填充的结构的指针。对此类API的调用通常会传递本地struct变量的地址，如果没有该规则，则需要对struct变量进行冗余初始化。

指针递增和递减

在不安全的上下文中，++和--运算符（Postfix递增和递减运算符以及前缀递增和递减运算符）可以应用于除了之外的所有类型的指针变量void*。因此，对于每个指针类型T*，隐式定义以下运算符：

T* operator ++(T* x);
T* operator --(T* x);

运算符产生相同的结果x + 1和x - 1，分别为（指针运算）。换句话说，对于类型的指针变量T*，++运算符将添加sizeof(T)到变量中包含的地址，并且--运算符sizeof(T)从变量中包含的地址中减去。

如果指针递增或递减操作溢出指针类型的域，则结果是实现定义的，但不会产生异常。

指针算术

在不安全的上下文中，+和-运算符（加法运算符和减法运算符）可以应用于除了之外的所有指针类型的值void*。因此，对于每个指针类型T*，隐式定义以下运算符：

T* operator +(T* x, int y);
T* operator +(T* x, uint y);
T* operator +(T* x, long y);
T* operator +(T* x, ulong y);

T* operator +(int x, T* y);
T* operator +(uint x, T* y);
T* operator +(long x, T* y);
T* operator +(ulong x, T* y);

T* operator -(T* x, int y);
T* operator -(T* x, uint y);
T* operator -(T* x, long y);
T* operator -(T* x, ulong y);

long operator -(T* x, T* y);

给出的表达式P指针类型的T*和表达N类型的int，uint，long，或ulong，表述P + N和N + P计算类型的指针值T*从增加导致N * sizeof(T)由给出的地址P。同样，表达式P - N计算类型的指针值，该值是从给定的地址中T*减去N * sizeof(T)的P。

给定两个表达式，P以及Q指针类型T*，表达式P - Q计算由P和给出的地址之间的差异Q，然后将差异除以sizeof(T)。结果的类型总是如此long。实际上，P - Q计算为((long)(P) - (long)(Q)) / sizeof(T)。

例如：

using System;

class Test
{
    static void Main() {
        unsafe {
            int* values = stackalloc int[20];
            int* p = &values[1];
            int* q = &values[15];
            Console.WriteLine("p - q = {0}", p - q);
            Console.WriteLine("q - p = {0}", q - p);
        }
    }
}

产生输出：

p - q = -14
q - p = 14

如果指针算术运算溢出指针类型的域，则结果将以实现定义的方式截断，但不会产生异常。

指针比较

在不安全的上下文中，==，!=，<，>，<=，和=>运算符（关系和类型的测试操作员）可以被应用于所有指针类型的值。指针比较运算符是：

bool operator ==(void* x, void* y);
bool operator !=(void* x, void* y);
bool operator <(void* x, void* y);
bool operator >(void* x, void* y);
bool operator <=(void* x, void* y);
bool operator >=(void* x, void* y);

因为从任何指针类型到void*类型都存在隐式转换，所以可以使用这些运算符比较任何指针类型的操作数。比较运算符将两个操作数给出的地址进行比较，就好像它们是无符号整数一样。

sizeof运算符

的sizeof运算符返回由给定类型的变量占用的字节的数目。指定为操作数的类型sizeof必须是unmanaged_type（指针类型）。

sizeof_expression
    : 'sizeof' '(' unmanaged_type ')'
    ;

sizeof运算符的结果是类型的值int。对于某些预定义类型，sizeof运算符会产生一个常量值，如下表所示。

表达	结果
sizeof(sbyte)	1
sizeof(byte)	1
sizeof(short)	2
sizeof(ushort)	2
sizeof(int)	4
sizeof(uint)	4
sizeof(long)	8
sizeof(ulong)	8
sizeof(char)	2
sizeof(float)	4
sizeof(double)	8
sizeof(bool)	1

对于所有其他类型，sizeof运算符的结果是实现定义的，并且被分类为值，而不是常量。

成员打包到结构中的顺序未指定。

出于对齐目的，在结构的开头，结构内和结构的末尾可能存在未命名的填充。用作填充的位的内容是不确定的。

当应用于具有结构类型的操作数时，结果是该类型的变量中的总字节数，包括任何填充。

固定的声明

在不安全的上下文中，embedded_statement（Statements）生成允许一个额外的构造，即fixed语句，用于“修复”可移动变量，使其地址在语句的持续时间内保持不变。

fixed_statement
    : 'fixed' '(' pointer_type fixed_pointer_declarators ')' embedded_statement
    ;

fixed_pointer_declarators
    : fixed_pointer_declarator (','  fixed_pointer_declarator)*
    ;

fixed_pointer_declarator
    : identifier '=' fixed_pointer_initializer
    ;

fixed_pointer_initializer
    : '&' variable_reference
    | expression
    ;

每个fixed_pointer_declarator声明给定pointer_type的局部变量，并使用相应的fixed_pointer_initializer计算的地址初始化该局部变量。声明中fixed声明的局部变量可以在该变量声明右侧的任何fixed_pointer_initializer中以及该语句的embedded_statement中访问fixed。声明声明的局部变量fixed被认为是只读的。如果嵌入语句试图修改此局部变量（通过赋值或发生编译时间错误++和--操作员）或它传递作为ref或out参数。

一个fixed_pointer_initializer可以是下列之一：

• 令牌“ &”后跟一个variable_reference（用于确定明确赋值的精确规则）到非托管类型的可移动变量（固定和可移动变量）T，前提是该类型T*可隐式转换为fixed语句中给出的指针类型。在这种情况下，初始化程序计算给定变量的地址，并保证变量在fixed语句的持续时间内保持固定的地址。
• 具有非托管类型元素的array_type的表达式T，前提是该类型T*可隐式转换为fixed语句中指定的指针类型。在这种情况下，初始化程序计算数组中第一个元素的地址，并保证整个数组在fixed语句的持续时间内保持固定的地址。如果数组表达式为null或者数组的元素为零，则初始化程序计算的地址等于零。
• 类型的表达式string，前提是类型char*可以隐式转换为fixed语句中给出的指针类型。在这种情况下，初始化程序计算字符串中第一个字符的地址，并保证整个字符串在fixed语句的持续时间内保持固定的地址。fixed如果字符串表达式为null ，则语句的行为是实现定义的。
• simple_name或member_access引用可移动变量的固定大小的缓冲部件，设置在固定大小缓冲部件的类型是隐式转换为给定的指针类型fixed声明。在这种情况下，初始化程序计算指向固定大小缓冲区的第一个元素的指针（表达式中的固定大小缓冲区），并且保证固定大小缓冲区在fixed语句的持续时间内保持固定地址。

对于由fixed_pointer_initializer计算的每个地址，该fixed语句确保该地址引用的变量在fixed语句持续时间内不受垃圾收集器的重定位或处理。例如，如果fixed_pointer_initializer计算的地址引用了对象的字段或数组实例的元素，则该fixed语句保证在语句的生命周期内不重定位或处置包含的对象实例。

程序员有责任确保fixed语句创建的指针不会超出这些语句的执行。例如，当fixed语句创建的指针传递给外部API时，程序员有责任确保API不保留这些指针的内存。

固定对象可能导致堆碎片（因为它们无法移动）。因此，只有在绝对必要时才能修复物体，然后才能在最短的时间内修复物体。

这个例子

class Test
{
    static int x;
    int y;

    unsafe static void F(int* p) {
        *p = 1;
    }

    static void Main() {
        Test t = new Test();
        int[] a = new int[10];
        unsafe {
            fixed (int* p = &x) F(p);
            fixed (int* p = &t.y) F(p);
            fixed (int* p = &a[0]) F(p);
            fixed (int* p = a) F(p);
        }
    }
}

演示了该fixed语句的几种用法。第一个语句修复并获取静态字段的地址，第二个语句修复并获取实例字段的地址，第三个语句修复并获取数组元素的地址。在每种情况下，使用常规&运算符都是错误的，因为变量都被归类为可移动变量。

上例中的第四个fixed语句产生与第三个类似的结果。

该fixed语句示例使用string：

class Test
{
    static string name = "xx";

    unsafe static void F(char* p) {
        for (int i = 0; p[i] != ''; ++i)
            Console.WriteLine(p[i]);
    }

    static void Main() {
        unsafe {
            fixed (char* p = name) F(p);
            fixed (char* p = "xx") F(p);
        }
    }
}

在不安全的上下文中，一维数组的数组元素以递增的索引顺序存储，从索引开始并以索引0结束Length - 1。对于多维数组，存储数组元素，使得最右边的维度的索引首先增加，然后是下一个左维度，依此类推到左边。内的fixed，其获得一个指针的语句p到数组实例a中，指针值从p到p + a.Length - 1代表数组中的元素的地址。同样地，变量范围从p[0]到p[a.Length - 1]代表实际的数组元素。考虑到存储数组的方式，我们可以将任何维度的数组视为线性数组。

例如：

using System;

class Test
{
    static void Main() {
        int[,,] a = new int[2,3,4];
        unsafe {
            fixed (int* p = a) {
                for (int i = 0; i < a.Length; ++i)    // treat as linear
                    p[i] = i;
            }
        }

        for (int i = 0; i < 2; ++i)
            for (int j = 0; j < 3; ++j) {
                for (int k = 0; k < 4; ++k)
                    Console.Write("[{0},{1},{2}] = {3,2} ", i, j, k, a[i,j,k]);
                Console.WriteLine();
            }
    }
}

产生输出：

[0,0,0] =  0 [0,0,1] =  1 [0,0,2] =  2 [0,0,3] =  3
[0,1,0] =  4 [0,1,1] =  5 [0,1,2] =  6 [0,1,3] =  7
[0,2,0] =  8 [0,2,1] =  9 [0,2,2] = 10 [0,2,3] = 11
[1,0,0] = 12 [1,0,1] = 13 [1,0,2] = 14 [1,0,3] = 15
[1,1,0] = 16 [1,1,1] = 17 [1,1,2] = 18 [1,1,3] = 19
[1,2,0] = 20 [1,2,1] = 21 [1,2,2] = 22 [1,2,3] = 23

在这个例子中

class Test
{
    unsafe static void Fill(int* p, int count, int value) {
        for (; count != 0; count--) *p++ = value;
    }

    static void Main() {
        int[] a = new int[100];
        unsafe {
            fixed (int* p = a) Fill(p, 100, -1);
        }
    }
}

一个fixed语句用于修复数组，因此它的地址可以传递给一个带指针的方法。

在示例中：

unsafe struct Font
{
    public int size;
    public fixed char name[32];
}

class Test
{
    unsafe static void PutString(string s, char* buffer, int bufSize) {
        int len = s.Length;
        if (len > bufSize) len = bufSize;
        for (int i = 0; i < len; i++) buffer[i] = s[i];
        for (int i = len; i < bufSize; i++) buffer[i] = (char)0;
    }

    Font f;

    unsafe static void Main()
    {
        Test test = new Test();
        test.f.size = 10;
        fixed (char* p = test.f.name) {
            PutString("Times New Roman", p, 32);
        }
    }
}

固定语句用于修复结构的固定大小缓冲区，因此其地址可用作指针。

阿char*通过固定字符串实例产生值总是指向一个空终止字符串。内的固定语句，其获得的指针p为一个字符串实例s中，指针值从p给p + s.Length - 1表示字符的地址字符串中，并且指针值p + s.Length总是指向一个空字符（具有值的字符''）。

通过固定指针修改托管类型的对象可能导致未定义的行为。例如，因为字符串是不可变的，所以程序员有责任确保不修改指向固定字符串的指针所引用的字符。

当调用期望“C风格”字符串的外部API时，字符串的自动空终止特别方便。但请注意，允许字符串实例包含空字符。如果存在此类空字符，则在将其视为以空值终止时，该字符串将显示为截断char*。

固定大小缓冲区

固定大小的缓冲区用于将“C样式”内联数组声明为结构的成员，主要用于与非托管API进行交互。

固定大小的缓冲区声明

固定大小缓冲器是表示对于给定类型的变量的固定长度缓冲器的存储的部件。固定大小的缓冲区声明引入给定元素类型的一个或多个固定大小的缓冲区。固定大小的缓冲区仅在结构声明中允许，并且只能在不安全的上下文中发生（不安全的上下文）。

struct_member_declaration_unsafe
    : fixed_size_buffer_declaration
    ;

fixed_size_buffer_declaration
    : attributes? fixed_size_buffer_modifier* 'fixed' buffer_element_type fixed_size_buffer_declarator+ ';'
    ;

fixed_size_buffer_modifier
    : 'new'
    | 'public'
    | 'protected'
    | 'internal'
    | 'private'
    | 'unsafe'
    ;

buffer_element_type
    : type
    ;

fixed_size_buffer_declarator
    : identifier '[' constant_expression ']'
    ;

固定大小的缓冲区声明可以包括一组属性（属性），new修饰符（修饰符），四个访问修饰符（类型参数和约束）的有效组合和unsafe修饰符（不安全上下文）。属性和修饰符适用于固定大小缓冲区声明声明的所有成员。同一修饰符在固定大小的缓冲区声明中多次出现是错误的。

固定大小的缓冲区声明不允许包含static修饰符。

固定大小缓冲区声明的缓冲区元素类型指定声明引入的缓冲区的元素类型。缓冲元件类型必须是预定义的类型中的一种sbyte，byte，short，ushort，int，uint，long，ulong，char，float，double，或bool。

缓冲区元素类型后跟一个固定大小的缓冲区声明符列表，每个缓冲区声明符都引入一个新成员。固定大小的缓冲区声明符包含一个标识该成员的标识符，后跟一个括在其中的常量表达式[和]标记。常量表达式表示由该固定大小缓冲区声明符引入的成员中的元素数。常量表达式的类型必须可隐式转换为type int，并且该值必须是非零正整数。

保证固定大小缓冲区的元素在存储器中顺序排列。

声明多个固定大小缓冲区的固定大小缓冲区声明等效于具有相同属性和元素类型的单个固定大小缓冲区声明的多个声明。例如

unsafe struct A
{
   public fixed int x[5], y[10], z[100];
}

相当于

unsafe struct A
{
   public fixed int x[5];
   public fixed int y[10];
   public fixed int z[100];
}

修复表达式中的大小缓冲区

固定大小缓冲区成员的成员查找（操作符）与字段的成员查找完全相同。

可以使用simple_name（类型推断）或member_access（动态重载决策的编译时检查）在表达式中引用固定大小的缓冲区。

当固定大小的缓冲区成员作为简单名称引用时，效果与表单的成员访问权限相同this.I，其中I是固定大小的缓冲区成员。

在表单的成员访问中E.I，如果E是结构类型并且该结构类型中的成员查找I标识了固定大小的成员，则E.I评估分类如下：

• 如果表达式E.I未在不安全的上下文中发生，则会发生编译时错误。
• 如果E被归类为值，则发生编译时错误。
• 否则，如果E是可移动变量（固定和可移动变量）且表达式E.I不是fixed_pointer_initializer（固定语句），则发生编译时错误。
• 否则，E引用一个固定变量和表达式的结果是一个指针到固定大小缓冲部件的第一元件I在E。结果是类型S*，其中S元素类型为I，并且被分类为值。

可以使用来自第一个元素的指针操作来访问固定大小缓冲区的后续元素。与访问数组不同，访问固定大小缓冲区的元素是一种不安全的操作，不进行范围检查。

以下示例声明并使用具有固定大小缓冲区成员的结构。

unsafe struct Font
{
    public int size;
    public fixed char name[32];
}

class Test
{
    unsafe static void PutString(string s, char* buffer, int bufSize) {
        int len = s.Length;
        if (len > bufSize) len = bufSize;
        for (int i = 0; i < len; i++) buffer[i] = s[i];
        for (int i = len; i < bufSize; i++) buffer[i] = (char)0;
    }

    unsafe static void Main()
    {
        Font f;
        f.size = 10;
        PutString("Times New Roman", f.name, 32);
    }
}

明确的赋值检查

固定大小的缓冲区不受明确的赋值检查（定义赋值），并且为了对结构类型变量进行明确的赋值检查，忽略固定大小的缓冲区成员。

当固定大小缓冲区成员的最外层包含struct变量是静态变量，类实例的实例变量或数组元素时，固定大小缓冲区的元素将自动初始化为其默认值（默认值）。在所有其他情况下，固定大小缓冲区的初始内容是未定义的。

堆栈分配

在不安全的上下文中，局部变量声明（局部变量声明）可能包括一个堆栈分配初始化器，它从调用堆栈中分配内存。

local_variable_initializer_unsafe
    : stackalloc_initializer
    ;

stackalloc_initializer
    : 'stackalloc' unmanaged_type '[' expression ']'
    ;

所述unmanaged_type指示将被存储在新分配的位置的物品的类型和表达表明这些项目的数目。总之，这些指定了所需的分配大小。由于堆栈分配的大小不能为负，因此将项目数指定为计算为负值的constant_expression是编译时错误。

表单的堆栈分配初始值设定项stackalloc T[E]需要T是非托管类型（指针类型）并且E是类型的表达式int。该构造E * sizeof(T)从调用堆栈分配字节，并将类型的指针返回T*给新分配的块。如果E是负值，则行为未定义。如果E为零，则不进行分配，并且返回的指针是实现定义的。如果没有足够的可用内存来分配给定大小的块，System.StackOverflowException则抛出a。

新分配的内存的内容未定义。

堆栈分配初始值设定项不允许在块catch或finally块中（try语句）。

没有办法显式释放使用分配的内存stackalloc。在该函数成员返回时，将自动丢弃在执行函数成员期间创建的所有堆栈分配的内存块。这对应于alloca函数，这是C和C ++实现中常见的扩展。

在这个例子中

using System;

class Test
{
    static string IntToString(int value) {
        int n = value >= 0? value: -value;
        unsafe {
            char* buffer = stackalloc char[16];
            char* p = buffer + 16;
            do {
                *--p = (char)(n % 10 + '0');
                n /= 10;
            } while (n != 0);
            if (value < 0) *--p = '-';
            return new string(p, 0, (int)(buffer + 16 - p));
        }
    }

    static void Main() {
        Console.WriteLine(IntToString(12345));
        Console.WriteLine(IntToString(-999));
    }
}

一个stackalloc初始值设定在所使用的IntToString方法来分配的16个字符缓冲器中的堆栈中。方法返回时自动丢弃缓冲区。

动态内存分配

除了stackalloc运算符之外，C＃没有提供用于管理非垃圾收集内存的预定义构造。此类服务通常由支持类库提供或直接从底层操作系统导入。例如，Memory下面的类说明了如何从C＃访问底层操作系统的堆函数：

using System;
using System.Runtime.InteropServices;

public unsafe class Memory
{
    // Handle for the process heap. This handle is used in all calls to the
    // HeapXXX APIs in the methods below.
    static int ph = GetProcessHeap();

    // Private instance constructor to prevent instantiation.
    private Memory() {}

    // Allocates a memory block of the given size. The allocated memory is
    // automatically initialized to zero.
    public static void* Alloc(int size) {
        void* result = HeapAlloc(ph, HEAP_ZERO_MEMORY, size);
        if (result == null) throw new OutOfMemoryException();
        return result;
    }

    // Copies count bytes from src to dst. The source and destination
    // blocks are permitted to overlap.
    public static void Copy(void* src, void* dst, int count) {
        byte* ps = (byte*)src;
        byte* pd = (byte*)dst;
        if (ps > pd) {
            for (; count != 0; count--) *pd++ = *ps++;
        }
        else if (ps < pd) {
            for (ps += count, pd += count; count != 0; count--) *--pd = *--ps;
        }
    }

    // Frees a memory block.
    public static void Free(void* block) {
        if (!HeapFree(ph, 0, block)) throw new InvalidOperationException();
    }

    // Re-allocates a memory block. If the reallocation request is for a
    // larger size, the additional region of memory is automatically
    // initialized to zero.
    public static void* ReAlloc(void* block, int size) {
        void* result = HeapReAlloc(ph, HEAP_ZERO_MEMORY, block, size);
        if (result == null) throw new OutOfMemoryException();
        return result;
    }

    // Returns the size of a memory block.
    public static int SizeOf(void* block) {
        int result = HeapSize(ph, 0, block);
        if (result == -1) throw new InvalidOperationException();
        return result;
    }

    // Heap API flags
    const int HEAP_ZERO_MEMORY = 0x00000008;

    // Heap API functions
    [DllImport("kernel32")]
    static extern int GetProcessHeap();

    [DllImport("kernel32")]
    static extern void* HeapAlloc(int hHeap, int flags, int size);

    [DllImport("kernel32")]
    static extern bool HeapFree(int hHeap, int flags, void* block);

    [DllImport("kernel32")]
    static extern void* HeapReAlloc(int hHeap, int flags, void* block, int size);

    [DllImport("kernel32")]
    static extern int HeapSize(int hHeap, int flags, void* block);
}

Memory下面给出了使用该类的示例：

class Test
{
    static void Main() {
        unsafe {
            byte* buffer = (byte*)Memory.Alloc(256);
            try {
                for (int i = 0; i < 256; i++) buffer[i] = (byte)i;
                byte[] array = new byte[256];
                fixed (byte* p = array) Memory.Copy(buffer, p, 256); 
            }
            finally {
                Memory.Free(buffer);
            }
            for (int i = 0; i < 256; i++) Console.WriteLine(array[i]);
        }
    }
}

该示例分配256字节的内存Memory.Alloc并初始化内存块，其值从0增加到255.然后，它分配256个元素的字节数组，并用于Memory.Copy将内存块的内容复制到字节数组中。最后，释放内存块，Memory.Free并在控制台上输出字节数组的内容。