Merge pull request #1395 from danielcweber/AvoidClosures2

Avoid even more closures with an additional overload of AsyncObservable.Create

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/AsyncObservable.cs

@@ -9,23 +9,58 @@ namespace System.Reactive.Linq
 {
     public static partial class AsyncObservable
     {
-        private sealed class AsyncObservableImpl<TSource, TResult> : AsyncObservableBase<TResult>
+        internal static class CreateAsyncObservable<TResult>
         {
-            private readonly IAsyncObservable<TSource> _source;
-            private readonly Func<IAsyncObservable<TSource>, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> _subscribeAsync;
+            private sealed class AsyncObservableImpl<TSource> : AsyncObservableBase<TResult>
+            {
+                private readonly IAsyncObservable<TSource> _source;
+                private readonly Func<IAsyncObservable<TSource>, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> _subscribeAsync;
+
+                public AsyncObservableImpl(IAsyncObservable<TSource> source, Func<IAsyncObservable<TSource>, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> subscribeAsync)
+                {
+                    _source = source ?? throw new ArgumentNullException(nameof(source));
+                    _subscribeAsync = subscribeAsync ?? throw new ArgumentNullException(nameof(subscribeAsync));
+                }
+
+                protected override ValueTask<IAsyncDisposable> SubscribeAsyncCore(IAsyncObserver<TResult> observer)
+                {
+                    if (observer == null)
+                        throw new ArgumentNullException(nameof(observer));
 
-            public AsyncObservableImpl(IAsyncObservable<TSource> source, Func<IAsyncObservable<TSource>, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> subscribeAsync)
+                    return _subscribeAsync(_source, observer);
+                }
+            }
+
+            private sealed class AsyncObservableImpl<TSource, TState> : AsyncObservableBase<TResult>
             {
-                _source = source;
-                _subscribeAsync = subscribeAsync ?? throw new ArgumentNullException(nameof(subscribeAsync));
+                private readonly TState _state;
+                private readonly IAsyncObservable<TSource> _source;
+                private readonly Func<IAsyncObservable<TSource>, TState, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> _subscribeAsync;
+
+                public AsyncObservableImpl(IAsyncObservable<TSource> source, TState state, Func<IAsyncObservable<TSource>, TState, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> subscribeAsync)
+                {
+                    _state = state;
+                    _source = source ?? throw new ArgumentNullException(nameof(source));
+                    _subscribeAsync = subscribeAsync ?? throw new ArgumentNullException(nameof(subscribeAsync));
+                }
+
+                protected override ValueTask<IAsyncDisposable> SubscribeAsyncCore(IAsyncObserver<TResult> observer)
+                {
+                    if (observer == null)
+                        throw new ArgumentNullException(nameof(observer));
+
+                    return _subscribeAsync(_source, _state, observer);
+                }
             }
 
-            protected override ValueTask<IAsyncDisposable> SubscribeAsyncCore(IAsyncObserver<TResult> observer)
+            public static IAsyncObservable<TResult> From<TSource>(IAsyncObservable<TSource> source, Func<IAsyncObservable<TSource>, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> subscribeAsync)
             {
-                if (observer == null)
-                    throw new ArgumentNullException(nameof(observer));
+                return new AsyncObservableImpl<TSource>(source, subscribeAsync);
+            }
 
-                return _subscribeAsync(_source, observer);
+            public static IAsyncObservable<TResult> From<TSource, TState>(IAsyncObservable<TSource> source, TState state, Func<IAsyncObservable<TSource>, TState, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> subscribeAsync)
+            {
+                return new AsyncObservableImpl<TSource, TState>(source, state, subscribeAsync);
             }
         }
 
@@ -39,10 +74,12 @@ namespace System.Reactive.Linq
 
         internal static IAsyncObservable<TResult> Create<TSource, TResult>(IAsyncObservable<TSource> source, Func<IAsyncObservable<TSource>, IAsyncObserver<TResult>, ValueTask<IAsyncDisposable>> subscribeAsync)
         {
-            if (subscribeAsync == null)
-                throw new ArgumentNullException(nameof(subscribeAsync));
+            return CreateAsyncObservable<TResult>.From(source, subscribeAsync);
+        }
 
-            return new AsyncObservableImpl<TSource, TResult>(source, subscribeAsync);
+        internal static IAsyncObservable<TSource> Create<TSource, TState>(IAsyncObservable<TSource> source, TState state, Func<IAsyncObservable<TSource>, TState, IAsyncObserver<TSource>, ValueTask<IAsyncDisposable>> subscribeAsync)
+        {
+            return CreateAsyncObservable<TSource>.From(source, state, subscribeAsync);
         }
 
         internal static IAsyncObservable<TSource> Create<TSource>(IAsyncObservable<TSource> source, Func<IAsyncObservable<TSource>, IAsyncObserver<TSource>, ValueTask<IAsyncDisposable>> subscribeAsync)

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Aggregate.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, func)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                func,
+                static (source, func, observer) => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, func)));
         }
 
         public static IAsyncObservable<TSource> Aggregate<TSource>(this IAsyncObservable<TSource> source, Func<TSource, TSource, ValueTask<TSource>> func)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, func)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                func,
+                static (source, func, observer) => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, func)));
         }
 
         public static IAsyncObservable<TResult> Aggregate<TSource, TResult>(this IAsyncObservable<TSource> source, TResult seed, Func<TResult, TSource, TResult> func)
@@ -35,7 +41,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, seed, func)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (seed, func),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, state.seed, state.func)));
         }
 
         public static IAsyncObservable<TResult> Aggregate<TSource, TResult>(this IAsyncObservable<TSource> source, TResult seed, Func<TResult, TSource, ValueTask<TResult>> func)
@@ -45,7 +54,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, seed, func)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (seed, func),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, state.seed, state.func)));
         }
 
         public static IAsyncObservable<TResult> Aggregate<TSource, TAccumulate, TResult>(this IAsyncObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
@@ -57,7 +69,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, seed, func, resultSelector)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (seed, func, resultSelector),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, state.seed, state.func, state.resultSelector)));
         }
 
         public static IAsyncObservable<TResult> Aggregate<TSource, TAccumulate, TResult>(this IAsyncObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> func, Func<TAccumulate, ValueTask<TResult>> resultSelector)
@@ -69,7 +84,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, seed, func, resultSelector)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (seed, func, resultSelector),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Aggregate(observer, state.seed, state.func, state.resultSelector)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/All.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<bool>(observer => source.SubscribeSafeAsync(AsyncObserver.All(observer, predicate)));
+            return CreateAsyncObservable<bool>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.All(observer, predicate)));
         }
 
         public static IAsyncObservable<bool> All<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<bool>(observer => source.SubscribeSafeAsync(AsyncObserver.All(observer, predicate)));
+            return CreateAsyncObservable<bool>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.All(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Amb.cs

@@ -19,20 +19,23 @@ namespace System.Reactive.Linq
             if (second == null)
                 throw new ArgumentNullException(nameof(second));
 
-            return Create<TSource>(async observer =>
-            {
-                var firstSubscription = new SingleAssignmentAsyncDisposable();
-                var secondSubscription = new SingleAssignmentAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                first,
+                second,
+                static async (first, second, observer) =>
+                {
+                    var firstSubscription = new SingleAssignmentAsyncDisposable();
+                    var secondSubscription = new SingleAssignmentAsyncDisposable();
 
-                var (firstObserver, secondObserver) = AsyncObserver.Amb(observer, firstSubscription, secondSubscription);
+                    var (firstObserver, secondObserver) = AsyncObserver.Amb(observer, firstSubscription, secondSubscription);
 
-                var firstTask = first.SubscribeSafeAsync(firstObserver).AsTask().ContinueWith(d => firstSubscription.AssignAsync(d.Result).AsTask()).Unwrap();
-                var secondTask = second.SubscribeSafeAsync(secondObserver).AsTask().ContinueWith(d => secondSubscription.AssignAsync(d.Result).AsTask()).Unwrap();
+                    var firstTask = first.SubscribeSafeAsync(firstObserver).AsTask().ContinueWith(d => firstSubscription.AssignAsync(d.Result).AsTask()).Unwrap();
+                    var secondTask = second.SubscribeSafeAsync(secondObserver).AsTask().ContinueWith(d => secondSubscription.AssignAsync(d.Result).AsTask()).Unwrap();
 
-                await Task.WhenAll(firstTask, secondTask).ConfigureAwait(false);
+                    await Task.WhenAll(firstTask, secondTask).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
-            });
+                    return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
+                });
         }
 
         public static IAsyncObservable<TSource> Amb<TSource>(this IEnumerable<IAsyncObservable<TSource>> sources) => Amb(sources.ToArray());

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Any.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<bool>(observer => source.SubscribeSafeAsync(AsyncObserver.Any(observer, predicate)));
+            return CreateAsyncObservable<bool>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Any(observer, predicate)));
         }
 
         public static IAsyncObservable<bool> Any<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<bool>(observer => source.SubscribeSafeAsync(AsyncObserver.Any(observer, predicate)));
+            return CreateAsyncObservable<bool>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Any(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Append.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Append(observer, value)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                value,
+                static(source, value, observer) => source.SubscribeSafeAsync(AsyncObserver.Append(observer, value)));
         }
 
         public static IAsyncObservable<TSource> Append<TSource>(this IAsyncObservable<TSource> source, TSource value, IAsyncScheduler scheduler)
@@ -25,20 +28,23 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return Create(
+                source,
+                (value, scheduler),
+                async (source, state, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sink, disposable) = AsyncObserver.Append(observer, value, scheduler);
+                    var (sink, disposable) = AsyncObserver.Append(observer, state.value, state.scheduler);
 
-                await d.AddAsync(disposable).ConfigureAwait(false);
+                    await d.AddAsync(disposable).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await d.AddAsync(subscription).ConfigureAwait(false);
+                    await d.AddAsync(subscription).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
 
         public static IAsyncObservable<TSource> Append<TSource>(this IAsyncObservable<TSource> source, params TSource[] values)
@@ -48,7 +54,10 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Append(observer, values)));
+            return Create(
+                source,
+                values,
+                (source, values, observer) => source.SubscribeSafeAsync(AsyncObserver.Append(observer, values)));
         }
 
         public static IAsyncObservable<TSource> Append<TSource>(this IAsyncObservable<TSource> source, IAsyncScheduler scheduler, params TSource[] values)
@@ -60,20 +69,23 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return Create(
+                source,
+                (scheduler, values),
+                async (source, state, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sink, disposable) = AsyncObserver.Append(observer, scheduler, values);
+                    var (sink, disposable) = AsyncObserver.Append(observer, state.scheduler, state.values);
 
-                await d.AddAsync(disposable).ConfigureAwait(false);
+                    await d.AddAsync(disposable).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await d.AddAsync(subscription).ConfigureAwait(false);
+                    await d.AddAsync(subscription).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
 
         public static IAsyncObservable<TSource> Append<TSource>(this IAsyncObservable<TSource> source, IEnumerable<TSource> values)
@@ -83,7 +95,10 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Append(observer, values)));
+            return Create(
+                source,
+                values,
+                (source, values, observer) => source.SubscribeSafeAsync(AsyncObserver.Append(observer, values)));
         }
 
         public static IAsyncObservable<TSource> Append<TSource>(this IAsyncObservable<TSource> source, IAsyncScheduler scheduler, IEnumerable<TSource> values)
@@ -95,20 +110,23 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return Create(
+                source,
+                (scheduler, values),
+                async (source, state, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sink, disposable) = AsyncObserver.Append(observer, scheduler, values);
+                    var (sink, disposable) = AsyncObserver.Append(observer, state.scheduler, state.values);
 
-                await d.AddAsync(disposable).ConfigureAwait(false);
+                    await d.AddAsync(disposable).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await d.AddAsync(subscription).ConfigureAwait(false);
+                    await d.AddAsync(subscription).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
     }
 

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

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageInt32(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32>> selector)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageInt32(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Average(this IAsyncObservable<Int32?> source)
@@ -51,7 +57,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32?>> selector)
@@ -61,7 +70,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Average(this IAsyncObservable<Int64> source)
@@ -79,7 +91,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageInt64(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64>> selector)
@@ -89,7 +104,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageInt64(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Average(this IAsyncObservable<Int64?> source)
@@ -107,7 +125,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64?>> selector)
@@ -117,7 +138,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Average(this IAsyncObservable<Single> source)
@@ -135,7 +159,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single>> selector)
@@ -145,7 +172,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Average(this IAsyncObservable<Single?> source)
@@ -163,7 +193,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single?>> selector)
@@ -173,7 +206,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Average(this IAsyncObservable<Double> source)
@@ -191,7 +227,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double>> selector)
@@ -201,7 +240,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Average(this IAsyncObservable<Double?> source)
@@ -219,7 +261,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double?>> selector)
@@ -229,7 +274,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Average(this IAsyncObservable<Decimal> source)
@@ -247,7 +295,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal>> selector)
@@ -257,7 +308,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Average(this IAsyncObservable<Decimal?> source)
@@ -275,7 +329,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Average<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal?>> selector)
@@ -285,7 +342,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.AverageNullableDecimal(observer, selector)));
         }
 
     }

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

@@ -53,7 +53,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=targetTypeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=targetTypeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
         public static IAsyncObservable<<#=targetTypeName#>> <#=name#><TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<<#=sourceTypeName#>>> selector)
@@ -63,7 +66,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=targetTypeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=targetTypeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
 <#

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Buffer.cs

