WriteableBitmap.Lock Methode

public:
 void Lock();

public void Lock();

member this.Lock : unit -> unit

Public Sub Lock ()

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie der Hintergrundpuffer mithilfe der Lock Methode reserviert wird.

    // 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();
        }
    }

Hinweise

Die Lock Methode erhöht die Sperranzahl. Wenn ein WriteableBitmap Renderingsystem gesperrt ist, sendet das Renderingsystem erst Updates, wenn die WriteableBitmap Sperrung durch Aufrufe der Unlock Methode vollständig aufgehoben wird.

Sie können die Lock Methode verwenden, um Multithreadimplementierungen zu unterstützen. In diesen Szenarien sperrt der UI-Thread die Bitmap und macht den Hintergrundpuffer für andere Threads verfügbar. Wenn der Workerthread einen Frame abgeschlossen hat, fügt der UI-Thread geänderte Rechtecke hinzu und entsperrt den Puffer.

Der UI-Thread kann blockiert werden, wenn der Renderthread eine Sperre im Hintergrundpuffer erhält, um ihn vorwärts an den Frontpuffer zu kopieren. Wenn die Latenz von diesem Block zu lang ist, verwenden Sie die TryLock Methode, um kurz zu warten, und heben Sie dann die Blockierung des UI-Threads auf, um andere Aufgaben auszuführen, während der Hintergrundpuffer gesperrt ist.

Weitere Informationen

• TryLock(Duration)
• Unlock()