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 d’arrière-mémoire à 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 est verrouillé, le système de rendu n’envoie pas de mises à jour tant que le WriteableBitmap n’est pas complètement déverrouillé par des 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 d’arrière-mémoire à d’autres threads. Lorsque le thread de travail a terminé un frame, le thread d’interface utilisateur ajoute des rectangles modifiés et déverrouille la mémoire tampon.

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

S’applique à

Voir aussi

• TryLock(Duration)
• Unlock()