@@ -19,7 +19,10 @@ namespace System.Reactive.Linq
             if (count <= 0)
                 throw new ArgumentNullException(nameof(count));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.Buffer(observer, count)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                count,
+                static (source, count, observer) => source.SubscribeSafeAsync(AsyncObserver.Buffer(observer, count)));
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource>(this IAsyncObservable<TSource> source, int count, int skip)
@@ -31,7 +34,10 @@ namespace System.Reactive.Linq
             if (skip <= 0)
                 throw new ArgumentNullException(nameof(skip));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.Buffer(observer, count, skip)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (count, skip),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Buffer(observer, state.count, state.skip)));
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan)
@@ -41,14 +47,17 @@ namespace System.Reactive.Linq
             if (timeSpan < TimeSpan.Zero)
                 throw new ArgumentNullException(nameof(timeSpan));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sink, timer) = await AsyncObserver.Buffer(observer, timeSpan).ConfigureAwait(false);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                timeSpan,
+                static async (source, timeSpan, observer) =>
+                {
+                    var (sink, timer) = await AsyncObserver.Buffer(observer, timeSpan).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, IAsyncScheduler scheduler)
@@ -60,14 +69,17 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sink, timer) = await AsyncObserver.Buffer(observer, timeSpan, scheduler).ConfigureAwait(false);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (timeSpan, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sink, timer) = await AsyncObserver.Buffer(observer, state.timeSpan, state.scheduler).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift)
@@ -79,14 +91,17 @@ namespace System.Reactive.Linq
             if (timeShift < TimeSpan.Zero)
                 throw new ArgumentNullException(nameof(timeShift));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sink, timer) = await AsyncObserver.Buffer(observer, timeSpan, timeShift).ConfigureAwait(false);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (timeSpan, timeShift),
+                static async (source, state, observer) =>
+                {
+                    var (sink, timer) = await AsyncObserver.Buffer(observer, state.timeSpan, state.timeShift).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IAsyncScheduler scheduler)
@@ -100,14 +115,17 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sink, timer) = await AsyncObserver.Buffer(observer, timeSpan, timeShift, scheduler).ConfigureAwait(false);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (timeSpan, timeShift, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sink, timer) = await AsyncObserver.Buffer(observer, state.timeSpan, state.timeShift, state.scheduler).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, int count)
@@ -119,14 +137,17 @@ namespace System.Reactive.Linq
             if (count <= 0)
                 throw new ArgumentNullException(nameof(count));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sink, timer) = await AsyncObserver.Buffer(observer, timeSpan, count).ConfigureAwait(false);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (timeSpan, count),
+                static async (source, state, observer) =>
+                {
+                    var (sink, timer) = await AsyncObserver.Buffer(observer, state.timeSpan, state.count).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, int count, IAsyncScheduler scheduler)
@@ -140,14 +161,17 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sink, timer) = await AsyncObserver.Buffer(observer, timeSpan, count, scheduler).ConfigureAwait(false);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (timeSpan, count, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sink, timer) = await AsyncObserver.Buffer(observer, state.timeSpan, state.count, state.scheduler).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(this IAsyncObservable<TSource> source, IAsyncObservable<TBufferBoundary> bufferBoundaries)
@@ -157,15 +181,18 @@ namespace System.Reactive.Linq
             if (bufferBoundaries == null)
                 throw new ArgumentNullException(nameof(bufferBoundaries));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sourceObserver, boundariesObserver) = AsyncObserver.Buffer<TSource, TBufferBoundary>(observer);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                bufferBoundaries,
+                static async (source, bufferBoundaries, observer) =>
+                {
+                    var (sourceObserver, boundariesObserver) = AsyncObserver.Buffer<TSource, TBufferBoundary>(observer);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
-                var boundariesSubscription = await bufferBoundaries.SubscribeSafeAsync(boundariesObserver).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var boundariesSubscription = await bufferBoundaries.SubscribeSafeAsync(boundariesObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(sourceSubscription, boundariesSubscription);
-            });
+                    return StableCompositeAsyncDisposable.Create(sourceSubscription, boundariesSubscription);
+                });
         }
 
         // REVIEW: This overload is inherited from Rx but arguably a bit esoteric as it doesn't provide context to the closing selector.
@@ -177,14 +204,17 @@ namespace System.Reactive.Linq
             if (bufferClosingSelector == null)
                 throw new ArgumentNullException(nameof(bufferClosingSelector));
 
-            return Create<IList<TSource>>(async observer =>
-            {
-                var (sourceObserver, closingDisposable) = await AsyncObserver.Buffer<TSource, TBufferClosing>(observer, bufferClosingSelector).ConfigureAwait(false);
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                bufferClosingSelector,
+                static async (source, bufferClosingSelector, observer) =>
+                {
+                    var (sourceObserver, closingDisposable) = await AsyncObserver.Buffer<TSource, TBufferClosing>(observer, bufferClosingSelector).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(sourceSubscription, closingDisposable);
-            });
+                    return StableCompositeAsyncDisposable.Create(sourceSubscription, closingDisposable);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Catch.cs

@@ -20,14 +20,17 @@ namespace System.Reactive.Linq
             if (handler == null)
                 throw new ArgumentNullException(nameof(handler));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.Catch(observer, handler);
+            return Create(
+                source,
+                handler,
+                async (source, handler, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.Catch(observer, handler);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TSource> Catch<TSource, TException>(this IAsyncObservable<TSource> source, Func<TException, ValueTask<IAsyncObservable<TSource>>> handler)
@@ -38,14 +41,17 @@ namespace System.Reactive.Linq
             if (handler == null)
                 throw new ArgumentNullException(nameof(handler));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.Catch(observer, handler);
+            return Create(
+                source,
+                handler,
+                async (source, handler, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.Catch(observer, handler);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TSource> Catch<TSource>(this IAsyncObservable<TSource> first, IAsyncObservable<TSource> second)
@@ -55,14 +61,17 @@ namespace System.Reactive.Linq
             if (second == null)
                 throw new ArgumentNullException(nameof(second));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.Catch(observer, second);
+            return Create(
+                first,
+                second,
+                async (first, second, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.Catch(observer, second);
 
-                var subscription = await first.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await first.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TSource> Catch<TSource>(params IAsyncObservable<TSource>[] sources) => Catch((IEnumerable<IAsyncObservable<TSource>>)sources);

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Concat.cs

@@ -19,14 +19,17 @@ namespace System.Reactive.Linq
             if (second == null)
                 throw new ArgumentNullException(nameof(second));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.Concat(observer, second);
+            return Create(
+                first,
+                second,
+                async (first, second, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.Concat(observer, second);
 
-                var subscription = await first.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await first.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TSource> Concat<TSource>(params IAsyncObservable<TSource>[] sources) => Concat((IEnumerable<IAsyncObservable<TSource>>)sources);

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Contains.cs

@@ -13,7 +13,10 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<bool>(observer => source.SubscribeSafeAsync(AsyncObserver.Contains(observer, element)));
+            return CreateAsyncObservable<bool>.From(
+                source,
+                element,
+                static (source, element, observer) => source.SubscribeSafeAsync(AsyncObserver.Contains(observer, element)));
         }
 
         public static IAsyncObservable<bool> Contains<TSource>(this IAsyncObservable<TSource> source, TSource element, IEqualityComparer<TSource> comparer)
@@ -23,7 +26,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<bool>(observer => source.SubscribeSafeAsync(AsyncObserver.Contains(observer, element, comparer)));
+            return CreateAsyncObservable<bool>.From(
+                source,
+                (element, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Contains(observer, state.element, state.comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Count.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<int>(observer => source.SubscribeSafeAsync(AsyncObserver.Count(observer, predicate)));
+            return CreateAsyncObservable<int>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Count(observer, predicate)));
         }
 
         public static IAsyncObservable<int> Count<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<int>(observer => source.SubscribeSafeAsync(AsyncObserver.Count(observer, predicate)));
+            return CreateAsyncObservable<int>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Count(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/DefaultIfEmpty.cs

@@ -19,7 +19,10 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.DefaultIfEmpty(observer, defaultValue)));
+            return Create(
+                source,
+                defaultValue,
+                (source, defaultValue, observer) => source.SubscribeSafeAsync(AsyncObserver.DefaultIfEmpty(observer, defaultValue)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Delay.cs

@@ -19,14 +19,17 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = await AsyncObserver.Delay(observer, dueTime).ConfigureAwait(false);
+            return Create(
+                source,
+                dueTime,
+                async (source, dueTime, observer) =>
+                {
+                    var (sink, drain) = await AsyncObserver.Delay(observer, dueTime).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
 
         public static IAsyncObservable<TSource> Delay<TSource>(this IAsyncObservable<TSource> source, TimeSpan dueTime, IAsyncScheduler scheduler)
@@ -36,14 +39,17 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = await AsyncObserver.Delay(observer, dueTime, scheduler).ConfigureAwait(false);
+            return Create(
+                source,
+                (dueTime, scheduler),
+                async (source, state, observer) =>
+                {
+                    var (sink, drain) = await AsyncObserver.Delay(observer, state.dueTime, state.scheduler).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/DelaySubscription.cs

@@ -24,20 +24,23 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
-
-                var task = await scheduler.ScheduleAsync(async ct =>
+            return Create(
+                source,
+                (dueTime, scheduler),
+                async (source, state, observer) =>
                 {
-                    var inner = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
-                    await d.AddAsync(inner).ConfigureAwait(false);
-                }, dueTime).ConfigureAwait(false);
+                    var d = new CompositeAsyncDisposable();
+
+                    var task = await state.scheduler.ScheduleAsync(async ct =>
+                    {
+                        var inner = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
+                        await d.AddAsync(inner).ConfigureAwait(false);
+                    }, state.dueTime).ConfigureAwait(false);
 
-                await d.AddAsync(task).ConfigureAwait(false);
+                    await d.AddAsync(task).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
 
         public static IAsyncObservable<TSource> DelaySubscription<TSource>(this IAsyncObservable<TSource> source, DateTimeOffset dueTime)
@@ -55,20 +58,23 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
-
-                var task = await scheduler.ScheduleAsync(async ct =>
+            return Create(
+                source,
+                (dueTime, scheduler),
+                async (source, state, observer) =>
                 {
-                    var inner = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
-                    await d.AddAsync(inner).ConfigureAwait(false);
-                }, dueTime).ConfigureAwait(false);
+                    var d = new CompositeAsyncDisposable();
+
+                    var task = await state.scheduler.ScheduleAsync(async ct =>
+                    {
+                        var inner = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
+                        await d.AddAsync(inner).ConfigureAwait(false);
+                    }, state.dueTime).ConfigureAwait(false);
 
-                await d.AddAsync(task).ConfigureAwait(false);
+                    await d.AddAsync(task).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
     }
 }

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Distinct.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Distinct(observer, comparer)));
+            return Create(
+                source,
+                comparer,
+                (source, comparer, observer) => source.SubscribeSafeAsync(AsyncObserver.Distinct(observer, comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/DistinctUntilChanged.cs

@@ -24,7 +24,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, comparer)));
+            return Create(
+                source,
+                comparer,
+                (source, comparer, observer) => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, comparer)));
         }
 
         public static IAsyncObservable<TSource> DistinctUntilChanged<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector)
@@ -34,7 +37,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, keySelector)));
+            return Create(
+                source,
+                keySelector,
+                (source, keySelector, observer) => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, keySelector)));
         }
 
         public static IAsyncObservable<TSource> DistinctUntilChanged<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
@@ -44,7 +50,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, keySelector)));
+            return Create(
+                source,
+                keySelector,
+                (source, keySelector, observer) => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, keySelector)));
         }
 
         public static IAsyncObservable<TSource> DistinctUntilChanged<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
@@ -56,7 +65,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, keySelector, comparer)));
+            return Create(
+                source,
+                (keySelector, comparer),
+                (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, state.keySelector, state.comparer)));
         }
 
         public static IAsyncObservable<TSource> DistinctUntilChanged<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
@@ -68,7 +80,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, keySelector, comparer)));
+            return Create(
+                source,
+                (keySelector, comparer),
+                (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.DistinctUntilChanged(observer, state.keySelector, state.comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Do.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (observer == null)
                 throw new ArgumentNullException(nameof(observer));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, observer)));
+            return Create(
+                source,
+                observer,
+                (source, observer, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, observer)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Action<TSource> onNext)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (onNext == null)
                 throw new ArgumentNullException(nameof(onNext));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onNext)));
+            return Create(
+                source,
+                onNext,
+                (source, onNext, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, onNext)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Action<Exception> onError)
@@ -35,7 +41,10 @@ namespace System.Reactive.Linq
             if (onError == null)
                 throw new ArgumentNullException(nameof(onError));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onError)));
+            return Create(
+                source,
+                onError,
+                (source, onError, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, onError)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Action onCompleted)
@@ -45,7 +54,10 @@ namespace System.Reactive.Linq
             if (onCompleted == null)
                 throw new ArgumentNullException(nameof(onCompleted));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onCompleted)));
+            return Create(
+                source,
+                onCompleted,
+                (source, onCompleted, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, onCompleted)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted)
@@ -59,7 +71,10 @@ namespace System.Reactive.Linq
             if (onCompleted == null)
                 throw new ArgumentNullException(nameof(onCompleted));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onNext, onError, onCompleted)));
+            return Create(
+                source,
+                (onNext, onError, onCompleted),
+                (source, state, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, state.onNext, state.onError, state.onCompleted)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, IAsyncObserver<TSource> observer)
@@ -69,7 +84,10 @@ namespace System.Reactive.Linq
             if (observer == null)
                 throw new ArgumentNullException(nameof(observer));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, observer)));
