The D3DImagePresentationTarget is derived from the WPF Image element and hosts a D3DImage as the image source.

The D3DImage manages two buffers: the back buffer and the front buffer. DigitalRune Graphics renders content into the back buffer using Direct3D 11. WPF copies the content of the back buffer into the front buffer and displays the result using Direct3D 9. See D3DImage documentation for additional information.

When content is rendered into the back buffer, the back buffer is automatically marked as dirty to notify WPF that the front buffer needs to be updated. You can also manually mark the back buffer as dirty to trigger an update of the front buffer. The following example shows how to mark all registered D3DImages as dirty.

foreach (var presentationTarget in _graphicsService.PresentationTargets)
{
    var d3dImagePresentationTarget = presentationTarget as D3DImagePresentationTarget;
    if (d3dImagePresentationTarget != null && d3dImagePresentationTarget.IsVisible)
    {
        var d3DImage = (D3DImage)d3dImagePresentationTarget.Source;
        d3DImage.Lock();
        d3DImage.AddDirtyRect(new Int32Rect(0, 0, d3DImage.PixelWidth, d3DImage.PixelHeight));
        d3DImage.Unlock();
    }
}

It is usually not necessary to manually trigger the update of the front buffer. However, if you run into synchronization problems, as described below, this may be relevant.

Synchronization:
By default, the Direct3D 11 device used for rendering is not synchronized with Direct3D 9 (WPF). Direct3D 11 and Direct3D 9 run asynchronously. The image shown in WPF may be one or more frames old. Setting IsSynchronized ensures that the devices run in sync and that WPF always shows the current frame.

However, synchronizing Direct3D 11 and Direct3D 9 is costly. When switching from Direct3D 11 to Direct3D 9 (and vice versa) the CPU needs to be blocked until the GPU is flushed. This reduces performance. Therefore, synchronization is disabled by default.

To avoid synchronization problems, you need to apply one of these 3 solutions:

1. Continuous rendering - Most interactive applications continuously render new frames - usually 30 or 60 frames per second. In this case, synchronization is not a problem: The image shown in WPF may lag one or more frames behind, but WPF will eventually catch up and show the new frame. (IsSynchronized should be set to for optimal performance!)
2. Enable synchronization - Explicit synchronization can be enabled by setting IsSynchronized to . This ensures that WPF always shows the new frame. However, as mentioned above, this synchronization greatly reduces performance. The CPU is blocked until the Direct3D 11 device has finished rendering the new frame.
3. Manual invalidation - There is a third solution that does not require continuously rendering new frames or using explicit synchronization: Render the new frame and then poll IsFrameReady. When this property returns true, manually trigger an update of the front buffer, as described above.

Clean-up:
Be sure to remove the D3DImagePresentationTarget from the IGraphicsService when it is no longer needed - usually when the element is Unloaded. This ensures that all unmanaged resources are properly disposed of.

Reference