diff --git a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_WriteBatching.cs b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_WriteBatching.cs
index a6d2642944eaba8d0f00ca22b9db63a2ac41db94..783d1ac68aecbb47f3e72e80227f00c796cdbdcd 100644
--- a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_WriteBatching.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_WriteBatching.cs
@@ -77,29 +77,41 @@ internal partial class SQLitePersistentStorage
             // thread for this queue+key, and a TaskCompletionSource we can use to let
             // other threads know about our own progress writing any new writes in this queue.
             var (previousWritesTask, taskCompletionSource) = await GetWriteTaskAsync().ConfigureAwait(false);
-
-            // Wait for all previous writes to be flushed.
-            await previousWritesTask.ConfigureAwait(false);
-
-            if (writesToProcess.Count == 0)
+            try
             {
-                // No additional writes for us to flush.  We can immediately bail out.
-                Debug.Assert(taskCompletionSource == null);
-                return;
-            }
+                // Wait for all previous writes to be flushed.
+                await previousWritesTask.ConfigureAwait(false);
 
-            // Now, if we have writes of our own, do them on this thread.
-            // 
-            // Note: this flushing is not cancellable.  We've already removed the
-            // writes from the write queue.  If we were not to write them out we
-            // would be losing data.
-            Debug.Assert(taskCompletionSource != null);
+                if (writesToProcess.Count == 0)
+                {
+                    // No additional writes for us to flush.  We can immediately bail out.
+                    Debug.Assert(taskCompletionSource == null);
+                    return;
+                }
 
-            ProcessWriteQueue(connection, writesToProcess);
+                // Now, if we have writes of our own, do them on this thread.
+                // 
+                // Note: this flushing is not cancellable.  We've already removed the
+                // writes from the write queue.  If we were not to write them out we
+                // would be losing data.
+                Debug.Assert(taskCompletionSource != null);
 
-            // Mark our TCS as completed.  Any other threads waiting on us will now be able
-            // to proceed.
-            taskCompletionSource.TrySetResult(0);
+                ProcessWriteQueue(connection, writesToProcess);
+            }
+            catch (OperationCanceledException ex)
+            {
+                taskCompletionSource?.TrySetCanceled(ex.CancellationToken);
+            }
+            catch (Exception ex)
+            {
+                taskCompletionSource?.TrySetException(ex);
+            }
+            finally
+            {
+                // Mark our TCS as completed.  Any other threads waiting on us will now be able
+                // to proceed.
+                taskCompletionSource?.TrySetResult(0);
+            }
 
             return;