+            return Create(
+                source,
+                observer,
+                (source, observer, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, observer)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask> onNext)
@@ -79,7 +97,10 @@ namespace System.Reactive.Linq
             if (onNext == null)
                 throw new ArgumentNullException(nameof(onNext));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onNext)));
+            return Create(
+                source,
+                onNext,
+                (source, onNext, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, onNext)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Func<Exception, ValueTask> onError)
@@ -89,7 +110,10 @@ namespace System.Reactive.Linq
             if (onError == null)
                 throw new ArgumentNullException(nameof(onError));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onError)));
+            return Create(
+                source,
+                onError,
+                (source, onError, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, onError)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Func<ValueTask> onCompleted)
@@ -99,7 +123,10 @@ namespace System.Reactive.Linq
             if (onCompleted == null)
                 throw new ArgumentNullException(nameof(onCompleted));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onCompleted)));
+            return Create(
+                source,
+                onCompleted,
+                (source, onCompleted, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, onCompleted)));
         }
 
         public static IAsyncObservable<TSource> Do<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask> onNext, Func<Exception, ValueTask> onError, Func<ValueTask> onCompleted)
@@ -113,7 +140,10 @@ namespace System.Reactive.Linq
             if (onCompleted == null)
                 throw new ArgumentNullException(nameof(onCompleted));
 
-            return Create<TSource>(target => source.SubscribeSafeAsync(AsyncObserver.Do(target, onNext, onError, onCompleted)));
+            return Create(
+                source,
+                (onNext, onError, onCompleted),
+                (source, state, target) => source.SubscribeSafeAsync(AsyncObserver.Do(target, state.onNext, state.onError, state.onCompleted)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/DoWhile.cs

@@ -18,55 +18,58 @@ namespace System.Reactive.Linq
             if (condition == null)
                 throw new ArgumentNullException(nameof(condition));
 
-            return Create<TSource>(async observer =>
-            {
-                var subscription = new SerialAsyncDisposable();
-
-                var o = default(IAsyncObserver<TSource>);
-
-                o = AsyncObserver.CreateUnsafe<TSource>(
-                        observer.OnNextAsync,
-                        observer.OnErrorAsync,
-                        MoveNext
-                    );
-
-                async Task Subscribe()
+            return Create(
+                source,
+                condition,
+                async (source, condition, observer) =>
                 {
-                    var sad = new SingleAssignmentAsyncDisposable();
-                    await subscription.AssignAsync(sad).ConfigureAwait(false);
+                    var subscription = new SerialAsyncDisposable();
 
-                    var d = await source.SubscribeSafeAsync(o).ConfigureAwait(false);
-                    await sad.AssignAsync(d).ConfigureAwait(false);
-                }
+                    var o = default(IAsyncObserver<TSource>);
 
-                async ValueTask MoveNext()
-                {
-                    var b = default(bool);
+                    o = AsyncObserver.CreateUnsafe<TSource>(
+                            observer.OnNextAsync,
+                            observer.OnErrorAsync,
+                            MoveNext
+                        );
 
-                    try
+                    async Task Subscribe()
                     {
-                        b = condition();
-                    }
-                    catch (Exception ex)
-                    {
-                        await observer.OnErrorAsync(ex).ConfigureAwait(false);
-                        return;
-                    }
+                        var sad = new SingleAssignmentAsyncDisposable();
+                        await subscription.AssignAsync(sad).ConfigureAwait(false);
 
-                    if (b)
-                    {
-                        await Subscribe().ConfigureAwait(false);
+                        var d = await source.SubscribeSafeAsync(o).ConfigureAwait(false);
+                        await sad.AssignAsync(d).ConfigureAwait(false);
                     }
-                    else
+
+                    async ValueTask MoveNext()
                     {
-                        await observer.OnCompletedAsync().ConfigureAwait(false);
+                        var b = default(bool);
+
+                        try
+                        {
+                            b = condition();
+                        }
+                        catch (Exception ex)
+                        {
+                            await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                            return;
+                        }
+
+                        if (b)
+                        {
+                            await Subscribe().ConfigureAwait(false);
+                        }
+                        else
+                        {
+                            await observer.OnCompletedAsync().ConfigureAwait(false);
+                        }
                     }
-                }
 
-                await Subscribe().ConfigureAwait(false);
+                    await Subscribe().ConfigureAwait(false);
 
-                return subscription;
-            });
+                    return subscription;
+                });
         }
 
         public static IAsyncObservable<TSource> DoWhile<TSource>(IAsyncObservable<TSource> source, Func<ValueTask<bool>> condition)
@@ -76,55 +79,58 @@ namespace System.Reactive.Linq
             if (condition == null)
                 throw new ArgumentNullException(nameof(condition));
 
-            return Create<TSource>(async observer =>
-            {
-                var subscription = new SerialAsyncDisposable();
-
-                var o = default(IAsyncObserver<TSource>);
-
-                o = AsyncObserver.CreateUnsafe<TSource>(
-                        observer.OnNextAsync,
-                        observer.OnErrorAsync,
-                        MoveNext
-                    );
-
-                async Task Subscribe()
+            return Create(
+                source,
+                condition,
+                async (source, condition, observer) =>
                 {
-                    var sad = new SingleAssignmentAsyncDisposable();
-                    await subscription.AssignAsync(sad).ConfigureAwait(false);
+                    var subscription = new SerialAsyncDisposable();
 
-                    var d = await source.SubscribeSafeAsync(o).ConfigureAwait(false);
-                    await sad.AssignAsync(d).ConfigureAwait(false);
-                }
+                    var o = default(IAsyncObserver<TSource>);
 
-                async ValueTask MoveNext()
-                {
-                    var b = default(bool);
+                    o = AsyncObserver.CreateUnsafe<TSource>(
+                            observer.OnNextAsync,
+                            observer.OnErrorAsync,
+                            MoveNext
+                        );
 
-                    try
+                    async Task Subscribe()
                     {
-                        b = await condition().ConfigureAwait(false);
-                    }
-                    catch (Exception ex)
-                    {
-                        await observer.OnErrorAsync(ex).ConfigureAwait(false);
-                        return;
-                    }
+                        var sad = new SingleAssignmentAsyncDisposable();
+                        await subscription.AssignAsync(sad).ConfigureAwait(false);
 
-                    if (b)
-                    {
-                        await Subscribe().ConfigureAwait(false);
+                        var d = await source.SubscribeSafeAsync(o).ConfigureAwait(false);
+                        await sad.AssignAsync(d).ConfigureAwait(false);
                     }
-                    else
+
+                    async ValueTask MoveNext()
                     {
-                        await observer.OnCompletedAsync().ConfigureAwait(false);
+                        var b = default(bool);
+
+                        try
+                        {
+                            b = await condition().ConfigureAwait(false);
+                        }
+                        catch (Exception ex)
+                        {
+                            await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                            return;
+                        }
+
+                        if (b)
+                        {
+                            await Subscribe().ConfigureAwait(false);
+                        }
+                        else
+                        {
+                            await observer.OnCompletedAsync().ConfigureAwait(false);
+                        }
                     }
-                }
 
-                await Subscribe().ConfigureAwait(false);
+                    await Subscribe().ConfigureAwait(false);
 
-                return subscription;
-            });
+                    return subscription;
+                });
         }
     }
 }

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/ElementAt.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (index < 0)
                 throw new ArgumentOutOfRangeException(nameof(index));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.ElementAt(observer, index)));
+            return Create(
+                source,
+                index,
+                (source, index, observer) => source.SubscribeSafeAsync(AsyncObserver.ElementAt(observer, index)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/ElementAtOrDefault.cs

@@ -13,7 +13,10 @@ namespace System.Reactive.Linq
             if (index < 0)
                 throw new ArgumentOutOfRangeException(nameof(index));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.ElementAtOrDefault(observer, index)));
+            return Create(
+                source,
+                index,
+                (source, index, observer) => source.SubscribeSafeAsync(AsyncObserver.ElementAtOrDefault(observer, index)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Finally.cs

@@ -16,22 +16,25 @@ namespace System.Reactive.Linq
             if (finallyAction == null)
                 throw new ArgumentNullException(nameof(finallyAction));
 
-            return Create<TSource>(async observer =>
-            {
-                var subscription = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
-
-                return AsyncDisposable.Create(async () =>
+            return Create(
+                source,
+                finallyAction,
+                async (source, finallyAction, observer) =>
                 {
-                    try
-                    {
-                        await subscription.DisposeAsync().ConfigureAwait(false);
-                    }
-                    finally
+                    var subscription = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
+
+                    return AsyncDisposable.Create(async () =>
                     {
-                        finallyAction();
-                    }
+                        try
+                        {
+                            await subscription.DisposeAsync().ConfigureAwait(false);
+                        }
+                        finally
+                        {
+                            finallyAction();
+                        }
+                    });
                 });
-            });
         }
 
         public static IAsyncObservable<TSource> Finally<TSource>(this IAsyncObservable<TSource> source, Func<Task> finallyAction)
@@ -41,22 +44,25 @@ namespace System.Reactive.Linq
             if (finallyAction == null)
                 throw new ArgumentNullException(nameof(finallyAction));
 
-            return Create<TSource>(async observer =>
-            {
-                var subscription = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
-
-                return AsyncDisposable.Create(async () =>
+            return Create(
+                source,
+                finallyAction,
+                async (source, finallyAction, observer) =>
                 {
-                    try
-                    {
-                        await subscription.DisposeAsync().ConfigureAwait(false);
-                    }
-                    finally
+                    var subscription = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
+
+                    return AsyncDisposable.Create(async () =>
                     {
-                        await finallyAction().ConfigureAwait(false);
-                    }
+                        try
+                        {
+                            await subscription.DisposeAsync().ConfigureAwait(false);
+                        }
+                        finally
+                        {
+                            await finallyAction().ConfigureAwait(false);
+                        }
+                    });
                 });
-            });
         }
     }
 }

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/First.cs

@@ -27,7 +27,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.First(observer, predicate)));
+            return Create(
+                source,
+                predicate,
+                (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.First(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> First<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -37,7 +40,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.First(observer, predicate)));
+            return Create(
+                source,
+                predicate,
+                (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.First(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/FirstOrDefault.cs

@@ -27,7 +27,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.FirstOrDefault(observer, predicate)));
+            return Create(
+                source,
+                predicate,
+                (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.FirstOrDefault(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> FirstOrDefault<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -37,7 +40,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.FirstOrDefault(observer, predicate)));
+            return Create(
+                source,
+                predicate,
+                (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.FirstOrDefault(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/GroupBy.cs

@@ -18,7 +18,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                keySelector,
+                static (source, keySelector, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
@@ -30,7 +33,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity)
@@ -42,7 +48,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, capacity),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -56,7 +65,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, capacity, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, capacity, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.capacity, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
@@ -68,7 +80,10 @@ namespace System.Reactive.Linq
             if (elementSelector == null)
                 throw new ArgumentNullException(nameof(elementSelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
@@ -82,7 +97,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity)
@@ -96,7 +114,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, capacity),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -112,7 +133,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector, capacity, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, capacity, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector, state.capacity, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
@@ -122,7 +146,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                keySelector,
+                static (source, keySelector, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
@@ -134,7 +161,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, int capacity)
@@ -146,7 +176,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, capacity),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -160,7 +193,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, capacity, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, capacity, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.capacity, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector)
@@ -172,7 +208,10 @@ namespace System.Reactive.Linq
             if (elementSelector == null)
                 throw new ArgumentNullException(nameof(elementSelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer)
@@ -186,7 +225,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, int capacity)
@@ -200,7 +242,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, capacity),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -216,7 +261,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, keySelector, elementSelector, capacity, comparer)));
+            return CreateAsyncObservable< IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, capacity, comparer),
+                static (source, state, observer) => GroupByCore(source, observer, (o, d) => AsyncObserver.GroupBy(o, d, state.keySelector, state.elementSelector, state.capacity, state.comparer)));
         }
 
         private static async ValueTask<IAsyncDisposable> GroupByCore<TSource, TKey, TElement>(IAsyncObservable<TSource> source, IAsyncObserver<IGroupedAsyncObservable<TKey, TElement>> observer, Func<IAsyncObserver<IGroupedAsyncObservable<TKey, TElement>>, IAsyncDisposable, (IAsyncObserver<TSource>, IAsyncDisposable)> createObserver)

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/GroupByUntil.cs

