I am using a background thread to update a CanvasVirtualControl because the redraw time has started to affect the UI thread (there are a lot of complex objects and text).

I am using option 1 from the CreateDrawingSession remarks:

On an arbitrary non-UI thread:
CreateDrawingSession
Issue drawing calls
SuspendDrawingSession(CanvasDrawingSession)
Back on the UI thread:
drawingSession.Dispose()

When the update is lightweight, everything seems to be fine. Once the update starts to consume time, I start getting ComException 0x80004005. I get the exception consistently by calling Invalidate while the drawing session is open.

Below are the page SizeChanged method, the RegionsInvalidated method (which enqueues the invalid rectangles and verifies the background task is running) and the actual redraw method.

    private void Page_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        scalingFactor = (float)Math.Max(1F, Math.Min(e.NewSize.Height / 20, e.NewSize.Width / 40));

        lock (((System.Collections.ICollection)redrawRegions).SyncRoot)
        {
            redrawRegions.Clear();
        }

        try
        {
            MyCanvas.Invalidate(); // <== this will throw a COMException 0x8004005 if a redraw is active
        }
        catch (Exception ex )
        {
            throw;
        }
    }

    private void BackgroundCanvasRedraw(CanvasVirtualControl sender)
    {
        bool keepGoing = true;
        while ( keepGoing )
        {
            Rect r;
            lock (((System.Collections.ICollection)redrawRegions).SyncRoot)
            {
                if ( redrawRegions.Count > 0 )
                {
                    r = redrawRegions.Dequeue();
                }
                else
                {
                    keepGoing = false;
                }
            } // lock

            if (keepGoing)
            {
                CanvasDrawingSession cds;
                try
                {
                     cds = sender.CreateDrawingSession(r); // Step 1, Create drawing session
                }
                catch( System.ArgumentException ) 
                { // rect no longer fits inside current canvas / canvas must have changed size
                    cds = null;
                }

                if ( cds != null )
                {
                    Matrix3x2 m = Matrix3x2.CreateScale(scalingFactor);
                    cds.Transform = m;

                    cds.FillCircle(10, 10, 10, Colors.Red ); // Step 2, drawing calls

                    // comment out the below line and it works
                    Task.Delay(1000).Wait(); // simulate heavy computation / lots of drawing calls

                    cds.FillCircle(20, 10, 10, Colors.Blue); // last drawing call

                    sender.SuspendDrawingSession(cds); // Step 3, suspend

                    IAsyncAction aa = Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
                                 () => { cds.Dispose(); }); // Step 4, dispose on UI thread

                    aa.AsTask().Wait();  // Is it bad to open a new drawing session before the previous is disposed?  Guarantee completion for now
                }
            }
        }
    }

    private void MyCanvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
    {
        lock (((System.Collections.ICollection)redrawRegions).SyncRoot)
        {
            foreach (Rect r in args.InvalidatedRegions)
            {
                redrawRegions.Enqueue(r);
            }
        }

        if ( tBackgroundRedraw.IsCompleted )
        {
            tBackgroundRedraw = Task.Run( () => BackgroundCanvasRedraw(sender));
        }
    }