Moving core logic of FromAsyncPattern to observers.

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/FromAsyncPattern.Generated.cs

@@ -23,23 +23,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end);
                 }
                 catch (Exception ex)
                 {
@@ -63,23 +47,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1);
                 }
                 catch (Exception ex)
                 {
@@ -103,23 +71,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2);
                 }
                 catch (Exception ex)
                 {
@@ -143,23 +95,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3);
                 }
                 catch (Exception ex)
                 {
@@ -183,23 +119,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4);
                 }
                 catch (Exception ex)
                 {
@@ -223,23 +143,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5);
                 }
                 catch (Exception ex)
                 {
@@ -263,23 +167,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6);
                 }
                 catch (Exception ex)
                 {
@@ -303,23 +191,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
                 }
                 catch (Exception ex)
                 {
@@ -343,23 +215,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
                 }
                 catch (Exception ex)
                 {
@@ -383,23 +239,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
                 }
                 catch (Exception ex)
                 {
@@ -423,23 +263,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
                 }
                 catch (Exception ex)
                 {
@@ -463,23 +287,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
                 }
                 catch (Exception ex)
                 {
@@ -503,23 +311,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
                 }
                 catch (Exception ex)
                 {
@@ -543,23 +335,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
                 }
                 catch (Exception ex)
                 {
@@ -583,23 +359,7 @@ namespace System.Reactive.Linq
 
                 try
                 {
-                    begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
                 }
                 catch (Exception ex)
                 {
@@ -617,11 +377,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return () =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, IAsyncObservable<Unit>> FromAsyncPattern<T1>(Func<T1, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -631,11 +401,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2>(Func<T1, T2, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -645,11 +425,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3>(Func<T1, T2, T3, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -659,11 +449,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4>(Func<T1, T2, T3, T4, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -673,11 +473,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -687,11 +497,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6>(Func<T1, T2, T3, T4, T5, T6, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -701,11 +521,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7>(Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -715,11 +545,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, T8, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8>(Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -729,11 +569,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -743,11 +593,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -757,11 +617,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -771,11 +641,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -785,11 +665,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -799,11 +689,21 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
         }
 
         public static Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IAsyncObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
@@ -813,11 +713,685 @@ namespace System.Reactive.Linq
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) =>
             {
-                end(iar);
-                return Unit.Default;
-            });
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
+        }
+
+    }
+
+    partial class AsyncObserver
+    {
+        public static IAsyncResult FromAsyncPattern<TResult>(IAsyncObserver<TResult> observer, Func<AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, TResult>(IAsyncObserver<TResult> observer, Func<T1, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(IAsyncObserver<TResult> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+        public static IAsyncResult FromAsyncPattern(IAsyncObserver<Unit> observer, Func<AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            });
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1>(IAsyncObserver<Unit> observer, Func<T1, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2>(IAsyncObserver<Unit> observer, Func<T1, T2, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
+        }
+
+        public static IAsyncResult FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(IAsyncObserver<Unit> observer, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, Unit> end, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
+            {
+                end(iar);
+                return Unit.Default;
+            }, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
         }
 
     }

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/FromAsyncPattern.Generated.tt

@@ -27,6 +27,13 @@ for (var i = 0; i <= 14; i++)
 
     var begin = "Func<" + string.Join(", ", Enumerable.Range(1, i).Select(j => "T" + j).Concat(new[] { "AsyncCallback, object, IAsyncResult" })) + ">";
     var end = "Func<IAsyncResult, TResult>";
+
+    var invokeArgs = pars;
+
+    if (i > 0)
+    {
+        invokeArgs = ", " + invokeArgs;
+    }
 #>
         public static <#=ret#> FromAsyncPattern<<#=genArgs#>>(<#=begin#> begin, <#=end#> end)
         {
@@ -41,23 +48,7 @@ for (var i = 0; i <= 14; i++)
 
                 try
                 {
-                    begin(<#=pars + (i > 0 ? ", " : "")#>async iar =>
-                    {
-                        TResult result;
-
-                        try
-                        {
-                            result = end(iar);
-                        }
-                        catch (Exception ex)
-                        {
-                            await subject.OnErrorAsync(ex).ConfigureAwait(false);
-                            return;
-                        }
-
-                        await subject.OnNextAsync(result).ConfigureAwait(false);
-                        await subject.OnCompletedAsync().ConfigureAwait(false);
-                    }, null);
+                    AsyncObserver.FromAsyncPattern(subject, begin, end<#=invokeArgs#>);
                 }
                 catch (Exception ex)
                 {
@@ -87,6 +78,13 @@ for (var i = 0; i <= 14; i++)
     {
         genArgs = "<" + genArgs + ">";
     }
+
+    var invokeArgs = pars;
+
+    if (i > 0)
+    {
+        invokeArgs = ", " + invokeArgs;
+    }
 #>
         public static <#=ret#> FromAsyncPattern<#=genArgs#>(<#=begin#> begin, <#=end#> end)
         {
@@ -95,11 +93,120 @@ for (var i = 0; i <= 14; i++)
             if (end == null)
                 throw new ArgumentNullException(nameof(end));
 
-            return FromAsyncPattern(begin, iar =>
+            return (<#=pars#>) =>
+            {
+                var subject = new SequentialAsyncAsyncSubject<Unit>();
+
+                try
+                {
+                    AsyncObserver.FromAsyncPattern(subject, begin, end<#=invokeArgs#>);
+                }
+                catch (Exception ex)
+                {
+                    return Throw<Unit>(ex);
+                }
+
+                return subject.AsAsyncObservable();
+            };
+        }
+
+<#
+}
+#>
+    }
+
+    partial class AsyncObserver
+    {
+<#
+for (var i = 0; i <= 14; i++)
+{
+    var args = Enumerable.Range(1, i).Select(j => "T" + j).Concat(new[] { "IAsyncObservable<TResult>" });
+    var ret = "Func<" + string.Join(", ", args) + ">";
+
+    var genArgs = string.Join(", ", Enumerable.Range(1, i).Select(j => "T" + j).Concat(new[] { "TResult" }));
+    var pars = string.Join(", ", Enumerable.Range(1, i).Select(j => "arg" + j));
+
+    var begin = "Func<" + string.Join(", ", Enumerable.Range(1, i).Select(j => "T" + j).Concat(new[] { "AsyncCallback, object, IAsyncResult" })) + ">";
+    var end = "Func<IAsyncResult, TResult>";
+
+    var invokePars = string.Join(", ", Enumerable.Range(1, i).Select(j => "T" + j + " arg" + j));
+
+    if (i > 0)
+    {
+        invokePars = ", " + invokePars;
+    }
+#>
+        public static IAsyncResult FromAsyncPattern<<#=genArgs#>>(IAsyncObserver<TResult> observer, <#=begin#> begin, <#=end#> end<#=invokePars#>)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return begin(<#=pars + (i > 0 ? ", " : "")#>async iar =>
+            {
+                TResult result;
+
+                try
+                {
+                    result = end(iar);
+                }
+                catch (Exception ex)
+                {
+                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                    return;
+                }
+
+                await observer.OnNextAsync(result).ConfigureAwait(false);
+                await observer.OnCompletedAsync().ConfigureAwait(false);
+            }, null);
+        }
+
+<#
+}
+#>
+<#
+for (var i = 0; i <= 14; i++)
+{
+    var args = Enumerable.Range(1, i).Select(j => "T" + j).Concat(new[] { "IAsyncObservable<Unit>" });
+    var ret = "Func<" + string.Join(", ", args) + ">";
+
+    var genArgs = string.Join(", ", Enumerable.Range(1, i).Select(j => "T" + j));
+    var pars = string.Join(", ", Enumerable.Range(1, i).Select(j => "arg" + j));
+
+    var begin = "Func<" + string.Join(", ", Enumerable.Range(1, i).Select(j => "T" + j).Concat(new[] { "AsyncCallback, object, IAsyncResult" })) + ">";
+    var end = "Func<IAsyncResult, Unit>";
+
+    if (genArgs != "")
+    {
+        genArgs = "<" + genArgs + ">";
+    }
+
+    var invokePars = string.Join(", ", Enumerable.Range(1, i).Select(j => "T" + j + " arg" + j));
+    var invokeArgs = pars;
+
+    if (i > 0)
+    {
+        invokePars = ", " + invokePars;
+        invokeArgs = ", " + invokeArgs;
+    }
+#>
+        public static IAsyncResult FromAsyncPattern<#=genArgs#>(IAsyncObserver<Unit> observer, <#=begin#> begin, <#=end#> end<#=invokePars#>)
+        {
+            if (observer == null)
+                throw new ArgumentNullException(nameof(observer));
+            if (begin == null)
+                throw new ArgumentNullException(nameof(begin));
+            if (end == null)
+                throw new ArgumentNullException(nameof(end));
+
+            return FromAsyncPattern(observer, begin, iar =>
             {
                 end(iar);
                 return Unit.Default;
-            });
+            }<#=invokeArgs#>);
         }
 
 <#