@@ -22,7 +22,10 @@ namespace System.Reactive.Linq
             if (durationSelector == null)
                 throw new ArgumentNullException(nameof(durationSelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedAsyncObservable<TKey, TSource>, IAsyncObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer)
@@ -36,7 +39,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedAsyncObservable<TKey, TSource>, IAsyncObservable<TDuration>> durationSelector, int capacity)
@@ -50,7 +56,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector, capacity),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedAsyncObservable<TKey, TSource>, IAsyncObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -66,7 +75,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector, capacity, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector, capacity, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector, state.capacity, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector)
@@ -80,7 +92,10 @@ namespace System.Reactive.Linq
             if (durationSelector == null)
                 throw new ArgumentNullException(nameof(durationSelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer)
@@ -96,7 +111,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector, int capacity)
@@ -112,7 +130,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector, capacity),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -130,7 +151,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector, capacity, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector, capacity, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector, state.capacity, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<IGroupedAsyncObservable<TKey, TSource>, IAsyncObservable<TDuration>> durationSelector)
@@ -142,7 +166,10 @@ namespace System.Reactive.Linq
             if (durationSelector == null)
                 throw new ArgumentNullException(nameof(durationSelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<IGroupedAsyncObservable<TKey, TSource>, IAsyncObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer)
@@ -156,7 +183,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<IGroupedAsyncObservable<TKey, TSource>, IAsyncObservable<TDuration>> durationSelector, int capacity)
@@ -170,7 +200,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector, capacity),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<IGroupedAsyncObservable<TKey, TSource>, IAsyncObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -186,7 +219,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TSource>>(observer => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, durationSelector, capacity, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TSource>>.From(
+                source,
+                (keySelector, durationSelector, capacity, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TSource, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.durationSelector, state.capacity, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector)
@@ -200,7 +236,10 @@ namespace System.Reactive.Linq
             if (durationSelector == null)
                 throw new ArgumentNullException(nameof(durationSelector));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer)
@@ -216,7 +255,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector, state.comparer)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector, int capacity)
@@ -232,7 +274,10 @@ namespace System.Reactive.Linq
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector, capacity)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector, capacity),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector, state.capacity)));
         }
 
         public static IAsyncObservable<IGroupedAsyncObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<IGroupedAsyncObservable<TKey, TElement>, IAsyncObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer)
@@ -250,7 +295,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IGroupedAsyncObservable<TKey, TElement>>(observer => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, keySelector, elementSelector, durationSelector, capacity, comparer)));
+            return CreateAsyncObservable<IGroupedAsyncObservable<TKey, TElement>>.From(
+                source,
+                (keySelector, elementSelector, durationSelector, capacity, comparer),
+                static (source, state, observer) => GroupByUntilCore<TSource, TKey, TElement, TDuration>(source, observer, (o, d) => AsyncObserver.GroupByUntil(o, d, state.keySelector, state.elementSelector, state.durationSelector, state.capacity, state.comparer)));
         }
 
         private static async ValueTask<IAsyncDisposable> GroupByUntilCore<TSource, TKey, TElement, TDuration>(IAsyncObservable<TSource> source, IAsyncObserver<IGroupedAsyncObservable<TKey, TElement>> observer, Func<IAsyncObserver<IGroupedAsyncObservable<TKey, TElement>>, IAsyncDisposable, ValueTask<(IAsyncObserver<TSource>, IAsyncDisposable)>> createObserver)

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/If.cs

@@ -22,21 +22,24 @@ namespace System.Reactive.Linq
             if (elseSource == null)
                 throw new ArgumentNullException(nameof(elseSource));
 
-            return Create<TResult>(observer =>
-            {
-                var b = default(bool);
-
-                try
-                {
-                    b = condition();
-                }
-                catch (Exception ex)
+            return CreateAsyncObservable<TResult>.From(
+                thenSource,
+                (elseSource, condition),
+                static (thenSource, state, observer) =>
                 {
-                    return Throw<TResult>(ex).SubscribeAsync(observer);
-                }
+                    var b = default(bool);
+
+                    try
+                    {
+                        b = state.condition();
+                    }
+                    catch (Exception ex)
+                    {
+                        return Throw<TResult>(ex).SubscribeAsync(observer);
+                    }
 
-                return (b ? thenSource : elseSource).SubscribeSafeAsync(observer);
-            });
+                    return (b ? thenSource : state.elseSource).SubscribeSafeAsync(observer);
+                });
         }
 
         public static IAsyncObservable<TResult> If<TResult>(Func<ValueTask<bool>> condition, IAsyncObservable<TResult> thenSource) => If(condition, thenSource, Empty<TResult>());
@@ -52,21 +55,24 @@ namespace System.Reactive.Linq
             if (elseSource == null)
                 throw new ArgumentNullException(nameof(elseSource));
 
-            return Create<TResult>(async observer =>
-            {
-                var b = default(bool);
-
-                try
-                {
-                    b = await condition().ConfigureAwait(false);
-                }
-                catch (Exception ex)
+            return CreateAsyncObservable<TResult>.From(
+                thenSource,
+                (elseSource, condition),
+                static async (thenSource, state, observer) =>
                 {
-                    return await Throw<TResult>(ex).SubscribeAsync(observer).ConfigureAwait(false);
-                }
+                    var b = default(bool);
+
+                    try
+                    {
+                        b = await state.condition().ConfigureAwait(false);
+                    }
+                    catch (Exception ex)
+                    {
+                        return await Throw<TResult>(ex).SubscribeAsync(observer).ConfigureAwait(false);
+                    }
 
-                return await (b ? thenSource : elseSource).SubscribeSafeAsync(observer).ConfigureAwait(false);
-            });
+                    return await (b ? thenSource : state.elseSource).SubscribeSafeAsync(observer).ConfigureAwait(false);
+                });
         }
     }
 }

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Join.cs

@@ -24,20 +24,23 @@ namespace System.Reactive.Linq
             if (resultSelector == null)
                 throw new ArgumentNullException(nameof(resultSelector));
 
-            return Create<TResult>(async observer =>
-            {
-                var subscriptions = new CompositeAsyncDisposable();
+            return CreateAsyncObservable<TResult>.From(
+                left,
+                (right, leftDurationSelector, rightDurationSelector, resultSelector),
+                static async (left, state, observer) =>
+                {
+                    var subscriptions = new CompositeAsyncDisposable();
 
-                var (leftObserver, rightObserver, disposable) = AsyncObserver.Join(observer, subscriptions, leftDurationSelector, rightDurationSelector, resultSelector);
+                    var (leftObserver, rightObserver, disposable) = AsyncObserver.Join(observer, subscriptions, state.leftDurationSelector, state.rightDurationSelector, state.resultSelector);
 
-                var leftSubscription = await left.SubscribeSafeAsync(leftObserver).ConfigureAwait(false);
-                await subscriptions.AddAsync(leftSubscription).ConfigureAwait(false);
+                    var leftSubscription = await left.SubscribeSafeAsync(leftObserver).ConfigureAwait(false);
+                    await subscriptions.AddAsync(leftSubscription).ConfigureAwait(false);
 
-                var rightSubscription = await right.SubscribeSafeAsync(rightObserver).ConfigureAwait(false);
-                await subscriptions.AddAsync(rightSubscription).ConfigureAwait(false);
+                    var rightSubscription = await state.right.SubscribeSafeAsync(rightObserver).ConfigureAwait(false);
+                    await subscriptions.AddAsync(rightSubscription).ConfigureAwait(false);
 
-                return disposable;
-            });
+                    return disposable;
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Last.cs

@@ -17,7 +17,9 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Last(observer)));
+            return Create(
+                source,
+                (source, observer) => source.SubscribeSafeAsync(AsyncObserver.Last(observer)));
         }
 
         public static IAsyncObservable<TSource> Last<TSource>(this IAsyncObservable<TSource> source, Func<TSource, bool> predicate)
@@ -27,7 +29,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Last(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Last(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> Last<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -37,7 +42,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Last(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Last(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/LastOrDefault.cs

@@ -17,7 +17,9 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.LastOrDefault(observer)));
+            return Create(
+                source,
+                (source, observer) => source.SubscribeSafeAsync(AsyncObserver.LastOrDefault(observer)));
         }
 
         public static IAsyncObservable<TSource> LastOrDefault<TSource>(this IAsyncObservable<TSource> source, Func<TSource, bool> predicate)
@@ -27,7 +29,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.LastOrDefault(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.LastOrDefault(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> LastOrDefault<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -37,7 +42,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.LastOrDefault(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.LastOrDefault(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/LongCount.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<long>(observer => source.SubscribeSafeAsync(AsyncObserver.LongCount(observer, predicate)));
+            return CreateAsyncObservable<long>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.LongCount(observer, predicate)));
         }
 
         public static IAsyncObservable<long> LongCount<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<long>(observer => source.SubscribeSafeAsync(AsyncObserver.LongCount(observer, predicate)));
+            return CreateAsyncObservable<long>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.LongCount(observer, predicate)));
         }
     }
 

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

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxInt32(observer, selector)));
+            return CreateAsyncObservable<Int32>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32>> selector)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxInt32(observer, selector)));
+            return CreateAsyncObservable<Int32>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32?> Max(this IAsyncObservable<Int32?> source)
@@ -51,7 +57,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Int32?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32?> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32?>> selector)
@@ -61,7 +70,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Int32?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int64> Max(this IAsyncObservable<Int64> source)
@@ -79,7 +91,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxInt64(observer, selector)));
+            return CreateAsyncObservable<Int64>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64>> selector)
@@ -89,7 +104,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxInt64(observer, selector)));
+            return CreateAsyncObservable<Int64>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64?> Max(this IAsyncObservable<Int64?> source)
@@ -107,7 +125,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Int64?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64?> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64?>> selector)
@@ -117,7 +138,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Int64?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Max(this IAsyncObservable<Single> source)
@@ -135,7 +159,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single>> selector)
@@ -145,7 +172,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Max(this IAsyncObservable<Single?> source)
@@ -163,7 +193,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single?>> selector)
@@ -173,7 +206,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Max(this IAsyncObservable<Double> source)
@@ -191,7 +227,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double>> selector)
@@ -201,7 +240,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Max(this IAsyncObservable<Double?> source)
@@ -219,7 +261,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double?>> selector)
@@ -229,7 +274,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Max(this IAsyncObservable<Decimal> source)
@@ -247,7 +295,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal>> selector)
@@ -257,7 +308,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Max(this IAsyncObservable<Decimal?> source)
@@ -275,7 +329,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Max<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal?>> selector)
@@ -285,7 +342,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxNullableDecimal(observer, selector)));
         }
 
     }

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

@@ -42,7 +42,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=typeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=typeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
         public static IAsyncObservable<<#=typeName#>> <#=name#><TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<<#=typeName#>>> selector)
@@ -52,7 +55,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=typeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=typeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
 <#

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Max.cs

@@ -24,7 +24,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Max(observer, comparer)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                comparer,
+                static (source, comparer, observer) => source.SubscribeSafeAsync(AsyncObserver.Max(observer, comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/MaxBy.cs

@@ -16,7 +16,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, keySelector)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                keySelector,
+                static (source, keySelector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, keySelector)));
         }
 
         public static IAsyncObservable<IList<TSource>> MaxBy<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
@@ -28,7 +31,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, keySelector, comparer)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (keySelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, state.keySelector, state.comparer)));
         }
 
         public static IAsyncObservable<IList<TSource>> MaxBy<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
@@ -38,7 +44,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, keySelector)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                keySelector,
+                static (source, keySelector, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, keySelector)));
         }
 
         public static IAsyncObservable<IList<TSource>> MaxBy<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
@@ -50,7 +59,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, keySelector, comparer)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (keySelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, state.keySelector, state.comparer)));
         }
     }
 

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

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32>(observer => source.SubscribeSafeAsync(AsyncObserver.MinInt32(observer, selector)));
+            return CreateAsyncObservable<Int32>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32>> selector)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32>(observer => source.SubscribeSafeAsync(AsyncObserver.MinInt32(observer, selector)));
+            return CreateAsyncObservable<Int32>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32?> Min(this IAsyncObservable<Int32?> source)
@@ -51,7 +57,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Int32?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32?> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32?>> selector)
@@ -61,7 +70,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Int32?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int64> Min(this IAsyncObservable<Int64> source)
@@ -79,7 +91,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64>(observer => source.SubscribeSafeAsync(AsyncObserver.MinInt64(observer, selector)));
+            return CreateAsyncObservable<Int64>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64>> selector)
@@ -89,7 +104,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64>(observer => source.SubscribeSafeAsync(AsyncObserver.MinInt64(observer, selector)));
+            return CreateAsyncObservable<Int64>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64?> Min(this IAsyncObservable<Int64?> source)
@@ -107,7 +125,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Int64?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64?> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64?>> selector)
@@ -117,7 +138,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Int64?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Min(this IAsyncObservable<Single> source)
@@ -135,7 +159,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.MinSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single>> selector)
@@ -145,7 +172,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.MinSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Min(this IAsyncObservable<Single?> source)
@@ -163,7 +193,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single?>> selector)
@@ -173,7 +206,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Min(this IAsyncObservable<Double> source)
@@ -191,7 +227,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.MinDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double>> selector)
@@ -201,7 +240,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.MinDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Min(this IAsyncObservable<Double?> source)
@@ -219,7 +261,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double?>> selector)
@@ -229,7 +274,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Min(this IAsyncObservable<Decimal> source)
@@ -247,7 +295,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.MinDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal>> selector)
@@ -257,7 +308,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.MinDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Min(this IAsyncObservable<Decimal?> source)
@@ -275,7 +329,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Min<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal?>> selector)
@@ -285,7 +342,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.MinNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinNullableDecimal(observer, selector)));
         }
 
     }

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

@@ -42,7 +42,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=typeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=typeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
         public static IAsyncObservable<<#=typeName#>> <#=name#><TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<<#=typeName#>>> selector)
@@ -52,7 +55,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=typeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=typeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
 <#

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Min.cs

@@ -24,7 +24,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Min(observer, comparer)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                comparer,
+                static (source, comparer, observer) => source.SubscribeSafeAsync(AsyncObserver.Min(observer, comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/MinBy.cs

@@ -16,7 +16,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, keySelector)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                keySelector,
+                static (source, keySelector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, keySelector)));
         }
 
         public static IAsyncObservable<IList<TSource>> MinBy<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
@@ -28,7 +31,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, keySelector, comparer)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (keySelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, state.keySelector, state.comparer)));
         }
 
         public static IAsyncObservable<IList<TSource>> MinBy<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
