diff --git a/src/Tests/UnitTest/TestComponentCSharp_Tests.cs b/src/Tests/UnitTest/TestComponentCSharp_Tests.cs
index d5830fae2..c90d26f41 100644
--- a/src/Tests/UnitTest/TestComponentCSharp_Tests.cs
+++ b/src/Tests/UnitTest/TestComponentCSharp_Tests.cs
@@ -1815,6 +1815,27 @@ public void TestAsyncAction()
             Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
+        [Fact]
+        public void TestAsyncActionWait()
+        {
+            var asyncAction = TestObject.DoitAsync();
+            TestObject.CompleteAsync();
+            asyncAction.Wait();
+            Assert.Equal(AsyncStatus.Completed, asyncAction.Status);
+
+            asyncAction = TestObject.DoitAsync();
+            TestObject.CompleteAsync(E_FAIL);
+            var e = Assert.Throws<AggregateException>(() => asyncAction.Wait());
+            Assert.Equal(E_FAIL, e.InnerException.HResult);
+            Assert.Equal(AsyncStatus.Error, asyncAction.Status);
+
+            asyncAction = TestObject.DoitAsync();
+            asyncAction.Cancel();
+            e = Assert.Throws<AggregateException>(() => asyncAction.Wait());
+            Assert.True(e.InnerException is TaskCanceledException);
+            Assert.Equal(AsyncStatus.Canceled, asyncAction.Status);
+        }
+
         [Fact]
         public void TestAsyncActionRoundTrip()
         {
@@ -1882,6 +1903,27 @@ public void TestAsyncActionWithProgress()
             Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
+        [Fact]
+        public void TestAsyncActionWithProgressWait()
+        {
+            var asyncAction = TestObject.DoitAsyncWithProgress();
+            TestObject.CompleteAsync();
+            asyncAction.Wait();
+            Assert.Equal(AsyncStatus.Completed, asyncAction.Status);
+
+            asyncAction = TestObject.DoitAsyncWithProgress();
+            TestObject.CompleteAsync(E_FAIL);
+            var e = Assert.Throws<AggregateException>(() => asyncAction.Wait());
+            Assert.Equal(E_FAIL, e.InnerException.HResult);
+            Assert.Equal(AsyncStatus.Error, asyncAction.Status);
+
+            asyncAction = TestObject.DoitAsyncWithProgress();
+            asyncAction.Cancel();
+            e = Assert.Throws<AggregateException>(() => asyncAction.Wait());
+            Assert.True(e.InnerException is TaskCanceledException);
+            Assert.Equal(AsyncStatus.Canceled, asyncAction.Status);
+        }
+
         async Task<int> InvokeAddAsync(int lhs, int rhs)
         {
             return await TestObject.AddAsync(lhs, rhs);
@@ -1913,6 +1955,27 @@ public void TestAsyncOperation()
             Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
+        [Fact]
+        public void TestAsyncOperationWait()
+        {
+            var asyncOperation = TestObject.AddAsync(42, 8);
+            TestObject.CompleteAsync();
+            asyncOperation.Wait();
+            Assert.Equal(AsyncStatus.Completed, asyncOperation.Status);
+
+            asyncOperation = TestObject.AddAsync(42, 8);
+            TestObject.CompleteAsync(E_FAIL);
+            var e = Assert.Throws<AggregateException>(() => asyncOperation.Wait());
+            Assert.Equal(E_FAIL, e.InnerException.HResult);
+            Assert.Equal(AsyncStatus.Error, asyncOperation.Status);
+
+            asyncOperation = TestObject.AddAsync(42, 8);
+            asyncOperation.Cancel();
+            e = Assert.Throws<AggregateException>(() => asyncOperation.Wait());
+            Assert.True(e.InnerException is TaskCanceledException);
+            Assert.Equal(AsyncStatus.Canceled, asyncOperation.Status);
+        }
+
 
         [Fact]
         public void TestAsyncOperationRoundTrip()
@@ -1983,6 +2046,27 @@ public void TestAsyncOperationWithProgress()
             Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
+        [Fact]
+        public void TestAsyncOperationWithProgressWait()
+        {
+            var asyncOperation = TestObject.AddAsyncWithProgress(42, 8);
+            TestObject.CompleteAsync();
+            asyncOperation.Wait();
+            Assert.Equal(AsyncStatus.Completed, asyncOperation.Status);
+
+            asyncOperation = TestObject.AddAsyncWithProgress(42, 8);
+            TestObject.CompleteAsync(E_FAIL);
+            var e = Assert.Throws<AggregateException>(() => asyncOperation.Wait());
+            Assert.Equal(E_FAIL, e.InnerException.HResult);
+            Assert.Equal(AsyncStatus.Error, asyncOperation.Status);
+
+            asyncOperation = TestObject.AddAsyncWithProgress(42, 8);
+            asyncOperation.Cancel();
+            e = Assert.Throws<AggregateException>(() => asyncOperation.Wait());
+            Assert.True(e.InnerException is TaskCanceledException);
+            Assert.Equal(AsyncStatus.Canceled, asyncOperation.Status);
+        }
+
         [Fact]
         public void TestPointTypeMapping()
         {
diff --git a/src/cswinrt/strings/additions/Windows.Foundation/AsyncInfo.cs b/src/cswinrt/strings/additions/Windows.Foundation/AsyncInfo.cs
index c43aaac31..81378030f 100644
--- a/src/cswinrt/strings/additions/Windows.Foundation/AsyncInfo.cs
+++ b/src/cswinrt/strings/additions/Windows.Foundation/AsyncInfo.cs
@@ -121,28 +121,28 @@ public static IAsyncOperationWithProgress<TResult, TProgress> Run<TResult, TProg
 
         #region Factory methods for creating IAsyncInfo instances that have already completed synchronously
 
-        internal static IAsyncAction CreateCompletedAction()
+        public static IAsyncAction CompletedAction()
         {
             var asyncInfo = new TaskToAsyncActionAdapter(isCanceled: false);
             return asyncInfo;
         }
 
 
-        internal static IAsyncActionWithProgress<TProgress> CreateCompletedAction<TProgress>()
+        public static IAsyncActionWithProgress<TProgress> CompletedActionWithProgress<TProgress>()
         {
             var asyncInfo = new TaskToAsyncActionWithProgressAdapter<TProgress>(isCanceled: false);
             return asyncInfo;
         }
 
 
-        internal static IAsyncOperation<TResult> CreateCompletedOperation<TResult>(TResult synchronousResult)
+        public static IAsyncOperation<TResult> FromResult<TResult>(TResult synchronousResult)
         {
             var asyncInfo = new TaskToAsyncOperationAdapter<TResult>(synchronousResult);
             return asyncInfo;
         }
 
 
-        internal static IAsyncOperationWithProgress<TResult, TProgress> CreateCompletedOperation<TResult, TProgress>(TResult synchronousResult)
+        public static IAsyncOperationWithProgress<TResult, TProgress> FromResultWithProgress<TResult, TProgress>(TResult synchronousResult)
         {
             var asyncInfo = new TaskToAsyncOperationWithProgressAdapter<TResult, TProgress>(synchronousResult);
             return asyncInfo;
@@ -150,10 +150,9 @@ internal static IAsyncOperationWithProgress<TResult, TProgress> CreateCompletedO
 
         #endregion Factory methods for creating IAsyncInfo instances that have already completed synchronously
 
-
         #region Factory methods for creating IAsyncInfo instances that have already completed synchronously with an error
 
-        internal static IAsyncAction CreateFaultedAction(Exception error)
+        public static IAsyncAction FromException(Exception error)
         {
             if (error == null)
                 throw new ArgumentNullException(nameof(error));
@@ -167,7 +166,7 @@ internal static IAsyncAction CreateFaultedAction(Exception error)
         }
 
 
-        internal static IAsyncActionWithProgress<TProgress> CreateFaultedAction<TProgress>(Exception error)
+        public static IAsyncActionWithProgress<TProgress> FromExceptionWithProgress<TProgress>(Exception error)
         {
             if (error == null)
                 throw new ArgumentNullException(nameof(error));
@@ -181,7 +180,7 @@ internal static IAsyncActionWithProgress<TProgress> CreateFaultedAction<TProgres
         }
 
 
-        internal static IAsyncOperation<TResult> CreateFaultedOperation<TResult>(Exception error)
+        public static IAsyncOperation<TResult> FromException<TResult>(Exception error)
         {
             if (error == null)
                 throw new ArgumentNullException(nameof(error));
@@ -195,7 +194,7 @@ internal static IAsyncOperation<TResult> CreateFaultedOperation<TResult>(Excepti
         }
 
 
-        internal static IAsyncOperationWithProgress<TResult, TProgress> CreateFaultedOperation<TResult, TProgress>(Exception error)
+        public static IAsyncOperationWithProgress<TResult, TProgress> FromExceptionWithProgress<TResult, TProgress>(Exception error)
         {
             if (error == null)
                 throw new ArgumentNullException(nameof(error));
@@ -207,7 +206,39 @@ internal static IAsyncOperationWithProgress<TResult, TProgress> CreateFaultedOpe
 
             return asyncInfo;
         }
+
         #endregion Factory methods for creating IAsyncInfo instances that have already completed synchronously with an error
 
+        #region Factory methods for creating IAsyncInfo instances that have already been canceled synchronously
+
+        public static IAsyncAction CanceledAction()
+        {
+            var asyncInfo = new TaskToAsyncActionAdapter(isCanceled: true);
+            return asyncInfo;
+        }
+
+
+        public static IAsyncActionWithProgress<TProgress> CanceledActionWithProgress<TProgress>()
+        {
+            var asyncInfo = new TaskToAsyncActionWithProgressAdapter<TProgress>(isCanceled: true);
+            return asyncInfo;
+        }
+
+
+        public static IAsyncOperation<TResult> CanceledOperation<TResult>()
+        {
+            var asyncInfo = new TaskToAsyncOperationAdapter<TResult>(isCanceled: true);
+            return asyncInfo;
+        }
+
+
+        public static IAsyncOperationWithProgress<TResult, TProgress> CanceledOperationWithProgress<TResult, TProgress>()
+        {
+            var asyncInfo = new TaskToAsyncOperationWithProgressAdapter<TResult, TProgress>(isCanceled: true);
+            return asyncInfo;
+        }
+
+        #endregion Factory methods for creating IAsyncInfo instances that have already been canceled synchronously
+
     }  // class AsyncInfo
 }  // namespace
diff --git a/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationAdapter.cs b/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationAdapter.cs
index 6cf370263..e8c7f0b24 100644
--- a/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationAdapter.cs
+++ b/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationAdapter.cs
@@ -39,6 +39,13 @@ internal TaskToAsyncOperationAdapter(TResult synchronousResult)
         {
         }
 
+        internal TaskToAsyncOperationAdapter(bool isCanceled)
+            : base(default(TResult))
+        {
+            if (isCanceled)
+                DangerousSetCanceled();
+        }
+
         public TResult GetResults()
         {
             return GetResultsInternal();
diff --git a/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationWithProgressAdapter.cs b/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationWithProgressAdapter.cs
index e933814a9..9307b67f9 100644
--- a/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationWithProgressAdapter.cs
+++ b/src/cswinrt/strings/additions/Windows.Foundation/TaskToAsyncOperationWithProgressAdapter.cs
@@ -44,6 +44,13 @@ internal TaskToAsyncOperationWithProgressAdapter(TResult synchronousResult)
         {
         }
 
+        internal TaskToAsyncOperationWithProgressAdapter(bool isCanceled)
+            : base(default(TResult))
+        {
+            if (isCanceled)
+                DangerousSetCanceled();
+        }
+
         public TResult GetResults()
         {
             return GetResultsInternal();
diff --git a/src/cswinrt/strings/additions/Windows.Foundation/Windows.Foundation.cs b/src/cswinrt/strings/additions/Windows.Foundation/Windows.Foundation.cs
index c27bf8c79..506ecfe76 100644
--- a/src/cswinrt/strings/additions/Windows.Foundation/Windows.Foundation.cs
+++ b/src/cswinrt/strings/additions/Windows.Foundation/Windows.Foundation.cs
@@ -61,6 +61,11 @@ public static TaskAwaiter GetAwaiter(this IAsyncAction source)
             return AsTask(source).GetAwaiter();
         }
 
+        public static void Wait(this IAsyncAction source)
+        {
+            AsTask(source).Wait();
+        }
+
         public static Task<TResult> AsTask<TResult>(this IAsyncOperation<TResult> source, CancellationToken cancellationToken)
         {
             if (source == null)
@@ -104,6 +109,16 @@ public static TaskAwaiter<TResult> GetAwaiter<TResult>(this IAsyncOperation<TRes
             return AsTask(source).GetAwaiter();
         }
 
+        public static void Wait<TResult>(this IAsyncOperation<TResult> source)
+        {
+            AsTask(source).Wait();
+        }
+
+        public static TResult Get<TResult>(this IAsyncOperation<TResult> source)
+        {
+            return AsTask(source).Result;
+        }
+
         public static Task AsTask<TProgress>(this IAsyncActionWithProgress<TProgress> source, CancellationToken cancellationToken, IProgress<TProgress> progress)
         {
             if (source == null)
@@ -169,6 +184,11 @@ public static TaskAwaiter GetAwaiter<TProgress>(this IAsyncActionWithProgress<TP
             return AsTask(source).GetAwaiter();
         }
 
+        public static void Wait<TProgress>(this IAsyncActionWithProgress<TProgress> source)
+        {
+            AsTask(source).Wait();
+        }
+
         public static Task<TResult> AsTask<TResult, TProgress>(this IAsyncOperationWithProgress<TResult, TProgress> source, CancellationToken cancellationToken, IProgress<TProgress> progress)
         {
             if (source == null)
@@ -234,6 +254,16 @@ public static TaskAwaiter<TResult> GetAwaiter<TResult, TProgress>(this IAsyncOpe
             return AsTask(source).GetAwaiter();
         }
 
+        public static void Wait<TResult, TProgress>(this IAsyncOperationWithProgress<TResult, TProgress> source)
+        {
+            AsTask(source).Wait();
+        }
+
+        public static TResult Get<TResult, TProgress>(this IAsyncOperationWithProgress<TResult, TProgress> source)
+        {
+            return AsTask(source).Result;
+        }
+
         public static IAsyncAction AsAsyncAction(this Task source)
         {
             if (source == null)
diff --git a/src/cswinrt/strings/additions/Windows.Storage.Streams/StreamOperationsImplementation.cs b/src/cswinrt/strings/additions/Windows.Storage.Streams/StreamOperationsImplementation.cs
index b14a652a5..e297596ba 100644
--- a/src/cswinrt/strings/additions/Windows.Storage.Streams/StreamOperationsImplementation.cs
+++ b/src/cswinrt/strings/additions/Windows.Storage.Streams/StreamOperationsImplementation.cs
@@ -53,11 +53,11 @@ internal static IAsyncOperationWithProgress<IBuffer, uint> ReadAsync_MemoryStrea
                 if (dataBuffer.Length > 0)
                     memStream.Seek(dataBuffer.Length, SeekOrigin.Current);
 
-                return AsyncInfo.CreateCompletedOperation<IBuffer, uint>(dataBuffer);
+                return AsyncInfo.FromResultWithProgress<IBuffer, uint>(dataBuffer);
             }
             catch (Exception ex)
             {
-                return AsyncInfo.CreateFaultedOperation<IBuffer, uint>(ex);
+                return AsyncInfo.FromExceptionWithProgress<IBuffer, uint>(ex);
             }
         }  // ReadAsync_MemoryStream