Instrução fixa (referência C#)

The fixed demonstrativo impede que o coletor de lixo realocar uma variável móvel. The fixed demonstrativo só é permitida em um não seguro contexto.Fixed também pode ser usado para criar buffers de dimensionar fixo.

The fixeddemonstrativo define um ponteiro um gerenciado variável e "fixa" ou variável durante a execução da demonstrativo. Sem fixed, ponteiros para variáveis gerenciado móveis seria de pouco uso desde lixo coleção pode realocar as variáveis de forma imprevisível. O compilador translation from VPE for Csharp só permite atribuir um ponteiro para uma variável gerenciada em um fixed demonstrativo.

unsafe static void TestMethod()
{

    // assume class Point { public int x, y; }
    // pt is a managed variable, subject to garbage collection.
    Point pt = new Point();

    // Using fixed allows the address of pt members to be
    // taken, and "pins" pt so it isn't relocated.

    fixed (int* p = &pt.x)
    {
        *p = 1;
    }        

}

Você pode inicializar um ponteiro com o endereço de uma matriz ou uma seqüência de caracteres:

unsafe void Test2()
{
    Point point = new Point();
    double[] arr = { 0, 1.5, 2.3, 3.4, 4.0, 5.9 };
    string str = "Hello World";

    fixed (double* p = arr) { /*...*/ }   // equivalent to p = &arr[0]
    fixed (char* p = str) { /*...*/ }  // equivalent to p = &str[0]

    fixed (int* p1 = &point.x)
    {
        fixed (double* p2 = &arr[5])
        {
            // Do something with p1 and p2.
        }
    }

}

Você pode inicializar várias ponteiros, desde que eles sejam todos do mesmo tipo:

fixed (byte* ps = srcarray, pd = dstarray) {...}

Para inicializar os ponteiros de tipo diferente, simplesmente aninhar fixed instruções:

fixed (int* p1 = &point.x)
{
    fixed (double* p2 = &arr[5])
    {
        // Do something with p1 and p2.
    }
}

Após o código na demonstrativo é executado, qualquer variáveis fixados são lixo desagregado e está sujeito à coleção.Portanto, não apontam para essas variáveis fora o fixed demonstrativo.

Observação:
Ponteiros inicializados em instruções fixas não podem ser modificados.

No modo não seguro, é possível alocar memória na pilha, onde ele não é sujeita a coleta de lixo e, portanto, não precisa ser fixado.Para obter mais informações, consulte stackalloc.

Exemplo

class Point
{ 
    public int x, y; 
}

class FixedTest2 
{
    // Unsafe method: takes a pointer to an int.
    unsafe static void SquarePtrParam (int* p) 
    {
        *p *= *p;
    }

    unsafe static void Main() 
    {
        Point pt = new Point();
        pt.x = 5;
        pt.y = 6;
        // Pin pt in place:
        fixed (int* p = &pt.x) 
        {
            SquarePtrParam (p);
        }
        // pt now unpinned
        Console.WriteLine ("{0} {1}", pt.x, pt.y);
    }
}
/*
Output:
25 6
 */

Especificação da linguagem C#

Para obter mais informações, consulte as seções a seguir no Especificação da linguagem C#:

• 18.3 Variáveis fixas e móveis

• 18.6 A demonstrativo fixed

Consulte também

Conceitos

Guia de Programação C#

Referência

Palavras-chave C#

(referência C#) não seguros

Buffers de dimensionar fixo (guia de programação translation from VPE for Csharp)

Outros recursos

Referência C#