@@ -38,7 +44,10 @@ namespace System.Reactive.Linq
             if (keySelector == null)
                 throw new ArgumentNullException(nameof(keySelector));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, keySelector)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                keySelector,
+                static (source, keySelector, observer) => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, keySelector)));
         }
 
         public static IAsyncObservable<IList<TSource>> MinBy<TSource, TKey>(IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
@@ -50,7 +59,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, keySelector, comparer)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (keySelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.MinBy(observer, state.keySelector, state.comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Multicast.cs

@@ -63,33 +63,36 @@ namespace System.Reactive.Linq
 
             // REVIEW: Use a lifted observer operator.
 
-            return Create<TResult>(async observer =>
-            {
-                var observable = default(IAsyncObservable<TResult>);
-                var connectable = default(IConnectableAsyncObservable<TIntermediate>);
-
-                try
-                {
-                    var subject = await subjectFactory().ConfigureAwait(false);
-                    connectable = new ConnectableAsyncObservable<TSource, TIntermediate>(source, subject);
-                    observable = await selector(connectable).ConfigureAwait(false);
-                }
-                catch (Exception ex)
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (subjectFactory, selector),
+                static async (source, state, observer) =>
                 {
-                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
-                    return AsyncDisposable.Nop;
-                }
-
-                var d = new CompositeAsyncDisposable();
-
-                var subscription = await observable.SubscribeAsync(observer).ConfigureAwait(false);
-                await d.AddAsync(subscription).ConfigureAwait(false);
-
-                var connection = await connectable.ConnectAsync().ConfigureAwait(false);
-                await d.AddAsync(connection).ConfigureAwait(false);
-
-                return d;
-            });
+                    var observable = default(IAsyncObservable<TResult>);
+                    var connectable = default(IConnectableAsyncObservable<TIntermediate>);
+
+                    try
+                    {
+                        var subject = await state.subjectFactory().ConfigureAwait(false);
+                        connectable = new ConnectableAsyncObservable<TSource, TIntermediate>(source, subject);
+                        observable = await state.selector(connectable).ConfigureAwait(false);
+                    }
+                    catch (Exception ex)
+                    {
+                        await observer.OnErrorAsync(ex).ConfigureAwait(false);
+                        return AsyncDisposable.Nop;
+                    }
+
+                    var d = new CompositeAsyncDisposable();
+
+                    var subscription = await observable.SubscribeAsync(observer).ConfigureAwait(false);
+                    await d.AddAsync(subscription).ConfigureAwait(false);
+
+                    var connection = await connectable.ConnectAsync().ConfigureAwait(false);
+                    await d.AddAsync(connection).ConfigureAwait(false);
+
+                    return d;
+                });
         }
     }
 }

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/ObserveOn.cs

@@ -19,14 +19,17 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = await AsyncObserver.ObserveOn(observer, scheduler).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                scheduler,
+                static async (source, scheduler, observer) =>
+                {
+                    var (sink, drain) = await AsyncObserver.ObserveOn(observer, scheduler).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/OnErrorResumeNext.cs

@@ -19,14 +19,17 @@ namespace System.Reactive.Linq
             if (second == null)
                 throw new ArgumentNullException(nameof(second));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.OnErrorResumeNext(observer, second);
+            return CreateAsyncObservable<TSource>.From(
+                first,
+                second,
+                static async (first, second, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.OnErrorResumeNext(observer, second);
 
-                var subscription = await first.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await first.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TSource> OnErrorResumeNext<TSource>(params IAsyncObservable<TSource>[] sources) => OnErrorResumeNext((IEnumerable<IAsyncObservable<TSource>>)sources);

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Prepend.cs

@@ -21,7 +21,10 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(async observer => await source.SubscribeSafeAsync(await AsyncObserver.Prepend(observer, value).ConfigureAwait(false)).ConfigureAwait(false));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                value,
+                static async (source, value, observer) => await source.SubscribeSafeAsync(await AsyncObserver.Prepend(observer, value).ConfigureAwait(false)).ConfigureAwait(false));
         }
 
         public static IAsyncObservable<TSource> Prepend<TSource>(this IAsyncObservable<TSource> source, TSource value, IAsyncScheduler scheduler)
@@ -31,7 +34,10 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(observer => AsyncObserver.Prepend(observer, source, value, scheduler));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (scheduler, value),
+                static (source, state, observer) => AsyncObserver.Prepend(observer, source, state.value, state.scheduler));
         }
 
         public static IAsyncObservable<TSource> Prepend<TSource>(this IAsyncObservable<TSource> source, params TSource[] values)
@@ -41,7 +47,10 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(async observer => await source.SubscribeSafeAsync(await AsyncObserver.Prepend(observer, values).ConfigureAwait(false)).ConfigureAwait(false));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                values,
+                static async (source, values, observer) => await source.SubscribeSafeAsync(await AsyncObserver.Prepend(observer, values).ConfigureAwait(false)).ConfigureAwait(false));
         }
 
         public static IAsyncObservable<TSource> Prepend<TSource>(this IAsyncObservable<TSource> source, IAsyncScheduler scheduler, params TSource[] values)
@@ -53,7 +62,10 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(observer => AsyncObserver.Prepend(observer, source, scheduler, values));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (scheduler, values),
+                static (source, state, observer) => AsyncObserver.Prepend(observer, source, state.scheduler, state.values)); ;
         }
 
         public static IAsyncObservable<TSource> Prepend<TSource>(this IAsyncObservable<TSource> source, IEnumerable<TSource> values)
@@ -63,7 +75,10 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(async observer => await source.SubscribeSafeAsync(await AsyncObserver.Prepend(observer, values).ConfigureAwait(false)).ConfigureAwait(false));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                values,
+                static async (source, values, observer) => await source.SubscribeSafeAsync(await AsyncObserver.Prepend(observer, values).ConfigureAwait(false)).ConfigureAwait(false));
         }
 
         public static IAsyncObservable<TSource> Prepend<TSource>(this IAsyncObservable<TSource> source, IAsyncScheduler scheduler, IEnumerable<TSource> values)
@@ -75,7 +90,10 @@ namespace System.Reactive.Linq
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            return Create<TSource>(observer => AsyncObserver.Prepend(observer, source, scheduler, values));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (scheduler, values),
+                static (source, state, observer) => AsyncObserver.Prepend(observer, source, state.scheduler, state.values));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Repeat.cs

@@ -58,7 +58,10 @@ namespace System.Reactive.Linq
             if (repeatCount < 0)
                 throw new ArgumentNullException(nameof(repeatCount));
 
-            return Create<TSource>(observer => AsyncObserver.Repeat(observer, source, repeatCount));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                repeatCount,
+                static (source, repeatCount, observer) => AsyncObserver.Repeat(observer, source, repeatCount));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Retry.cs

@@ -33,14 +33,17 @@ namespace System.Reactive.Linq
             if (retryCount < 0)
                 throw new ArgumentOutOfRangeException(nameof(retryCount));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.Retry(observer, source, retryCount);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                retryCount,
+                static async (source, retryCount, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.Retry(observer, source, retryCount);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Sample.cs

@@ -18,15 +18,18 @@ namespace System.Reactive.Linq
             if (sampler == null)
                 throw new ArgumentNullException(nameof(sampler));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceSink, samplerSink) = AsyncObserver.Sample<TSource, TSample>(observer);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                sampler,
+                static async (source, sampler, observer) =>
+                {
+                    var (sourceSink, samplerSink) = AsyncObserver.Sample<TSource, TSample>(observer);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sourceSink).ConfigureAwait(false);
-                var samplerSubscription = await sampler.SubscribeSafeAsync(samplerSink).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sourceSink).ConfigureAwait(false);
+                    var samplerSubscription = await sampler.SubscribeSafeAsync(samplerSink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(sourceSubscription, samplerSubscription);
-            });
+                    return StableCompositeAsyncDisposable.Create(sourceSubscription, samplerSubscription);
+                });
         }
 
         public static IAsyncObservable<TSource> Sample<TSource>(this IAsyncObservable<TSource> source, TimeSpan interval)
@@ -34,14 +37,17 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceSink, sampler) = await AsyncObserver.Sample(observer, interval).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                interval,
+                static async (source, interval, observer) =>
+                {
+                    var (sourceSink, sampler) = await AsyncObserver.Sample(observer, interval).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sourceSink).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sourceSink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(sourceSubscription, sampler);
-            });
+                    return StableCompositeAsyncDisposable.Create(sourceSubscription, sampler);
+                });
         }
 
         public static IAsyncObservable<TSource> Sample<TSource>(this IAsyncObservable<TSource> source, TimeSpan interval, IAsyncScheduler scheduler)
@@ -51,14 +57,17 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceSink, sampler) = await AsyncObserver.Sample(observer, interval, scheduler).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (scheduler, interval),
+                static async (source, state, observer) =>
+                {
+                    var (sourceSink, sampler) = await AsyncObserver.Sample(observer, state.interval, state.scheduler).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sourceSink).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sourceSink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(sourceSubscription, sampler);
-            });
+                    return StableCompositeAsyncDisposable.Create(sourceSubscription, sampler);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Scan.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, func)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                func,
+                static (source, func, observer) => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, func)));
         }
 
         public static IAsyncObservable<TSource> Scan<TSource>(this IAsyncObservable<TSource> source, Func<TSource, TSource, ValueTask<TSource>> func)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, func)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                func,
+                static (source, func, observer) => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, func)));
         }
 
         public static IAsyncObservable<TResult> Scan<TSource, TResult>(this IAsyncObservable<TSource> source, TResult seed, Func<TResult, TSource, TResult> func)
@@ -35,7 +41,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, seed, func)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (func, seed),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, state.seed, state.func)));
         }
 
         public static IAsyncObservable<TResult> Scan<TSource, TResult>(this IAsyncObservable<TSource> source, TResult seed, Func<TResult, TSource, ValueTask<TResult>> func)
@@ -45,7 +54,10 @@ namespace System.Reactive.Linq
             if (func == null)
                 throw new ArgumentNullException(nameof(func));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, seed, func)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (func, seed),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.Scan(observer, state.seed, state.func)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Select.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
         }
 
         public static IAsyncObservable<TResult> Select<TSource, TResult>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TResult>> selector)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
         }
 
         public static IAsyncObservable<TResult> Select<TSource, TResult>(this IAsyncObservable<TSource> source, Func<TSource, int, TResult> selector)
@@ -35,7 +41,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
         }
 
         public static IAsyncObservable<TResult> Select<TSource, TResult>(this IAsyncObservable<TSource> source, Func<TSource, int, ValueTask<TResult>> selector)
