fixed Statement (C# Reference)

O fixed instrução impede que o coletor de lixo de realocação um variável móvel. O fixed instrução só é permitida em um inseguros contexto. Fixedtambém pode ser usado para criar fixo de buffers de tamanho.

O fixed instrução define um ponteiro para uma variável gerenciada e "pins" Essa variável durante a execução da instrução. Sem fixed, ponteiros para variáveis de gerenciado Movível seria de pouco uso desde a coleta de lixo pode realocar as variáveis de forma imprevisível. O compilador C# somente permite que você atribua um ponteiro para uma variável gerenciada em um fixed instrução.

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, contanto que eles são 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.
    }
}

Depois que o código na instrução é executado, quaisquer variáveis fixados são lixo desagregados e está sujeito à coleção. Portanto, não apontam para essas variáveis fora do fixed instrução.

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

No modo não seguro, você pode alocar memória na pilha, onde ele não estará sujeito à 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 C# Language Specification A especificação de linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também

Referência

C# Keywords

unsafe (C# Reference)

Buffers de tamanho fixo (guia de programação de C#)

Conceitos

C# Programming Guide

Outros recursos

C# Reference