WriteableBitmap.Lock Methode

Definition

Namespace:

System.Windows.Media.Imaging

Assembly:

PresentationCore.dll

Reserviert den Hintergrundpuffer für Aktualisierungen.

public:
 void Lock();

public void Lock ();

member this.Lock : unit -> unit

Public Sub Lock ()

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie der Backpuffer 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 System gesperrt ist, sendet das Renderingsystem keine Updates, bis die WriteableBitmap Aufrufe der Unlock Methode vollständig entsperrt sind.

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

Der UI-Thread kann blockiert werden, wenn der Renderthread eine Sperrung im Backpuffer erhält, um ihn an den Frontpuffer zu kopieren. Wenn die Latenz aus diesem Block zu lang ist, verwenden Sie die TryLock Methode, um kurz zu warten und dann den UI-Thread zu blockieren, um andere Aufgaben auszuführen, während der Backpuffer gesperrt ist.

Siehe auch

• TryLock(Duration)
• Unlock()