@@ -45,7 +54,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(observer => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.Select(observer, selector)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/SelectMany.cs

@@ -17,14 +17,17 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static async (source, selector, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TResult> SelectMany<TSource, TResult>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<IAsyncObservable<TResult>>> selector)
@@ -34,14 +37,17 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static async (source, selector, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncObservable<TSource> source, Func<TSource, IAsyncObservable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
@@ -53,14 +59,17 @@ namespace System.Reactive.Linq
             if (resultSelector == null)
                 throw new ArgumentNullException(nameof(resultSelector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, collectionSelector, resultSelector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (collectionSelector, resultSelector),
+                static async (source, state, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, state.collectionSelector, state.resultSelector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<IAsyncObservable<TCollection>>> collectionSelector, Func<TSource, TCollection, ValueTask<TResult>> resultSelector)
@@ -72,14 +81,17 @@ namespace System.Reactive.Linq
             if (resultSelector == null)
                 throw new ArgumentNullException(nameof(resultSelector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, collectionSelector, resultSelector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (collectionSelector, resultSelector),
+                static async (source, state, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, state.collectionSelector, state.resultSelector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TResult> SelectMany<TSource, TResult>(this IAsyncObservable<TSource> source, Func<TSource, int, IAsyncObservable<TResult>> selector)
@@ -89,14 +101,17 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static async (source, selector, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TResult> SelectMany<TSource, TResult>(this IAsyncObservable<TSource> source, Func<TSource, int, ValueTask<IAsyncObservable<TResult>>> selector)
@@ -106,14 +121,17 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                selector,
+                static async (source, selector, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, selector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncObservable<TSource> source, Func<TSource, int, IAsyncObservable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)
@@ -125,14 +143,17 @@ namespace System.Reactive.Linq
             if (resultSelector == null)
                 throw new ArgumentNullException(nameof(resultSelector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, collectionSelector, resultSelector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (collectionSelector, resultSelector),
+                static async (source, state, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, state.collectionSelector, state.resultSelector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
 
         public static IAsyncObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncObservable<TSource> source, Func<TSource, int, ValueTask<IAsyncObservable<TCollection>>> collectionSelector, Func<TSource, int, TCollection, int, ValueTask<TResult>> resultSelector)
@@ -144,14 +165,17 @@ namespace System.Reactive.Linq
             if (resultSelector == null)
                 throw new ArgumentNullException(nameof(resultSelector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (sink, inner) = AsyncObserver.SelectMany(observer, collectionSelector, resultSelector);
+            return CreateAsyncObservable<TResult>.From(
+                source,
+                (collectionSelector, resultSelector),
+                static async (source, state, observer) =>
+                {
+                    var (sink, inner) = AsyncObserver.SelectMany(observer, state.collectionSelector, state.resultSelector);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, inner);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, inner);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/SequenceEqual.cs

@@ -19,20 +19,23 @@ namespace System.Reactive.Linq
             if (second == null)
                 throw new ArgumentNullException(nameof(second));
 
-            return Create<bool>(async observer =>
-            {
-                var (firstObserver, secondObserver) = AsyncObserver.SequenceEqual<TSource>(observer);
+            return CreateAsyncObservable<bool>.From(
+                first,
+                second,
+                static async (first, second, observer) =>
+                {
+                    var (firstObserver, secondObserver) = AsyncObserver.SequenceEqual<TSource>(observer);
 
-                var firstTask = first.SubscribeSafeAsync(firstObserver);
-                var secondTask = second.SubscribeSafeAsync(secondObserver);
+                    var firstTask = first.SubscribeSafeAsync(firstObserver);
+                    var secondTask = second.SubscribeSafeAsync(secondObserver);
 
-                // REVIEW: Consider concurrent subscriptions.
+                    // REVIEW: Consider concurrent subscriptions.
 
-                var d1 = await firstTask.ConfigureAwait(false);
-                var d2 = await secondTask.ConfigureAwait(false);
+                    var d1 = await firstTask.ConfigureAwait(false);
+                    var d2 = await secondTask.ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(d1, d2);
-            });
+                    return StableCompositeAsyncDisposable.Create(d1, d2);
+                });
         }
 
         public static IAsyncObservable<bool> SequenceEqual<TSource>(this IAsyncObservable<TSource> first, IAsyncObservable<TSource> second, IEqualityComparer<TSource> comparer)
@@ -44,20 +47,23 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<bool>(async observer =>
-            {
-                var (firstObserver, secondObserver) = AsyncObserver.SequenceEqual(observer, comparer);
+            return CreateAsyncObservable<bool>.From(
+                first,
+                (second, comparer),
+                static async (first, state, observer) =>
+                {
+                    var (firstObserver, secondObserver) = AsyncObserver.SequenceEqual(observer, state.comparer);
 
-                var firstTask = first.SubscribeSafeAsync(firstObserver);
-                var secondTask = second.SubscribeSafeAsync(secondObserver);
+                    var firstTask = first.SubscribeSafeAsync(firstObserver);
+                    var secondTask = state.second.SubscribeSafeAsync(secondObserver);
 
-                // REVIEW: Consider concurrent subscriptions.
+                    // REVIEW: Consider concurrent subscriptions.
 
-                var d1 = await firstTask.ConfigureAwait(false);
-                var d2 = await secondTask.ConfigureAwait(false);
+                    var d1 = await firstTask.ConfigureAwait(false);
+                    var d2 = await secondTask.ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(d1, d2);
-            });
+                    return StableCompositeAsyncDisposable.Create(d1, d2);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Single.cs

@@ -27,7 +27,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Single(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Single(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> Single<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -37,7 +40,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Single(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Single(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/SingleOrDefault.cs

@@ -27,7 +27,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SingleOrDefault(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.SingleOrDefault(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> SingleOrDefault<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -37,7 +40,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SingleOrDefault(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.SingleOrDefault(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Skip.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
                 return source;
             }
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Skip(observer, count)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                count,
+                static (source, count, observer) => source.SubscribeSafeAsync(AsyncObserver.Skip(observer, count)));
         }
 
         public static IAsyncObservable<TSource> Skip<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration)
@@ -40,14 +43,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use SkipUntil with a Timer parameter. Do we want Skip on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.Skip(observer, duration).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                duration,
+                static async (source, duration, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.Skip(observer, duration).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<TSource> Skip<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration, IAsyncScheduler scheduler)
@@ -66,14 +72,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use SkipUntil with a Timer parameter. Do we want Skip on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.Skip(observer, duration).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (duration, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.Skip(observer, state.duration).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/SkipLast.cs

@@ -22,7 +22,10 @@ namespace System.Reactive.Linq
                 return source;
             }
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SkipLast(observer, count)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                count,
+                static (source, count, observer) => source.SubscribeSafeAsync(AsyncObserver.SkipLast(observer, count)));
         }
 
 
@@ -38,7 +41,10 @@ namespace System.Reactive.Linq
                 return source;
             }
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SkipLast(observer, duration)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                duration,
+                static (source, duration, observer) => source.SubscribeSafeAsync(AsyncObserver.SkipLast(observer, duration)));
         }
 
         public static IAsyncObservable<TSource> SkipLast<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration, IClock clock)
@@ -55,7 +61,10 @@ namespace System.Reactive.Linq
                 return source;
             }
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SkipLast(observer, duration, clock)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (duration, clock),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.SkipLast(observer, state.duration, state.clock)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/SkipUntil.cs

@@ -18,20 +18,23 @@ namespace System.Reactive.Linq
             if (until == null)
                 throw new ArgumentNullException(nameof(until));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, untilObserver) = AsyncObserver.SkipUntil<TSource, TUntil>(observer);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                until,
+                static async (source, until, observer) =>
+                {
+                    var (sourceObserver, untilObserver) = AsyncObserver.SkipUntil<TSource, TUntil>(observer);
 
-                var sourceTask = source.SubscribeSafeAsync(sourceObserver);
-                var untilTask = until.SubscribeSafeAsync(untilObserver);
+                    var sourceTask = source.SubscribeSafeAsync(sourceObserver);
+                    var untilTask = until.SubscribeSafeAsync(untilObserver);
 
-                // REVIEW: Consider concurrent subscriptions.
+                    // REVIEW: Consider concurrent subscriptions.
 
-                var d1 = await sourceTask.ConfigureAwait(false);
-                var d2 = await untilTask.ConfigureAwait(false);
+                    var d1 = await sourceTask.ConfigureAwait(false);
+                    var d2 = await untilTask.ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(d1, d2);
-            });
+                    return StableCompositeAsyncDisposable.Create(d1, d2);
+                });
         }
 
         public static IAsyncObservable<TSource> SkipUntil<TSource>(this IAsyncObservable<TSource> source, DateTimeOffset endTime)
@@ -41,14 +44,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use SkipUntil with a Timer parameter. Do we want SkipUntil on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.SkipUntil(observer, endTime).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                endTime,
+                static async (source, endTime, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.SkipUntil(observer, endTime).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<TSource> SkipUntil<TSource>(this IAsyncObservable<TSource> source, DateTimeOffset endTime, IAsyncScheduler scheduler)
@@ -60,14 +66,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use SkipUntil with a Timer parameter. Do we want SkipUntil on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.SkipUntil(observer, endTime).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (scheduler, endTime),
+                static async (source, state, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.SkipUntil(observer, state.endTime).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/SkipWhile.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> SkipWhile<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> SkipWhile<TSource>(this IAsyncObservable<TSource> source, Func<TSource, int, bool> predicate)
@@ -35,7 +41,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> SkipWhile<TSource>(this IAsyncObservable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
@@ -45,7 +54,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.SkipWhile(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/SubscribeOn.cs

@@ -28,32 +28,35 @@ namespace System.Reactive.Linq
             if (disposeScheduler == null)
                 throw new ArgumentNullException(nameof(disposeScheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var m = new SingleAssignmentAsyncDisposable();
-                var d = new SerialAsyncDisposable();
-
-                await d.AssignAsync(m).ConfigureAwait(false);
-
-                var scheduled = await subscribeScheduler.ScheduleAsync(async ct =>
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (subscribeScheduler, disposeScheduler),
+                static async (source, state, observer) =>
                 {
-                    var subscription = await source.SubscribeSafeAsync(observer).RendezVous(subscribeScheduler, ct);
+                    var m = new SingleAssignmentAsyncDisposable();
+                    var d = new SerialAsyncDisposable();
 
-                    var scheduledDispose = AsyncDisposable.Create(async () =>
+                    await d.AssignAsync(m).ConfigureAwait(false);
+
+                    var scheduled = await state.subscribeScheduler.ScheduleAsync(async ct =>
                     {
-                        await disposeScheduler.ScheduleAsync(async _ =>
+                        var subscription = await source.SubscribeSafeAsync(observer).RendezVous(state.subscribeScheduler, ct);
+
+                        var scheduledDispose = AsyncDisposable.Create(async () =>
                         {
-                            await subscription.DisposeAsync().RendezVous(disposeScheduler, ct);
-                        }).ConfigureAwait(false);
-                    });
+                            await state.disposeScheduler.ScheduleAsync(async _ =>
+                            {
+                                await subscription.DisposeAsync().RendezVous(state.disposeScheduler, ct);
+                            }).ConfigureAwait(false);
+                        });
 
-                    await d.AssignAsync(scheduledDispose).RendezVous(subscribeScheduler, ct);
-                }).ConfigureAwait(false);
+                        await d.AssignAsync(scheduledDispose).RendezVous(state.subscribeScheduler, ct);
+                    }).ConfigureAwait(false);
 
-                await m.AssignAsync(scheduled).ConfigureAwait(false);
+                    await m.AssignAsync(scheduled).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
     }
 }

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

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32>(observer => source.SubscribeSafeAsync(AsyncObserver.SumInt32(observer, selector)));
+            return CreateAsyncObservable<Int32>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32>> selector)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32>(observer => source.SubscribeSafeAsync(AsyncObserver.SumInt32(observer, selector)));
+            return CreateAsyncObservable<Int32>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32?> Sum(this IAsyncObservable<Int32?> source)
@@ -51,7 +57,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Int32?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int32?> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int32?>> selector)
@@ -61,7 +70,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int32?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt32(observer, selector)));
+            return CreateAsyncObservable<Int32?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt32(observer, selector)));
         }
 
         public static IAsyncObservable<Int64> Sum(this IAsyncObservable<Int64> source)
@@ -79,7 +91,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64>(observer => source.SubscribeSafeAsync(AsyncObserver.SumInt64(observer, selector)));
+            return CreateAsyncObservable<Int64>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64>> selector)
@@ -89,7 +104,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64>(observer => source.SubscribeSafeAsync(AsyncObserver.SumInt64(observer, selector)));
+            return CreateAsyncObservable<Int64>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64?> Sum(this IAsyncObservable<Int64?> source)
@@ -107,7 +125,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Int64?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Int64?> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Int64?>> selector)
@@ -117,7 +138,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Int64?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt64(observer, selector)));
+            return CreateAsyncObservable<Int64?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableInt64(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Sum(this IAsyncObservable<Single> source)
@@ -135,7 +159,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.SumSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single>> selector)
@@ -145,7 +172,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single>(observer => source.SubscribeSafeAsync(AsyncObserver.SumSingle(observer, selector)));
+            return CreateAsyncObservable<Single>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Sum(this IAsyncObservable<Single?> source)
@@ -163,7 +193,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Single?> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Single?>> selector)
@@ -173,7 +206,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Single?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableSingle(observer, selector)));
+            return CreateAsyncObservable<Single?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableSingle(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Sum(this IAsyncObservable<Double> source)
@@ -191,7 +227,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.SumDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double>> selector)
@@ -201,7 +240,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double>(observer => source.SubscribeSafeAsync(AsyncObserver.SumDouble(observer, selector)));
+            return CreateAsyncObservable<Double>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Sum(this IAsyncObservable<Double?> source)
@@ -219,7 +261,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Double?> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Double?>> selector)
@@ -229,7 +274,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Double?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableDouble(observer, selector)));
+            return CreateAsyncObservable<Double?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableDouble(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Sum(this IAsyncObservable<Decimal> source)
@@ -247,7 +295,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.SumDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal>> selector)
@@ -257,7 +308,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal>(observer => source.SubscribeSafeAsync(AsyncObserver.SumDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Sum(this IAsyncObservable<Decimal?> source)
@@ -275,7 +329,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableDecimal(observer, selector)));
         }
 
         public static IAsyncObservable<Decimal?> Sum<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<Decimal?>> selector)
@@ -285,7 +342,10 @@ namespace System.Reactive.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<Decimal?>(observer => source.SubscribeSafeAsync(AsyncObserver.SumNullableDecimal(observer, selector)));
+            return CreateAsyncObservable<Decimal?>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.SumNullableDecimal(observer, selector)));
         }
 
     }

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

@@ -42,7 +42,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=typeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=typeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
         public static IAsyncObservable<<#=typeName#>> <#=name#><TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<<#=typeName#>>> selector)
@@ -52,7 +55,10 @@ foreach (var t in types)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Create<<#=typeName#>>(observer => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
+            return Build<<#=typeName#>>.From(
+                source,
+                selector,
+                static (source, selector, observer) => source.SubscribeSafeAsync(AsyncObserver.<#=name#><#=methodName#>(observer, selector)));
         }
 
 <#

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Synchronize.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (gate == null)
                 throw new ArgumentNullException(nameof(gate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Synchronize(observer, gate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                gate,
+                static (source, gate, observer) => source.SubscribeSafeAsync(AsyncObserver.Synchronize(observer, gate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Take.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
                 return Empty<TSource>();
             }
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Take(observer, count)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                count,
+                static (source, count, observer) => source.SubscribeSafeAsync(AsyncObserver.Take(observer, count)));
         }
 
         public static IAsyncObservable<TSource> Take<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration)
@@ -40,14 +43,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use TakeUntil with a Timer parameter. Do we want Take on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.Take(observer, duration).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                duration,
+                static async (source, duration, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.Take(observer, duration).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<TSource> Take<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration, IAsyncScheduler scheduler)
@@ -56,7 +62,7 @@ namespace System.Reactive.Linq
                 throw new ArgumentNullException(nameof(source));
             if (duration < TimeSpan.Zero)
                 throw new ArgumentOutOfRangeException(nameof(duration));
-            if (scheduler == null)
+            if (scheduler == null)  // REVIEW: scheduler not used.
                 throw new ArgumentNullException(nameof(scheduler));
 
             if (duration == TimeSpan.Zero)
@@ -66,14 +72,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use TakeUntil with a Timer parameter. Do we want Take on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.Take(observer, duration).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (duration, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.Take(observer, state.duration).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/TakeLast.cs

@@ -23,14 +23,17 @@ namespace System.Reactive.Linq
                 return Empty<TSource>();
             }
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = AsyncObserver.TakeLast(observer, count);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                count,
+                static async (source, count, observer) =>
+                {
+                    var (sink, drain) = AsyncObserver.TakeLast(observer, count);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
 
         public static IAsyncObservable<TSource> TakeLast<TSource>(this IAsyncObservable<TSource> source, int count, IAsyncScheduler scheduler)
@@ -47,14 +50,17 @@ namespace System.Reactive.Linq
                 return Empty<TSource>();
             }
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = AsyncObserver.TakeLast(observer, count, scheduler);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (count, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sink, drain) = AsyncObserver.TakeLast(observer, state.count, state.scheduler);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
 
         public static IAsyncObservable<TSource> TakeLast<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration)
