WriteableBitmap.Lock Méthode

public:
 void Lock();

public void Lock();

member this.Lock : unit -> unit

Public Sub Lock ()

Exemples

L’exemple de code suivant montre comment réserver la mémoire tampon back à l’aide de la Lock méthode.

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

Remarques

La Lock méthode incrémente le nombre de verrous. Lorsqu’un WriteableBitmap verrou est verrouillé, le système de rendu n’envoie pas de mises à jour tant que le WriteableBitmap système de rendu n’est pas entièrement déverrouillé par les appels à la Unlock méthode.

Vous pouvez utiliser la Lock méthode pour prendre en charge les implémentations multithread. Dans ces scénarios, le thread d’interface utilisateur verrouille la bitmap et expose la mémoire tampon back à d’autres threads. Une fois le thread de travail terminé, le thread d’interface utilisateur ajoute des rectangles modifiés et déverrouille la mémoire tampon.

Le thread d’interface utilisateur peut bloquer lorsque le thread de rendu acquiert un verrou sur la mémoire tampon arrière pour le copier vers la mémoire tampon frontale. Si la latence de ce bloc est trop longue, utilisez la TryLock méthode pour attendre un court délai, puis débloquer le thread d’interface utilisateur pour effectuer d’autres tâches pendant que la mémoire tampon arrière est verrouillée.

Voir aussi

• TryLock(Duration)
• Unlock()