WriteableBitmap.Lock Método

Definição

Namespace:

System.Windows.Media.Imaging

Assembly:

PresentationCore.dll

Reserva o buffer de fundo para atualizações.

public:
 void Lock();

public void Lock ();

member this.Lock : unit -> unit

Public Sub Lock ()

Exemplos

O exemplo de código a seguir mostra como reservar o buffer traseiro usando o Lock método.

    // The DrawPixel method updates the WriteableBitmap by using
    // unsafe code to write a pixel into the back buffer.
    static void DrawPixel(MouseEventArgs e)
    {
        int column = (int)e.GetPosition(i).X;
        int row = (int)e.GetPosition(i).Y;

        try{
            // Reserve the back buffer for updates.
            writeableBitmap.Lock();

            unsafe
            {
                // Get a pointer to the back buffer.
                IntPtr pBackBuffer = writeableBitmap.BackBuffer;

                // Find the address of the pixel to draw.
                pBackBuffer += row * writeableBitmap.BackBufferStride;
                pBackBuffer += column * 4;

                // Compute the pixel's color.
                int color_data = 255 << 16; // R
                color_data |= 128 << 8;   // G
                color_data |= 255 << 0;   // B

                // Assign the color data to the pixel.
                *((int*) pBackBuffer) = color_data;
            }

            // Specify the area of the bitmap that changed.
            writeableBitmap.AddDirtyRect(new Int32Rect(column, row, 1, 1));
        }
        finally{
            // Release the back buffer and make it available for display.
            writeableBitmap.Unlock();
        }
    }

Comentários

O Lock método incrementa a contagem de bloqueios. Quando um WriteableBitmap é bloqueado, o sistema de renderização não envia atualizações até que ele WriteableBitmap seja totalmente desbloqueado por chamadas para o Unlock método.

Você pode usar o Lock método para dar suporte a implementações com vários threads. Nesses cenários, o thread da interface do usuário bloqueia o bitmap e expõe o buffer traseiro para outros threads. Quando o thread de trabalho tiver terminado um quadro, o thread da interface do usuário adicionará retângulos alterados e desbloqueará o buffer.

O thread da interface do usuário pode ser bloqueado quando o thread de renderização adquire um bloqueio no buffer traseiro para copiá-lo para o buffer frontal. Se a latência desse bloco for muito longa, use o TryLock método para aguardar por um curto período de tempo e, em seguida, desbloqueie o thread da interface do usuário para executar outras tarefas enquanto o buffer traseiro estiver bloqueado.

Confira também

• TryLock(Duration)
• Unlock()