@@ -69,14 +75,17 @@ namespace System.Reactive.Linq
                 return Empty<TSource>();
             }
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = AsyncObserver.TakeLast(observer, duration);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                duration,
+                static async (source, duration, observer) =>
+                {
+                    var (sink, drain) = AsyncObserver.TakeLast(observer, duration);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
 
         public static IAsyncObservable<TSource> TakeLast<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration, IClock clock)
@@ -93,14 +102,17 @@ namespace System.Reactive.Linq
                 return Empty<TSource>();
             }
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = AsyncObserver.TakeLast(observer, duration, clock);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (duration, clock),
+                static async (source, state, observer) =>
+                {
+                    var (sink, drain) = AsyncObserver.TakeLast(observer, state.duration, state.clock);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
 
         public static IAsyncObservable<TSource> TakeLast<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration, IClock clock, IAsyncScheduler scheduler)
@@ -119,14 +131,17 @@ namespace System.Reactive.Linq
                 return Empty<TSource>();
             }
 
-            return Create<TSource>(async observer =>
-            {
-                var (sink, drain) = AsyncObserver.TakeLast(observer, duration, clock, scheduler);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (duration, clock, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sink, drain) = AsyncObserver.TakeLast(observer, state.duration, state.clock, state.scheduler);
 
-                var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, drain);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, drain);
+                });
         }
 
         public static IAsyncObservable<TSource> TakeLast<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration, IAsyncScheduler scheduler) => TakeLast(source, duration, scheduler, scheduler);

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/TakeLastBuffer.cs

@@ -22,7 +22,10 @@ namespace System.Reactive.Linq
                 return Empty<IList<TSource>>();
             }
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.TakeLastBuffer(observer, count)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                count,
+                static (source, count, observer) => source.SubscribeSafeAsync(AsyncObserver.TakeLastBuffer(observer, count)));
         }
 
         public static IAsyncObservable<IList<TSource>> TakeLastBuffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration)
@@ -37,7 +40,10 @@ namespace System.Reactive.Linq
                 return Empty<IList<TSource>>();
             }
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.TakeLastBuffer(observer, duration)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                duration,
+                static (source, duration, observer) => source.SubscribeSafeAsync(AsyncObserver.TakeLastBuffer(observer, duration)));
         }
 
         public static IAsyncObservable<IList<TSource>> TakeLastBuffer<TSource>(this IAsyncObservable<TSource> source, TimeSpan duration, IClock clock)
@@ -54,7 +60,10 @@ namespace System.Reactive.Linq
                 return Empty<IList<TSource>>();
             }
 
-            return Create<IList<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.TakeLastBuffer(observer, duration, clock)));
+            return CreateAsyncObservable<IList<TSource>>.From(
+                source,
+                (duration, clock),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.TakeLastBuffer(observer, state.duration, state.clock)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/TakeUntil.cs

@@ -18,20 +18,23 @@ namespace System.Reactive.Linq
             if (until == null)
                 throw new ArgumentNullException(nameof(until));
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, untilObserver) = AsyncObserver.TakeUntil<TSource, TUntil>(observer);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                until,
+                static async (source, until, observer) =>
+                {
+                    var (sourceObserver, untilObserver) = AsyncObserver.TakeUntil<TSource, TUntil>(observer);
 
-                var sourceTask = source.SubscribeSafeAsync(sourceObserver);
-                var untilTask = until.SubscribeSafeAsync(untilObserver);
+                    var sourceTask = source.SubscribeSafeAsync(sourceObserver);
+                    var untilTask = until.SubscribeSafeAsync(untilObserver);
 
-                // REVIEW: Consider concurrent subscriptions.
+                    // REVIEW: Consider concurrent subscriptions.
 
-                var d1 = await sourceTask.ConfigureAwait(false);
-                var d2 = await untilTask.ConfigureAwait(false);
+                    var d1 = await sourceTask.ConfigureAwait(false);
+                    var d2 = await untilTask.ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(d1, d2);
-            });
+                    return StableCompositeAsyncDisposable.Create(d1, d2);
+                });
         }
 
         public static IAsyncObservable<TSource> TakeUntil<TSource>(this IAsyncObservable<TSource> source, DateTimeOffset endTime)
@@ -41,14 +44,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use TakeUntil with a Timer parameter. Do we want TakeUntil on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.TakeUntil(observer, endTime).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                endTime,
+                static async (source, endTime, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.TakeUntil(observer, endTime).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
 
         public static IAsyncObservable<TSource> TakeUntil<TSource>(this IAsyncObservable<TSource> source, DateTimeOffset endTime, IAsyncScheduler scheduler)
@@ -60,14 +66,17 @@ namespace System.Reactive.Linq
 
             // REVIEW: May be easier to just use TakeUntil with a Timer parameter. Do we want TakeUntil on the observer?
 
-            return Create<TSource>(async observer =>
-            {
-                var (sourceObserver, timer) = await AsyncObserver.TakeUntil(observer, endTime, scheduler).ConfigureAwait(false);
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (endTime, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var (sourceObserver, timer) = await AsyncObserver.TakeUntil(observer, state.endTime, state.scheduler).ConfigureAwait(false);
 
-                var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(subscription, timer);
-            });
+                    return StableCompositeAsyncDisposable.Create(subscription, timer);
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/TakeWhile.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> TakeWhile<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> TakeWhile<TSource>(this IAsyncObservable<TSource> source, Func<TSource, int, bool> predicate)
@@ -35,7 +41,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> TakeWhile<TSource>(this IAsyncObservable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
@@ -45,7 +54,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.TakeWhile(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Throttle.cs

@@ -17,20 +17,23 @@ namespace System.Reactive.Linq
             if (dueTime < TimeSpan.Zero)
                 throw new ArgumentOutOfRangeException(nameof(dueTime));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                dueTime,
+                static async (source, dueTime, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sink, throttler) = AsyncObserver.Throttle(observer, dueTime);
+                    var (sink, throttler) = AsyncObserver.Throttle(observer, dueTime);
 
-                await d.AddAsync(throttler).ConfigureAwait(false);
+                    await d.AddAsync(throttler).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await d.AddAsync(sourceSubscription).ConfigureAwait(false);
+                    await d.AddAsync(sourceSubscription).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
 
         public static IAsyncObservable<TSource> Throttle<TSource>(this IAsyncObservable<TSource> source, TimeSpan dueTime, IAsyncScheduler scheduler)
@@ -42,20 +45,23 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (dueTime, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sink, throttler) = AsyncObserver.Throttle(observer, dueTime, scheduler);
+                    var (sink, throttler) = AsyncObserver.Throttle(observer, state.dueTime, state.scheduler);
 
-                await d.AddAsync(throttler).ConfigureAwait(false);
+                    await d.AddAsync(throttler).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await d.AddAsync(sourceSubscription).ConfigureAwait(false);
+                    await d.AddAsync(sourceSubscription).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
 
         public static IAsyncObservable<TSource> Throttle<TSource, TThrottle>(this IAsyncObservable<TSource> source, Func<TSource, IAsyncObservable<TThrottle>> throttleSelector)
@@ -65,20 +71,23 @@ namespace System.Reactive.Linq
             if (throttleSelector == null)
                 throw new ArgumentNullException(nameof(throttleSelector));
 
-            return Create<TSource>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                throttleSelector,
+                static async (source, throttleSelector, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sink, throttler) = AsyncObserver.Throttle(observer, throttleSelector);
+                    var (sink, throttler) = AsyncObserver.Throttle(observer, throttleSelector);
 
-                await d.AddAsync(throttler).ConfigureAwait(false);
+                    await d.AddAsync(throttler).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await d.AddAsync(sourceSubscription).ConfigureAwait(false);
+                    await d.AddAsync(sourceSubscription).ConfigureAwait(false);
 
-                return d;
-            });
+                    return d;
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/TimeInterval.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (clock == null)
                 throw new ArgumentNullException(nameof(clock));
 
-            return Create<TimeInterval<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.TimeInterval(observer, clock)));
+            return CreateAsyncObservable<TimeInterval<TSource>>.From(
+                source,
+                clock,
+                static (source, clock, observer) => source.SubscribeSafeAsync(AsyncObserver.TimeInterval(observer, clock))); ;
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Timeout.cs

@@ -16,18 +16,21 @@ namespace System.Reactive.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Create<TSource>(async observer =>
-            {
-                var sourceSubscription = new SingleAssignmentAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                dueTime,
+                static async (source, dueTime, observer) =>
+                {
+                    var sourceSubscription = new SingleAssignmentAsyncDisposable();
 
-                var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, dueTime).ConfigureAwait(false);
+                    var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, dueTime).ConfigureAwait(false);
 
-                var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
+                    await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
 
-                return disposable;
-            });
+                    return disposable;
+                });
         }
 
         public static IAsyncObservable<TSource> Timeout<TSource>(this IAsyncObservable<TSource> source, TimeSpan dueTime, IAsyncScheduler scheduler)
@@ -37,18 +40,21 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var sourceSubscription = new SingleAssignmentAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (dueTime, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var sourceSubscription = new SingleAssignmentAsyncDisposable();
 
-                var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, dueTime, scheduler).ConfigureAwait(false);
+                    var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, state.dueTime, state.scheduler).ConfigureAwait(false);
 
-                var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
+                    await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
 
-                return disposable;
-            });
+                    return disposable;
+                });
         }
 
         public static IAsyncObservable<TSource> Timeout<TSource>(this IAsyncObservable<TSource> source, TimeSpan dueTime, IAsyncObservable<TSource> other)
@@ -58,18 +64,21 @@ namespace System.Reactive.Linq
             if (other == null)
                 throw new ArgumentNullException(nameof(other));
 
-            return Create<TSource>(async observer =>
-            {
-                var sourceSubscription = new SingleAssignmentAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (dueTime, other),
+                static async (source, state, observer) =>
+                {
+                    var sourceSubscription = new SingleAssignmentAsyncDisposable();
 
-                var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, dueTime, other).ConfigureAwait(false);
+                    var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, state.dueTime, state.other).ConfigureAwait(false);
 
-                var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
+                    await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
 
-                return disposable;
-            });
+                    return disposable;
+                });
         }
 
         public static IAsyncObservable<TSource> Timeout<TSource>(this IAsyncObservable<TSource> source, TimeSpan dueTime, IAsyncObservable<TSource> other, IAsyncScheduler scheduler)
@@ -81,18 +90,21 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<TSource>(async observer =>
-            {
-                var sourceSubscription = new SingleAssignmentAsyncDisposable();
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                (dueTime, other, scheduler),
+                static async (source, state, observer) =>
+                {
+                    var sourceSubscription = new SingleAssignmentAsyncDisposable();
 
-                var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, dueTime, other, scheduler).ConfigureAwait(false);
+                    var (sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, state.dueTime, state.other, state.scheduler).ConfigureAwait(false);
 
-                var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
+                    var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
 
-                await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
+                    await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
 
-                return disposable;
-            });
+                    return disposable;
+                });
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Timestamp.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (clock == null)
                 throw new ArgumentNullException(nameof(clock));
 
-            return Create<Timestamped<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.Timestamp(observer, clock)));
+            return CreateAsyncObservable<Timestamped<TSource>>.From(
+                source,
+                clock,
+                static (source, clock, observer) => source.SubscribeSafeAsync(AsyncObserver.Timestamp(observer, clock)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/ToDictionary.cs

@@ -18,7 +18,10 @@ namespace System.Reactive.Linq
             if (valueSelector == null)
                 throw new ArgumentNullException(nameof(valueSelector));
 
-            return Create<IDictionary<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, keySelector, valueSelector)));
+            return CreateAsyncObservable<IDictionary<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, state.keySelector, state.valueSelector)));
         }
 
         public static IAsyncObservable<IDictionary<TKey, TValue>> ToDictionary<TSource, TKey, TValue>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, IEqualityComparer<TKey> comparer)
@@ -32,7 +35,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IDictionary<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, keySelector, valueSelector, comparer)));
+            return CreateAsyncObservable<IDictionary<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, state.keySelector, state.valueSelector, state.comparer))); ;
         }
 
         public static IAsyncObservable<IDictionary<TKey, TValue>> ToDictionary<TSource, TKey, TValue>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TValue>> valueSelector)
@@ -44,7 +50,10 @@ namespace System.Reactive.Linq
             if (valueSelector == null)
                 throw new ArgumentNullException(nameof(valueSelector));
 
-            return Create<IDictionary<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, keySelector, valueSelector)));
+            return CreateAsyncObservable<IDictionary<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, state.keySelector, state.valueSelector)));
         }
 
         public static IAsyncObservable<IDictionary<TKey, TValue>> ToDictionary<TSource, TKey, TValue>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TValue>> valueSelector, IEqualityComparer<TKey> comparer)
@@ -58,7 +67,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<IDictionary<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, keySelector, valueSelector, comparer)));
+            return CreateAsyncObservable<IDictionary<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToDictionary(observer, state.keySelector, state.valueSelector, state.comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/ToHashSet.cs

@@ -23,7 +23,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<HashSet<TSource>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToHashSet(observer, comparer)));
+            return CreateAsyncObservable<HashSet<TSource>>.From(
+                source,
+                comparer,
+                static (source, comparer, observer) => source.SubscribeSafeAsync(AsyncObserver.ToHashSet(observer, comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/ToLookup.cs

@@ -19,7 +19,10 @@ namespace System.Reactive.Linq
             if (valueSelector == null)
                 throw new ArgumentNullException(nameof(valueSelector));
 
-            return Create<ILookup<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, keySelector, valueSelector)));
+            return CreateAsyncObservable<ILookup<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, state.keySelector, state.valueSelector)));
         }
 
         public static IAsyncObservable<ILookup<TKey, TValue>> ToLookup<TSource, TKey, TValue>(this IAsyncObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, IEqualityComparer<TKey> comparer)
@@ -33,7 +36,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<ILookup<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, keySelector, valueSelector, comparer)));
+            return CreateAsyncObservable<ILookup<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, state.keySelector, state.valueSelector, state.comparer)));
         }
 
         public static IAsyncObservable<ILookup<TKey, TValue>> ToLookup<TSource, TKey, TValue>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TValue>> valueSelector)
@@ -45,7 +51,10 @@ namespace System.Reactive.Linq
             if (valueSelector == null)
                 throw new ArgumentNullException(nameof(valueSelector));
 
-            return Create<ILookup<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, keySelector, valueSelector)));
+            return CreateAsyncObservable<ILookup<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, state.keySelector, state.valueSelector)));
         }
 
         public static IAsyncObservable<ILookup<TKey, TValue>> ToLookup<TSource, TKey, TValue>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TValue>> valueSelector, IEqualityComparer<TKey> comparer)
@@ -59,7 +68,10 @@ namespace System.Reactive.Linq
             if (comparer == null)
                 throw new ArgumentNullException(nameof(comparer));
 
-            return Create<ILookup<TKey, TValue>>(observer => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, keySelector, valueSelector, comparer)));
+            return CreateAsyncObservable<ILookup<TKey, TValue>>.From(
+                source,
+                (keySelector, valueSelector, comparer),
+                static (source, state, observer) => source.SubscribeSafeAsync(AsyncObserver.ToLookup(observer, state.keySelector, state.valueSelector, state.comparer)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Where.cs

@@ -15,7 +15,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> Where<TSource>(this IAsyncObservable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
@@ -25,7 +28,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> Where<TSource>(this IAsyncObservable<TSource> source, Func<TSource, int, bool> predicate)
@@ -35,7 +41,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
         }
 
         public static IAsyncObservable<TSource> Where<TSource>(this IAsyncObservable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
@@ -45,7 +54,10 @@ namespace System.Reactive.Linq
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return Create<TSource>(observer => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
+            return CreateAsyncObservable<TSource>.From(
+                source,
+                predicate,
+                static (source, predicate, observer) => source.SubscribeSafeAsync(AsyncObserver.Where(observer, predicate)));
         }
     }
 

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/Window.cs

@@ -20,7 +20,10 @@ namespace System.Reactive.Linq
             if (count <= 0)
                 throw new ArgumentOutOfRangeException(nameof(count));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowCore(source, observer, (o, d) => AsyncObserver.Window(o, d, count)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                count,
+                static (source, count, observer) => WindowCore(source, observer, (o, d) => AsyncObserver.Window(o, d, count)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource>(this IAsyncObservable<TSource> source, int count, int skip)
@@ -32,7 +35,10 @@ namespace System.Reactive.Linq
             if (skip <= 0)
                 throw new ArgumentOutOfRangeException(nameof(skip));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowCore(source, observer, (o, d) => AsyncObserver.Window(o, d, count, skip)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                (count, skip),
+                static (source, state, observer) => WindowCore(source, observer, (o, d) => AsyncObserver.Window(o, d, state.count, state.skip)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan)
@@ -42,7 +48,10 @@ namespace System.Reactive.Linq
             if (timeSpan < TimeSpan.Zero)
                 throw new ArgumentOutOfRangeException(nameof(timeSpan));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, timeSpan)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                timeSpan,
+                static (source, timeSpan, observer) => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, timeSpan)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, IAsyncScheduler scheduler)
@@ -54,7 +63,10 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, timeSpan, scheduler)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                (timeSpan, scheduler),
+                static (source, state, observer) => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, state.timeSpan, state.scheduler)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift)
@@ -66,7 +78,10 @@ namespace System.Reactive.Linq
             if (timeShift < TimeSpan.Zero)
                 throw new ArgumentOutOfRangeException(nameof(timeShift));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, timeSpan, timeShift)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                (timeSpan, timeShift),
+                static (source, state, observer) => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, state.timeSpan, state.timeShift)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IAsyncScheduler scheduler)
@@ -80,7 +95,10 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, timeSpan, timeShift, scheduler)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                (timeSpan, timeShift, scheduler),
+                static (source, state, observer) => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, state.timeSpan, state.timeShift, state.scheduler)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, int count)
@@ -92,7 +110,10 @@ namespace System.Reactive.Linq
             if (count <= 0)
                 throw new ArgumentOutOfRangeException(nameof(count));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, timeSpan, count)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                (timeSpan, count),
+                static (source, state, observer) => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, state.timeSpan, state.count)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource>(this IAsyncObservable<TSource> source, TimeSpan timeSpan, int count, IAsyncScheduler scheduler)
@@ -106,7 +127,10 @@ namespace System.Reactive.Linq
             if (scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
 
-            return Create<IAsyncObservable<TSource>>(observer => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, timeSpan, count, scheduler)));
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                (timeSpan, count, scheduler),
+                static (source, state, observer) => WindowAsyncCore(source, observer, (o, d) => AsyncObserver.Window(o, d, state.timeSpan, state.count, state.scheduler)));
         }
 
         public static IAsyncObservable<IAsyncObservable<TSource>> Window<TSource, TWindowBoundary>(this IAsyncObservable<TSource> source, IAsyncObservable<TWindowBoundary> windowBoundaries)
@@ -116,20 +140,23 @@ namespace System.Reactive.Linq
             if (windowBoundaries == null)
                 throw new ArgumentNullException(nameof(windowBoundaries));
 
-            return Create<IAsyncObservable<TSource>>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                windowBoundaries,
+                static async (source, windowBoundaries, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sourceObserver, boundariesObserver, subscription) = await AsyncObserver.Window<TSource, TWindowBoundary>(observer, d).ConfigureAwait(false);
+                    var (sourceObserver, boundariesObserver, subscription) = await AsyncObserver.Window<TSource, TWindowBoundary>(observer, d).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
-                await d.AddAsync(sourceSubscription).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    await d.AddAsync(sourceSubscription).ConfigureAwait(false);
 
-                var boundariesSubscription = await windowBoundaries.SubscribeSafeAsync(boundariesObserver).ConfigureAwait(false);
-                await d.AddAsync(boundariesSubscription).ConfigureAwait(false);
+                    var boundariesSubscription = await windowBoundaries.SubscribeSafeAsync(boundariesObserver).ConfigureAwait(false);
+                    await d.AddAsync(boundariesSubscription).ConfigureAwait(false);
 
-                return subscription;
-            });
+                    return subscription;
+                });
         }
 
         // REVIEW: This overload is inherited from Rx but arguably a bit esoteric as it doesn't provide context to the closing selector.
@@ -141,19 +168,22 @@ namespace System.Reactive.Linq
             if (windowClosingSelector == null)
                 throw new ArgumentNullException(nameof(windowClosingSelector));
 
-            return Create<IAsyncObservable<TSource>>(async observer =>
-            {
-                var d = new CompositeAsyncDisposable();
+            return CreateAsyncObservable<IAsyncObservable<TSource>>.From(
+                source,
+                windowClosingSelector,
+                static async (source, windowClosingSelector, observer) =>
+                {
+                    var d = new CompositeAsyncDisposable();
 
-                var (sourceObserver, closingSubscription, subscription) = await AsyncObserver.Window<TSource, TWindowClosing>(observer, windowClosingSelector, d).ConfigureAwait(false);
+                    var (sourceObserver, closingSubscription, subscription) = await AsyncObserver.Window<TSource, TWindowClosing>(observer, windowClosingSelector, d).ConfigureAwait(false);
 
-                await d.AddAsync(closingSubscription).ConfigureAwait(false);
+                    await d.AddAsync(closingSubscription).ConfigureAwait(false);
 
-                var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
-                await d.AddAsync(sourceSubscription).ConfigureAwait(false);
+                    var sourceSubscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
+                    await d.AddAsync(sourceSubscription).ConfigureAwait(false);
 
-                return subscription;
-            });
+                    return subscription;
+                });
         }
 
         private static async ValueTask<IAsyncDisposable> WindowCore<TSource>(IAsyncObservable<TSource> source, IAsyncObserver<IAsyncObservable<TSource>> observer, Func<IAsyncObserver<IAsyncObservable<TSource>>, IAsyncDisposable, (IAsyncObserver<TSource>, IAsyncDisposable)> createObserver)

AsyncRx.NET/System.Reactive.Async.Linq/System/Reactive/Linq/Operators/WithLatestFrom.cs

@@ -17,17 +17,20 @@ namespace System.Reactive.Linq
             if (second == null)
                 throw new ArgumentNullException(nameof(second));
 
-            return Create<(TFirst first, TSecond second)>(async observer =>
-            {
-                var (firstObserver, secondObserver) = AsyncObserver.WithLatestFrom(observer);
+            return CreateAsyncObservable<(TFirst first, TSecond second)>.From(
+                first,
+                second,
+                static async (first, second, observer) =>
+                {
+                    var (firstObserver, secondObserver) = AsyncObserver.WithLatestFrom(observer);
 
-                // REVIEW: Consider concurrent subscriptions.
+                    // REVIEW: Consider concurrent subscriptions.
 
-                var firstSubscription = await first.SubscribeSafeAsync(firstObserver).ConfigureAwait(false);
-                var secondSubscription = await second.SubscribeSafeAsync(secondObserver).ConfigureAwait(false);
+                    var firstSubscription = await first.SubscribeSafeAsync(firstObserver).ConfigureAwait(false);
+                    var secondSubscription = await second.SubscribeSafeAsync(secondObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
-            });
+                    return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
+                });
         }
 
         public static IAsyncObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(this IAsyncObservable<TFirst> first, IAsyncObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
@@ -39,17 +42,20 @@ namespace System.Reactive.Linq
             if (resultSelector == null)
                 throw new ArgumentNullException(nameof(resultSelector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (firstObserver, secondObserver) = AsyncObserver.WithLatestFrom(observer, resultSelector);
+            return CreateAsyncObservable<TResult>.From(
+                first,
+                (second, resultSelector),
+                static async (first, state, observer) =>
+                {
+                    var (firstObserver, secondObserver) = AsyncObserver.WithLatestFrom(observer, state.resultSelector);
 
-                // REVIEW: Consider concurrent subscriptions.
+                    // REVIEW: Consider concurrent subscriptions.
 
-                var firstSubscription = await first.SubscribeSafeAsync(firstObserver).ConfigureAwait(false);
-                var secondSubscription = await second.SubscribeSafeAsync(secondObserver).ConfigureAwait(false);
+                    var firstSubscription = await first.SubscribeSafeAsync(firstObserver).ConfigureAwait(false);
+                    var secondSubscription = await state.second.SubscribeSafeAsync(secondObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
-            });
+                    return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
+                });
         }
 
         public static IAsyncObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(this IAsyncObservable<TFirst> first, IAsyncObservable<TSecond> second, Func<TFirst, TSecond, ValueTask<TResult>> resultSelector)
@@ -61,17 +67,20 @@ namespace System.Reactive.Linq
             if (resultSelector == null)
                 throw new ArgumentNullException(nameof(resultSelector));
 
-            return Create<TResult>(async observer =>
-            {
-                var (firstObserver, secondObserver) = AsyncObserver.WithLatestFrom(observer, resultSelector);
+            return CreateAsyncObservable<TResult>.From(
+                first,
+                (second, resultSelector),
+                static async (first, state, observer) =>
+                {
+                    var (firstObserver, secondObserver) = AsyncObserver.WithLatestFrom(observer, state.resultSelector);
 
-                // REVIEW: Consider concurrent subscriptions.
+                    // REVIEW: Consider concurrent subscriptions.
 
-                var firstSubscription = await first.SubscribeSafeAsync(firstObserver).ConfigureAwait(false);
-                var secondSubscription = await second.SubscribeSafeAsync(secondObserver).ConfigureAwait(false);
+                    var firstSubscription = await first.SubscribeSafeAsync(firstObserver).ConfigureAwait(false);
+                    var secondSubscription = await state.second.SubscribeSafeAsync(secondObserver).ConfigureAwait(false);
 
-                return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
-            });
+                    return StableCompositeAsyncDisposable.Create(firstSubscription, secondSubscription);
+                });
         }
     }