diff --git a/Ix.NET/Source/Ix.NET.sln.DotSettings b/Ix.NET/Source/Ix.NET.sln.DotSettings
index 953521b5f6..36f7776843 100644
--- a/Ix.NET/Source/Ix.NET.sln.DotSettings
+++ b/Ix.NET/Source/Ix.NET.sln.DotSettings
@@ -1,5 +1,8 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeEditing/GenerateMemberBody/CopyXmlDocumentation/@EntryValue">True</s:Boolean>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=SuggestVarOrType_005FBuiltInTypes/@EntryIndexedValue">SUGGESTION</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=SuggestVarOrType_005FElsewhere/@EntryIndexedValue">SUGGESTION</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=SuggestVarOrType_005FSimpleTypes/@EntryIndexedValue">SUGGESTION</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=NoReordering/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="NoReordering"&gt;&lt;RemoveCodeRedundancies&gt;True&lt;/RemoveCodeRedundancies&gt;&lt;CSUseAutoProperty&gt;True&lt;/CSUseAutoProperty&gt;&lt;CSMakeFieldReadonly&gt;True&lt;/CSMakeFieldReadonly&gt;&lt;CSMakeAutoPropertyGetOnly&gt;True&lt;/CSMakeAutoPropertyGetOnly&gt;&lt;CSArrangeQualifiers&gt;True&lt;/CSArrangeQualifiers&gt;&lt;CSFixBuiltinTypeReferences&gt;True&lt;/CSFixBuiltinTypeReferences&gt;&lt;CSEnforceVarKeywordUsageSettings&gt;True&lt;/CSEnforceVarKeywordUsageSettings&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;EmbraceInRegion&gt;False&lt;/EmbraceInRegion&gt;&lt;RegionName&gt;&lt;/RegionName&gt;&lt;/CSOptimizeUsings&gt;&lt;CSShortenReferences&gt;True&lt;/CSShortenReferences&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;CSharpFormatDocComments&gt;True&lt;/CSharpFormatDocComments&gt;&lt;AspOptimizeRegisterDirectives&gt;True&lt;/AspOptimizeRegisterDirectives&gt;&lt;HtmlReformatCode&gt;True&lt;/HtmlReformatCode&gt;&lt;FormatAttributeQuoteDescriptor&gt;True&lt;/FormatAttributeQuoteDescriptor&gt;&lt;JsInsertSemicolon&gt;True&lt;/JsInsertSemicolon&gt;&lt;CorrectVariableKindsDescriptor&gt;True&lt;/CorrectVariableKindsDescriptor&gt;&lt;VariablesToInnerScopesDescriptor&gt;True&lt;/VariablesToInnerScopesDescriptor&gt;&lt;StringToTemplatesDescriptor&gt;True&lt;/StringToTemplatesDescriptor&gt;&lt;JsReformatCode&gt;True&lt;/JsReformatCode&gt;&lt;JsFormatDocComments&gt;True&lt;/JsFormatDocComments&gt;&lt;RemoveRedundantQualifiersTs&gt;True&lt;/RemoveRedundantQualifiersTs&gt;&lt;OptimizeImportsTs&gt;True&lt;/OptimizeImportsTs&gt;&lt;OptimizeReferenceCommentsTs&gt;True&lt;/OptimizeReferenceCommentsTs&gt;&lt;PublicModifierStyleTs&gt;True&lt;/PublicModifierStyleTs&gt;&lt;TypeAnnotationStyleTs&gt;True&lt;/TypeAnnotationStyleTs&gt;&lt;ExplicitAnyTs&gt;True&lt;/ExplicitAnyTs&gt;&lt;RelativePathStyleTs&gt;True&lt;/RelativePathStyleTs&gt;&lt;XMLReformatCode&gt;True&lt;/XMLReformatCode&gt;&lt;CppReformatCode&gt;True&lt;/CppReformatCode&gt;&lt;CssAlphabetizeProperties&gt;True&lt;/CssAlphabetizeProperties&gt;&lt;CssReformatCode&gt;True&lt;/CssReformatCode&gt;&lt;VBOptimizeImports&gt;True&lt;/VBOptimizeImports&gt;&lt;VBShortenReferences&gt;True&lt;/VBShortenReferences&gt;&lt;VBReformatCode&gt;True&lt;/VBReformatCode&gt;&lt;VBFormatDocComments&gt;True&lt;/VBFormatDocComments&gt;&lt;CSCodeStyleAttributes ArrangeTypeAccessModifier="True" ArrangeTypeMemberAccessModifier="True" SortModifiers="True" RemoveRedundantParentheses="False" AddMissingParentheses="False" ArrangeBraces="False" ArrangeAttributes="False" ArrangeArgumentsStyle="False" /&gt;&lt;/Profile&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=Normal/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="Normal"&gt;&lt;CSArrangeThisQualifier&gt;True&lt;/CSArrangeThisQualifier&gt;&lt;CSUpdateFileHeader&gt;False&lt;/CSUpdateFileHeader&gt;&lt;CSRemoveCodeRedundancies&gt;True&lt;/CSRemoveCodeRedundancies&gt;&lt;CSUseAutoProperty&gt;True&lt;/CSUseAutoProperty&gt;&lt;CSMakeFieldReadonly&gt;True&lt;/CSMakeFieldReadonly&gt;&lt;CSUseVar&gt;&lt;BehavourStyle&gt;CAN_CHANGE_TO_IMPLICIT&lt;/BehavourStyle&gt;&lt;LocalVariableStyle&gt;ALWAYS_IMPLICIT&lt;/LocalVariableStyle&gt;&lt;ForeachVariableStyle&gt;ALWAYS_IMPLICIT&lt;/ForeachVariableStyle&gt;&lt;/CSUseVar&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;EmbraceInRegion&gt;False&lt;/EmbraceInRegion&gt;&lt;RegionName&gt;&lt;/RegionName&gt;&lt;/CSOptimizeUsings&gt;&lt;CSShortenReferences&gt;True&lt;/CSShortenReferences&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;CSharpFormatDocComments&gt;True&lt;/CSharpFormatDocComments&gt;&lt;CSReorderTypeMembers&gt;True&lt;/CSReorderTypeMembers&gt;&lt;CssAlphabetizeProperties&gt;True&lt;/CssAlphabetizeProperties&gt;&lt;CssReformatCode&gt;True&lt;/CssReformatCode&gt;&lt;XMLReformatCode&gt;True&lt;/XMLReformatCode&gt;&lt;JsReformatCode&gt;True&lt;/JsReformatCode&gt;&lt;JsInsertSemicolon&gt;True&lt;/JsInsertSemicolon&gt;&lt;VBReformatCode&gt;True&lt;/VBReformatCode&gt;&lt;VBShortenReferences&gt;True&lt;/VBShortenReferences&gt;&lt;VBOptimizeImports&gt;True&lt;/VBOptimizeImports&gt;&lt;HtmlReformatCode&gt;True&lt;/HtmlReformatCode&gt;&lt;AspOptimizeRegisterDirectives&gt;True&lt;/AspOptimizeRegisterDirectives&gt;&lt;RemoveCodeRedundancies&gt;True&lt;/RemoveCodeRedundancies&gt;&lt;CSMakeAutoPropertyGetOnly&gt;True&lt;/CSMakeAutoPropertyGetOnly&gt;&lt;CSArrangeQualifiers&gt;True&lt;/CSArrangeQualifiers&gt;&lt;CSEnforceVarKeywordUsageSettings&gt;True&lt;/CSEnforceVarKeywordUsageSettings&gt;&lt;CSFixBuiltinTypeReferences&gt;True&lt;/CSFixBuiltinTypeReferences&gt;&lt;FormatAttributeQuoteDescriptor&gt;True&lt;/FormatAttributeQuoteDescriptor&gt;&lt;CorrectVariableKindsDescriptor&gt;True&lt;/CorrectVariableKindsDescriptor&gt;&lt;VariablesToInnerScopesDescriptor&gt;True&lt;/VariablesToInnerScopesDescriptor&gt;&lt;StringToTemplatesDescriptor&gt;True&lt;/StringToTemplatesDescriptor&gt;&lt;JsFormatDocComments&gt;True&lt;/JsFormatDocComments&gt;&lt;RemoveRedundantQualifiersTs&gt;True&lt;/RemoveRedundantQualifiersTs&gt;&lt;OptimizeImportsTs&gt;True&lt;/OptimizeImportsTs&gt;&lt;OptimizeReferenceCommentsTs&gt;True&lt;/OptimizeReferenceCommentsTs&gt;&lt;PublicModifierStyleTs&gt;True&lt;/PublicModifierStyleTs&gt;&lt;ExplicitAnyTs&gt;True&lt;/ExplicitAnyTs&gt;&lt;TypeAnnotationStyleTs&gt;True&lt;/TypeAnnotationStyleTs&gt;&lt;RelativePathStyleTs&gt;True&lt;/RelativePathStyleTs&gt;&lt;CppReformatCode&gt;True&lt;/CppReformatCode&gt;&lt;VBFormatDocComments&gt;True&lt;/VBFormatDocComments&gt;&lt;CSCodeStyleAttributes ArrangeTypeAccessModifier="True" ArrangeTypeMemberAccessModifier="True" SortModifiers="True" RemoveRedundantParentheses="False" AddMissingParentheses="False" ArrangeBraces="False" ArrangeAttributes="False" ArrangeArgumentsStyle="False" /&gt;&lt;/Profile&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/RecentlyUsedProfile/@EntryValue">Default: Full Cleanup</s:String>
diff --git a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Aggregates.cs b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Aggregates.cs
index c2d4670137..cd523ac638 100644
--- a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Aggregates.cs
+++ b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Aggregates.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information. 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 using System.Threading;
 
@@ -14,64 +13,37 @@ public static partial class AsyncEnumerable
         public static Task<TResult> Aggregate<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (accumulator == null)
-                throw new ArgumentNullException("accumulator");
+                throw new ArgumentNullException(nameof(accumulator));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
-            var tcs = new TaskCompletionSource<TResult>();
+            return Aggregate_(source, seed, accumulator, resultSelector, cancellationToken);
+        }
 
+        private static async Task<TResult> Aggregate_<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource> source, TAccumulate seed,
+            Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector, CancellationToken cancellationToken)
+        {
             var acc = seed;
 
-            var e = source.GetEnumerator();
-
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        try
-                        {
-                            acc = accumulator(acc, e.Current);
-                            f(ct);
-                        }
-                        catch (Exception exception)
-                        {
-                            tcs.TrySetException(exception);
-                        }
-                    }
-                    else
-                    {
-                        var result = default(TResult);
-                        try
-                        {
-                            result = resultSelector(acc);
-                        }
-                        catch (Exception exception)
-                        {
-                            tcs.TrySetException(exception);
-                            return;
-                        }
-
-                        tcs.TrySetResult(result);
-                    }
-                });
-            });
-
-            f(cancellationToken);
+                    acc = accumulator(acc, e.Current);
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return resultSelector(acc);
         }
 
         public static Task<TAccumulate> Aggregate<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (accumulator == null)
-                throw new ArgumentNullException("accumulator");
+                throw new ArgumentNullException(nameof(accumulator));
 
             return source.Aggregate(seed, accumulator, x => x, cancellationToken);
         }
@@ -79,58 +51,35 @@ public static Task<TAccumulate> Aggregate<TSource, TAccumulate>(this IAsyncEnume
         public static Task<TSource> Aggregate<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (accumulator == null)
-                throw new ArgumentNullException("accumulator");
-            
-            var tcs = new TaskCompletionSource<TSource>();
+                throw new ArgumentNullException(nameof(accumulator));
 
+            return Aggregate_(source, accumulator, cancellationToken);
+        }
+
+        private static async Task<TSource> Aggregate_<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator, CancellationToken cancellationToken)
+        {
             var first = true;
             var acc = default(TSource);
 
-            var e = source.GetEnumerator();
-
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        try
-                        {
-                            if (first)
-                                acc = e.Current;
-                            else
-                                acc = accumulator(acc, e.Current);
-                            f(ct);
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                        }
-
-                        first = false;
-                    }
-                    else
-                    {
-                        if (first)
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                        else
-                            tcs.TrySetResult(acc);
-                    }
-                });
-            });
-
-            f(cancellationToken);
-
-            return tcs.Task.Finally(e.Dispose);
+                    acc = first ? e.Current : accumulator(acc, e.Current);
+                    first = false;
+                }
+            }
+            if (first)
+                throw new InvalidOperationException(Strings.NO_ELEMENTS);
+            return acc;
         }
 
         public static Task<int> Count<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(0, (c, _) => checked(c + 1), cancellationToken);
         }
@@ -138,9 +87,9 @@ public static Task<int> Count<TSource>(this IAsyncEnumerable<TSource> source, Ca
         public static Task<int> Count<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).Aggregate(0, (c, _) => checked(c + 1), cancellationToken);
         }
@@ -148,7 +97,7 @@ public static Task<int> Count<TSource>(this IAsyncEnumerable<TSource> source, Fu
         public static Task<long> LongCount<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(0L, (c, _) => checked(c + 1), cancellationToken);
         }
@@ -156,9 +105,9 @@ public static Task<long> LongCount<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<long> LongCount<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).Aggregate(0L, (c, _) => checked(c + 1), cancellationToken);
         }
@@ -166,91 +115,53 @@ public static Task<long> LongCount<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<bool> All<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
-
-            var tcs = new TaskCompletionSource<bool>();
+                throw new ArgumentNullException(nameof(predicate));
 
-            var e = source.GetEnumerator();
+            return All_(source, predicate, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<bool> All_<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        try
-                        {
-                            if (!predicate(e.Current))
-                                tcs.TrySetResult(false);
-                            else
-                                f(ct);
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                        }
-                    }
-                    else
-                    {
-                        tcs.TrySetResult(true);
-                    }
-                });
-            });
-
-            f(cancellationToken);
-
-            return tcs.Task.Finally(e.Dispose);
+                    if (!predicate(e.Current))
+                        return false;
+                }
+            }
+            return true;
         }
 
         public static Task<bool> Any<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
-            var tcs = new TaskCompletionSource<bool>();
-
-            var e = source.GetEnumerator();
+            return Any_(source, predicate, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<bool> Any_<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        try
-                        {
-                            if (predicate(e.Current))
-                                tcs.TrySetResult(true);
-                            else
-                                f(ct);
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                        }
-                    }
-                    else
-                    {
-                        tcs.TrySetResult(false);
-                    }
-                });
-            });
-
-            f(cancellationToken);
-
-            return tcs.Task.Finally(e.Dispose);
+                    if (predicate(e.Current))
+                        return true;
+                }
+            }
+            return false;
         }
 
         public static Task<bool> Any<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             var e = source.GetEnumerator();
             return e.MoveNext(cancellationToken);
@@ -259,9 +170,9 @@ public static Task<bool> Any<TSource>(this IAsyncEnumerable<TSource> source, Can
         public static Task<bool> Contains<TSource>(this IAsyncEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.Any(x => comparer.Equals(x, value), cancellationToken);
         }
@@ -269,7 +180,7 @@ public static Task<bool> Contains<TSource>(this IAsyncEnumerable<TSource> source
         public static Task<bool> Contains<TSource>(this IAsyncEnumerable<TSource> source, TSource value, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Contains(value, EqualityComparer<TSource>.Default, cancellationToken);
         }
@@ -277,32 +188,29 @@ public static Task<bool> Contains<TSource>(this IAsyncEnumerable<TSource> source
         public static Task<TSource> First<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
-            var tcs = new TaskCompletionSource<TSource>();
-
-            var e = source.GetEnumerator();
+            return First_(source, cancellationToken);
+        }
 
-            e.MoveNext(cancellationToken).Then(t =>
+        private static async Task<TSource> First_<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                        tcs.TrySetResult(e.Current);
-                    else
-                        tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                });
-            });
-
-            return tcs.Task.Finally(e.Dispose);
+                    return e.Current;
+                }
+            }
+            throw new InvalidOperationException(Strings.NO_ELEMENTS);
         }
 
         public static Task<TSource> First<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).First(cancellationToken);
         }
@@ -310,32 +218,29 @@ public static Task<TSource> First<TSource>(this IAsyncEnumerable<TSource> source
         public static Task<TSource> FirstOrDefault<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<TSource>();
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return FirstOrDefault_(source, cancellationToken);
+        }
 
-            e.MoveNext(cancellationToken).Then(t =>
+        private static async Task<TSource> FirstOrDefault_<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                        tcs.TrySetResult(e.Current);
-                    else
-                        tcs.TrySetResult(default(TSource));
-                });
-            });
-
-            return tcs.Task.Finally(e.Dispose);
+                    return e.Current;
+                }
+            }
+            return default(TSource);
         }
 
         public static Task<TSource> FirstOrDefault<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).FirstOrDefault(cancellationToken);
         }
@@ -343,46 +248,35 @@ public static Task<TSource> FirstOrDefault<TSource>(this IAsyncEnumerable<TSourc
         public static Task<TSource> Last<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
-            var tcs = new TaskCompletionSource<TSource>();
+            return Last_(source, cancellationToken);
+        }
 
-            var e = source.GetEnumerator();
+        private static async Task<TSource> Last_<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
             var last = default(TSource);
             var hasLast = false;
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        hasLast = true;
-                        last = e.Current;
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (!hasLast)
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                        else
-                            tcs.TrySetResult(last);
-                    }
-                });
-            });
-
-            f(cancellationToken);
-
-            return tcs.Task.Finally(e.Dispose);
+                    hasLast = true;
+                    last = e.Current;
+                }
+            }
+            if (!hasLast)
+                throw new InvalidOperationException(Strings.NO_ELEMENTS);
+            return last;
         }
 
         public static Task<TSource> Last<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).Last(cancellationToken);
         }
@@ -390,46 +284,33 @@ public static Task<TSource> Last<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<TSource> LastOrDefault<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
-            var tcs = new TaskCompletionSource<TSource>();
+            return LastOrDefault_(source, cancellationToken);
+        }
 
-            var e = source.GetEnumerator();
+        private static async Task<TSource> LastOrDefault_<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
             var last = default(TSource);
             var hasLast = false;
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        hasLast = true;
-                        last = e.Current;
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (!hasLast)
-                            tcs.TrySetResult(default(TSource));
-                        else
-                            tcs.TrySetResult(last);
-                    }
-                });
-            });
-
-            f(cancellationToken);
-
-            return tcs.Task.Finally(e.Dispose);
+                    hasLast = true;
+                    last = e.Current;
+                }
+            }
+            return !hasLast ? default(TSource) : last;
         }
 
         public static Task<TSource> LastOrDefault<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).LastOrDefault(cancellationToken);
         }
@@ -437,44 +318,34 @@ public static Task<TSource> LastOrDefault<TSource>(this IAsyncEnumerable<TSource
         public static Task<TSource> Single<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<TSource>();
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return Single_(source, cancellationToken);
+        }
 
-            e.MoveNext(cancellationToken).Then(t =>
+        private static async Task<TSource> Single_<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        var result = e.Current;
-                        e.MoveNext(cancellationToken).Then(t1 =>
-                        {
-                            t1.Handle(tcs, res1 =>
-                            {
-                                if (res1)
-                                    tcs.TrySetException(new InvalidOperationException(Strings.MORE_THAN_ONE_ELEMENT));
-                                else
-                                    tcs.TrySetResult(result);
-                            });
-                        });
-                    }
-                    else
-                        tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                });
-            });
-
-            return tcs.Task.Finally(e.Dispose);
+                    throw new InvalidOperationException(Strings.NO_ELEMENTS);
+                }
+                var result = e.Current;
+                if (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                {
+                    throw new InvalidOperationException(Strings.MORE_THAN_ONE_ELEMENT);
+                }
+                return result;
+            }
         }
 
         public static Task<TSource> Single<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).Single(cancellationToken);
         }
@@ -482,44 +353,35 @@ public static Task<TSource> Single<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<TSource> SingleOrDefault<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<TSource>();
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return SingleOrDefault_(source, cancellationToken);
+        }
 
-            e.MoveNext(cancellationToken).Then(t =>
+        private static async Task<TSource> SingleOrDefault_<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        var result = e.Current;
-                        e.MoveNext(cancellationToken).Then(t1 =>
-                        {
-                            t1.Handle(tcs, res1 =>
-                            {
-                                if (res1)
-                                    tcs.TrySetException(new InvalidOperationException(Strings.MORE_THAN_ONE_ELEMENT));
-                                else
-                                    tcs.TrySetResult(result);
-                            });
-                        });
-                    }
-                    else
-                        tcs.TrySetResult(default(TSource));
-                });
-            });
+                    return default(TSource);
+                }
 
-            return tcs.Task.Finally(e.Dispose);
+                var result = e.Current;
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                {
+                    return result;
+                }
+            }
+            throw new InvalidOperationException(Strings.MORE_THAN_ONE_ELEMENT);
         }
 
         public static Task<TSource> SingleOrDefault<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return source.Where(predicate).SingleOrDefault(cancellationToken);
         }
@@ -527,87 +389,69 @@ public static Task<TSource> SingleOrDefault<TSource>(this IAsyncEnumerable<TSour
         public static Task<TSource> ElementAt<TSource>(this IAsyncEnumerable<TSource> source, int index, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (index < 0)
-                throw new ArgumentOutOfRangeException("index");
-
-            var tcs = new TaskCompletionSource<TSource>();
+                throw new ArgumentOutOfRangeException(nameof(index));
 
-            var e = source.GetEnumerator();
+            return ElementAt_(source, index, cancellationToken);
+        }
 
-            var next = default(Action<CancellationToken>);
-            next = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<TSource> ElementAt_<TSource>(IAsyncEnumerable<TSource> source, int index, CancellationToken cancellationToken)
+        {
+            if (index >= 0)
             {
-                t.Handle(tcs, res =>
+                using (var e = source.GetEnumerator())
                 {
-                    if (res)
+                    while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                     {
                         if (index == 0)
                         {
-                            tcs.TrySetResult(e.Current);
-                        }
-                        else
-                        {
-                            index--;
-                            next(ct);
+                            return e.Current;
                         }
-                    }
-                    else
-                    {
-                        tcs.TrySetException(new ArgumentOutOfRangeException("index"));
-                    }
-                });
-            });
 
-            next(cancellationToken);
+                        index--;
+                    }
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            throw new ArgumentOutOfRangeException(nameof(index));
         }
 
         public static Task<TSource> ElementAtOrDefault<TSource>(this IAsyncEnumerable<TSource> source, int index, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (index < 0)
-                throw new ArgumentOutOfRangeException("index");
+                throw new ArgumentOutOfRangeException(nameof(index));
 
-            var tcs = new TaskCompletionSource<TSource>();
-
-            var e = source.GetEnumerator();
+            return ElementAtOrDefault_(source, index, cancellationToken);
+        }
 
-            var next = default(Action<CancellationToken>);
-            next = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<TSource> ElementAtOrDefault_<TSource>(IAsyncEnumerable<TSource> source, int index, CancellationToken cancellationToken)
+        {
+            if (index >= 0)
             {
-                t.Handle(tcs, res =>
+                using (var e = source.GetEnumerator())
                 {
-                    if (res)
+                    while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                     {
                         if (index == 0)
                         {
-                            tcs.TrySetResult(e.Current);
-                        }
-                        else
-                        {
-                            index--;
-                            next(ct);
+                            return e.Current;
                         }
-                    }
-                    else
-                    {
-                        tcs.TrySetResult(default(TSource));
-                    }
-                });
-            });
 
-            next(cancellationToken);
+                        index--;
+                    }
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return default(TSource);
         }
 
         public static Task<TSource[]> ToArray<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(new List<TSource>(), (list, x) => { list.Add(x); return list; }, list => list.ToArray(), cancellationToken);
         }
@@ -615,7 +459,7 @@ public static Task<TSource[]> ToArray<TSource>(this IAsyncEnumerable<TSource> so
         public static Task<List<TSource>> ToList<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(new List<TSource>(), (list, x) => { list.Add(x); return list; }, cancellationToken);
         }
@@ -623,13 +467,13 @@ public static Task<List<TSource>> ToList<TSource>(this IAsyncEnumerable<TSource>
         public static Task<Dictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.Aggregate(new Dictionary<TKey, TElement>(comparer), (d, x) => { d.Add(keySelector(x), elementSelector(x)); return d; }, cancellationToken);
         }
@@ -637,11 +481,11 @@ public static Task<Dictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElem
         public static Task<Dictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
 
             return source.ToDictionary(keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
         }
@@ -649,11 +493,11 @@ public static Task<Dictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElem
         public static Task<Dictionary<TKey, TSource>> ToDictionary<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.ToDictionary(keySelector, x => x, comparer, cancellationToken);
         }
@@ -661,35 +505,37 @@ public static Task<Dictionary<TKey, TSource>> ToDictionary<TSource, TKey>(this I
         public static Task<Dictionary<TKey, TSource>> ToDictionary<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.ToDictionary(keySelector, x => x, EqualityComparer<TKey>.Default, cancellationToken);
         }
 
-        public static Task<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
+        public static async Task<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
+
+            var lookup = await Internal.Lookup<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
 
-            return source.Aggregate(new Lookup<TKey, TElement>(comparer), (lookup, x) => { lookup.Add(keySelector(x), elementSelector(x)); return lookup; }, lookup => (ILookup<TKey, TElement>)lookup, cancellationToken);
+            return lookup;
         }
 
         public static Task<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
 
             return source.ToLookup(keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
         }
@@ -697,11 +543,11 @@ public static Task<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(th
         public static Task<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.ToLookup(keySelector, x => x, comparer, cancellationToken);
         }
@@ -709,461 +555,370 @@ public static Task<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(this IAsyncEn
         public static Task<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.ToLookup(keySelector, x => x, EqualityComparer<TKey>.Default, cancellationToken);
         }
 
-        class Lookup<TKey, TElement> : ILookup<TKey, TElement>
+        public static Task<double> Average(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
         {
-            private readonly Dictionary<TKey, EnumerableGrouping<TKey, TElement>> map;
+            if (source == null)
+                throw new ArgumentNullException(nameof(source));
 
-            public Lookup(IEqualityComparer<TKey> comparer)
-            {
-                map = new Dictionary<TKey, EnumerableGrouping<TKey, TElement>>(comparer);
-            }
+            return Average_(source, cancellationToken);
+        }
 
-            public void Add(TKey key, TElement element)
+        private static async Task<double> Average_(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                var g = default(EnumerableGrouping<TKey, TElement>);
-                if (!map.TryGetValue(key, out g))
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    g = new EnumerableGrouping<TKey, TElement>(key);
-                    map.Add(key, g);
+                    throw new InvalidOperationException(Strings.NO_ELEMENTS);
                 }
 
-                g.Add(element);
-            }
-
-            public bool Contains(TKey key)
-            {
-                return map.ContainsKey(key);
-            }
-
-            public int Count
-            {
-                get { return map.Keys.Count; }
-            }
-
-            public IEnumerable<TElement> this[TKey key]
-            {
-                get { return map[key]; }
-            }
-
-            public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
-            {
-                return map.Values.Cast<IGrouping<TKey, TElement>>().GetEnumerator();
-            }
-
-            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
-            {
-                return GetEnumerator();
-            }
-        }
-
-        public static Task<double> Average(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
-        {
-            if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<double>();
-
-            var count = 0L;
-            var sum = 0.0;
-
-            var e = source.GetEnumerator();
-
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
-            {
-                t.Handle(tcs, res =>
+                long sum = e.Current;
+                long count = 1;
+                checked
                 {
-                    if (res)
+                    while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                     {
-                        count++;
                         sum += e.Current;
-                        f(ct);
+                        ++count;
                     }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
-
-            f(cancellationToken);
+                }
 
-            return tcs.Task.Finally(e.Dispose);
+                return (double)sum / count;
+            }
         }
 
         public static Task<double?> Average(this IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<double?>();
-
-            var count = 0L;
-            var sum = 0.0;
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<double?> Average_(IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
+                    var v = e.Current;
+                    if (v.HasValue)
                     {
-                        if (e.Current.HasValue)
+                        long sum = v.GetValueOrDefault();
+                        long count = 1;
+                        checked
                         {
-                            count++;
-                            sum += e.Current.Value;
+                            while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                            {
+                                v = e.Current;
+                                if (v.HasValue)
+                                {
+                                    sum += v.GetValueOrDefault();
+                                    ++count;
+                                }
+                            }
                         }
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetResult(null);
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
 
-            f(cancellationToken);
+                        return (double)sum / count;
+                    }
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return null;
         }
 
         public static Task<double> Average(this IAsyncEnumerable<long> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
-            var tcs = new TaskCompletionSource<double>();
-
-            var count = 0L;
-            var sum = 0.0;
-
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<double> Average_(IAsyncEnumerable<long> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
+                    throw new InvalidOperationException(Strings.NO_ELEMENTS);
+                }
+
+                var sum = e.Current;
+                long count = 1;
+                checked
+                {
+                    while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                     {
-                        count++;
                         sum += e.Current;
-                        f(ct);
+                        ++count;
                     }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
-
-            f(cancellationToken);
+                }
 
-            return tcs.Task.Finally(e.Dispose);
+                return (double)sum / count;
+            }
         }
 
         public static Task<double?> Average(this IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<double?>();
+                throw new ArgumentNullException(nameof(source));
 
-            var count = 0L;
-            var sum = 0.0;
-
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<double?> Average_(IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
+                    var v = e.Current;
+                    if (v.HasValue)
                     {
-                        if (e.Current.HasValue)
+                        var sum = v.GetValueOrDefault();
+                        long count = 1;
+                        checked
                         {
-                            count++;
-                            sum += e.Current.Value;
+                            while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                            {
+                                v = e.Current;
+                                if (v.HasValue)
+                                {
+                                    sum += v.GetValueOrDefault();
+                                    ++count;
+                                }
+                            }
                         }
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetResult(null);
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
 
-            f(cancellationToken);
+                        return (double)sum / count;
+                    }
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return null;
         }
 
         public static Task<double> Average(this IAsyncEnumerable<double> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<double>();
+                throw new ArgumentNullException(nameof(source));
 
-            var count = 0L;
-            var sum = 0.0;
-
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<double> Average_(IAsyncEnumerable<double> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        count++;
-                        sum += e.Current;
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
+                    throw new InvalidOperationException(Strings.NO_ELEMENTS);
+                }
 
-            f(cancellationToken);
+                var sum = e.Current;
+                long count = 1;
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                {
+                    // There is an opportunity to short-circuit here, in that if e.Current is
+                    // ever NaN then the result will always be NaN. Assuming that this case is
+                    // rare enough that not checking is the better approach generally.
+                    sum += e.Current;
+                    ++count;
+                }
 
-            return tcs.Task.Finally(e.Dispose);
+                return sum / count;
+            }
         }
 
         public static Task<double?> Average(this IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<double?>();
+                throw new ArgumentNullException(nameof(source));
 
-            var count = 0L;
-            var sum = 0.0;
-
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<double?> Average_(IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
+                    var v = e.Current;
+                    if (v.HasValue)
                     {
-                        if (e.Current.HasValue)
+                        var sum = v.GetValueOrDefault();
+                        long count = 1;
+                        checked
                         {
-                            count++;
-                            sum += e.Current.Value;
+                            while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                            {
+                                v = e.Current;
+                                if (v.HasValue)
+                                {
+                                    sum += v.GetValueOrDefault();
+                                    ++count;
+                                }
+                            }
                         }
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetResult(null);
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
 
-            f(cancellationToken);
+                        return sum / count;
+                    }
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return null;
         }
 
         public static Task<float> Average(this IAsyncEnumerable<float> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<float>();
-
-            var count = 0L;
-            var sum = 0f;
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<float> Average_(IAsyncEnumerable<float> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        count++;
-                        sum += e.Current;
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
+                    throw new InvalidOperationException(Strings.NO_ELEMENTS);
+                }
 
-            f(cancellationToken);
+                double sum = e.Current;
+                long count = 1;
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                {
+                    sum += e.Current;
+                    ++count;
+                }
 
-            return tcs.Task.Finally(e.Dispose);
+                return (float)(sum / count);
+            }
         }
 
         public static Task<float?> Average(this IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<float?>();
-
-            var count = 0L;
-            var sum = 0f;
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<float?> Average_(IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
+                    var v = e.Current;
+                    if (v.HasValue)
                     {
-                        if (e.Current.HasValue)
+                        double sum = v.GetValueOrDefault();
+                        long count = 1;
+                        checked
                         {
-                            count++;
-                            sum += e.Current.Value;
+                            while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                            {
+                                v = e.Current;
+                                if (v.HasValue)
+                                {
+                                    sum += v.GetValueOrDefault();
+                                    ++count;
+                                }
+                            }
                         }
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetResult(null);
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
 
-            f(cancellationToken);
+                        return (float)(sum / count);
+                    }
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return null;
         }
 
         public static Task<decimal> Average(this IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<decimal>();
-
-            var count = 0L;
-            var sum = 0m;
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<decimal> Average_(IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
-                    {
-                        count++;
-                        sum += e.Current;
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
+                    throw new InvalidOperationException(Strings.NO_ELEMENTS);
+                }
 
-            f(cancellationToken);
+                var sum = e.Current;
+                long count = 1;
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                {
+                    sum += e.Current;
+                    ++count;
+                }
 
-            return tcs.Task.Finally(e.Dispose);
+                return sum / count;
+            }
         }
 
         public static Task<decimal?> Average(this IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
-
-            var tcs = new TaskCompletionSource<decimal?>();
-
-            var count = 0L;
-            var sum = 0m;
+                throw new ArgumentNullException(nameof(source));
 
-            var e = source.GetEnumerator();
+            return Average_(source, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+        private static async Task<decimal?> Average_(IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
+        {
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (res)
+                    var v = e.Current;
+                    if (v.HasValue)
                     {
-                        if (e.Current.HasValue)
+                        var sum = v.GetValueOrDefault();
+                        long count = 1;
+                        while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                         {
-                            count++;
-                            sum += e.Current.Value;
+                            v = e.Current;
+                            if (v.HasValue)
+                            {
+                                sum += v.GetValueOrDefault();
+                                ++count;
+                            }
                         }
-                        f(ct);
-                    }
-                    else
-                    {
-                        if (count == 0)
-                            tcs.TrySetResult(null);
-                        else
-                            tcs.TrySetResult(sum / count);
-                    }
-                });
-            });
 
-            f(cancellationToken);
+                        return sum / count;
+                    }
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return null;
         }
 
         public static Task<double?> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1171,9 +926,9 @@ public static Task<decimal> Average(this IAsyncEnumerable<decimal> source, Cance
         public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1181,9 +936,9 @@ public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1191,9 +946,9 @@ public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<double?> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1201,9 +956,9 @@ public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1211,9 +966,9 @@ public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<double?> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1221,9 +976,9 @@ public static Task<double> Average<TSource>(this IAsyncEnumerable<TSource> sourc
         public static Task<float> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1231,9 +986,9 @@ public static Task<float> Average<TSource>(this IAsyncEnumerable<TSource> source
         public static Task<float?> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1241,9 +996,9 @@ public static Task<float> Average<TSource>(this IAsyncEnumerable<TSource> source
         public static Task<decimal> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1251,9 +1006,9 @@ public static Task<decimal> Average<TSource>(this IAsyncEnumerable<TSource> sour
         public static Task<decimal?> Average<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Average(cancellationToken);
         }
@@ -1261,7 +1016,7 @@ public static Task<decimal> Average<TSource>(this IAsyncEnumerable<TSource> sour
         public static Task<int> Max(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Max, cancellationToken);
         }
@@ -1269,7 +1024,7 @@ public static Task<int> Max(this IAsyncEnumerable<int> source, CancellationToken
         public static Task<long> Max(this IAsyncEnumerable<long> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Max, cancellationToken);
         }
@@ -1277,7 +1032,7 @@ public static Task<long> Max(this IAsyncEnumerable<long> source, CancellationTok
         public static Task<double> Max(this IAsyncEnumerable<double> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Max, cancellationToken);
         }
@@ -1285,7 +1040,7 @@ public static Task<double> Max(this IAsyncEnumerable<double> source, Cancellatio
         public static Task<float> Max(this IAsyncEnumerable<float> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Max, cancellationToken);
         }
@@ -1293,7 +1048,7 @@ public static Task<float> Max(this IAsyncEnumerable<float> source, CancellationT
         public static Task<decimal> Max(this IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Max, cancellationToken);
         }
@@ -1313,7 +1068,7 @@ public static Task<decimal> Max(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<int?> Max(this IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(int?), NullableMax, cancellationToken);
         }
@@ -1321,7 +1076,7 @@ public static Task<decimal> Max(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<long?> Max(this IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(long?), NullableMax, cancellationToken);
         }
@@ -1329,7 +1084,7 @@ public static Task<decimal> Max(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<double?> Max(this IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(double?), NullableMax, cancellationToken);
         }
@@ -1337,7 +1092,7 @@ public static Task<decimal> Max(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<float?> Max(this IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(float?), NullableMax, cancellationToken);
         }
@@ -1345,7 +1100,7 @@ public static Task<decimal> Max(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<decimal?> Max(this IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(decimal?), NullableMax, cancellationToken);
         }
@@ -1353,7 +1108,7 @@ public static Task<decimal> Max(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<TSource> Max<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             var comparer = Comparer<TSource>.Default;
             return source.Aggregate((x, y) => comparer.Compare(x, y) >= 0 ? x : y, cancellationToken);
@@ -1362,9 +1117,9 @@ public static Task<TSource> Max<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<int> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1372,9 +1127,9 @@ public static Task<int> Max<TSource>(this IAsyncEnumerable<TSource> source, Func
         public static Task<long> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1382,9 +1137,9 @@ public static Task<long> Max<TSource>(this IAsyncEnumerable<TSource> source, Fun
         public static Task<double> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1392,9 +1147,9 @@ public static Task<double> Max<TSource>(this IAsyncEnumerable<TSource> source, F
         public static Task<float> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1402,9 +1157,9 @@ public static Task<float> Max<TSource>(this IAsyncEnumerable<TSource> source, Fu
         public static Task<decimal> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1412,9 +1167,9 @@ public static Task<decimal> Max<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<int?> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1422,9 +1177,9 @@ public static Task<decimal> Max<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<long?> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1432,9 +1187,9 @@ public static Task<decimal> Max<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<double?> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1442,9 +1197,9 @@ public static Task<decimal> Max<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<float?> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1452,9 +1207,9 @@ public static Task<decimal> Max<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<decimal?> Max<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1462,9 +1217,9 @@ public static Task<decimal> Max<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<TResult> Max<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Max(cancellationToken);
         }
@@ -1472,7 +1227,7 @@ public static Task<TResult> Max<TSource, TResult>(this IAsyncEnumerable<TSource>
         public static Task<int> Min(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Min, cancellationToken);
         }
@@ -1480,7 +1235,7 @@ public static Task<int> Min(this IAsyncEnumerable<int> source, CancellationToken
         public static Task<long> Min(this IAsyncEnumerable<long> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Min, cancellationToken);
         }
@@ -1488,7 +1243,7 @@ public static Task<long> Min(this IAsyncEnumerable<long> source, CancellationTok
         public static Task<double> Min(this IAsyncEnumerable<double> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Min, cancellationToken);
         }
@@ -1496,7 +1251,7 @@ public static Task<double> Min(this IAsyncEnumerable<double> source, Cancellatio
         public static Task<float> Min(this IAsyncEnumerable<float> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Min, cancellationToken);
         }
@@ -1504,7 +1259,7 @@ public static Task<float> Min(this IAsyncEnumerable<float> source, CancellationT
         public static Task<decimal> Min(this IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(Math.Min, cancellationToken);
         }
@@ -1524,7 +1279,7 @@ public static Task<decimal> Min(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<int?> Min(this IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(int?), NullableMin, cancellationToken);
         }
@@ -1532,7 +1287,7 @@ public static Task<decimal> Min(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<long?> Min(this IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(long?), NullableMin, cancellationToken);
         }
@@ -1540,7 +1295,7 @@ public static Task<decimal> Min(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<double?> Min(this IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(double?), NullableMin, cancellationToken);
         }
@@ -1548,7 +1303,7 @@ public static Task<decimal> Min(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<float?> Min(this IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(float?), NullableMin, cancellationToken);
         }
@@ -1556,7 +1311,7 @@ public static Task<decimal> Min(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<decimal?> Min(this IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(default(decimal?), NullableMin, cancellationToken);
         }
@@ -1564,7 +1319,7 @@ public static Task<decimal> Min(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<TSource> Min<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             var comparer = Comparer<TSource>.Default;
             return source.Aggregate((x, y) => comparer.Compare(x, y) <= 0 ? x : y, cancellationToken);
@@ -1573,9 +1328,9 @@ public static Task<TSource> Min<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<int> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1583,9 +1338,9 @@ public static Task<int> Min<TSource>(this IAsyncEnumerable<TSource> source, Func
         public static Task<long> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1593,9 +1348,9 @@ public static Task<long> Min<TSource>(this IAsyncEnumerable<TSource> source, Fun
         public static Task<double> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1603,9 +1358,9 @@ public static Task<double> Min<TSource>(this IAsyncEnumerable<TSource> source, F
         public static Task<float> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1613,9 +1368,9 @@ public static Task<float> Min<TSource>(this IAsyncEnumerable<TSource> source, Fu
         public static Task<decimal> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1623,9 +1378,9 @@ public static Task<decimal> Min<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<int?> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1633,9 +1388,9 @@ public static Task<decimal> Min<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<long?> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1643,9 +1398,9 @@ public static Task<decimal> Min<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<double?> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1653,9 +1408,9 @@ public static Task<decimal> Min<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<float?> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1663,9 +1418,9 @@ public static Task<decimal> Min<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<decimal?> Min<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1673,9 +1428,9 @@ public static Task<decimal> Min<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<TResult> Min<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Min(cancellationToken);
         }
@@ -1683,7 +1438,7 @@ public static Task<TResult> Min<TSource, TResult>(this IAsyncEnumerable<TSource>
         public static Task<int> Sum(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(0, (x, y) => x + y, cancellationToken);
         }
@@ -1691,7 +1446,7 @@ public static Task<int> Sum(this IAsyncEnumerable<int> source, CancellationToken
         public static Task<long> Sum(this IAsyncEnumerable<long> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(0L, (x, y) => x + y, cancellationToken);
         }
@@ -1699,7 +1454,7 @@ public static Task<long> Sum(this IAsyncEnumerable<long> source, CancellationTok
         public static Task<double> Sum(this IAsyncEnumerable<double> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(0.0, (x, y) => x + y, cancellationToken);
         }
@@ -1707,7 +1462,7 @@ public static Task<double> Sum(this IAsyncEnumerable<double> source, Cancellatio
         public static Task<float> Sum(this IAsyncEnumerable<float> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(0f, (x, y) => x + y, cancellationToken);
         }
@@ -1715,7 +1470,7 @@ public static Task<float> Sum(this IAsyncEnumerable<float> source, CancellationT
         public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate(0m, (x, y) => x + y, cancellationToken);
         }
@@ -1723,7 +1478,7 @@ public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<int?> Sum(this IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate((int?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
@@ -1731,7 +1486,7 @@ public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<long?> Sum(this IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate((long?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
@@ -1739,7 +1494,7 @@ public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<double?> Sum(this IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate((double?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
@@ -1747,7 +1502,7 @@ public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<float?> Sum(this IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate((float?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
@@ -1755,7 +1510,7 @@ public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<decimal?> Sum(this IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Aggregate((decimal?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
@@ -1763,9 +1518,9 @@ public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, Cancellat
         public static Task<int> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1773,9 +1528,9 @@ public static Task<int> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func
         public static Task<long> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1783,9 +1538,9 @@ public static Task<long> Sum<TSource>(this IAsyncEnumerable<TSource> source, Fun
         public static Task<double> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1793,9 +1548,9 @@ public static Task<double> Sum<TSource>(this IAsyncEnumerable<TSource> source, F
         public static Task<float> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1803,9 +1558,9 @@ public static Task<float> Sum<TSource>(this IAsyncEnumerable<TSource> source, Fu
         public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1813,9 +1568,9 @@ public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<int?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1823,9 +1578,9 @@ public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<long?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1833,9 +1588,9 @@ public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<double?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1843,9 +1598,9 @@ public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<float?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1853,9 +1608,9 @@ public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<decimal?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return source.Select(selector).Sum(cancellationToken);
         }
@@ -1863,27 +1618,37 @@ public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source,
         public static Task<bool> IsEmpty<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
-            return source.Any(cancellationToken).Then(t => !t.Result);
+            return IsEmpty_(source, cancellationToken);
+        }
+
+        private static async Task<bool> IsEmpty_<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            return !await source.Any(cancellationToken).ConfigureAwait(false);
         }
 
         public static Task<TSource> Min<TSource>(this IAsyncEnumerable<TSource> source, IComparer<TSource> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
-            return MinBy(source, x => x, comparer, cancellationToken).Then(t => t.Result.First());
+            return Min_(source, comparer, cancellationToken);
+        }
+
+        private static async Task<TSource> Min_<TSource>(IAsyncEnumerable<TSource> source, IComparer<TSource> comparer, CancellationToken cancellationToken)
+        {
+            return (await MinBy(source, x => x, comparer, cancellationToken).ConfigureAwait(false)).First();
         }
 
         public static Task<IList<TSource>> MinBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return MinBy(source, keySelector, Comparer<TKey>.Default, cancellationToken);
         }
@@ -1891,11 +1656,11 @@ public static Task<IList<TSource>> MinBy<TSource, TKey>(this IAsyncEnumerable<TS
         public static Task<IList<TSource>> MinBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return ExtremaBy(source, keySelector, (key, minValue) => -comparer.Compare(key, minValue), cancellationToken);
         }
@@ -1903,19 +1668,24 @@ public static Task<IList<TSource>> MinBy<TSource, TKey>(this IAsyncEnumerable<TS
         public static Task<TSource> Max<TSource>(this IAsyncEnumerable<TSource> source, IComparer<TSource> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
+
+            return Max_(source, comparer, cancellationToken);
+        }
 
-            return MaxBy(source, x => x, comparer, cancellationToken).Then(t => t.Result.First());
+        private static async Task<TSource> Max_<TSource>(IAsyncEnumerable<TSource> source, IComparer<TSource> comparer, CancellationToken cancellationToken)
+        {
+            return (await MaxBy(source, x => x, comparer, cancellationToken).ConfigureAwait(false)).First();
         }
 
         public static Task<IList<TSource>> MaxBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return MaxBy(source, keySelector, Comparer<TKey>.Default, cancellationToken);
         }
@@ -1923,99 +1693,47 @@ public static Task<IList<TSource>> MaxBy<TSource, TKey>(this IAsyncEnumerable<TS
         public static Task<IList<TSource>> MaxBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return ExtremaBy(source, keySelector, (key, minValue) => comparer.Compare(key, minValue), cancellationToken);
         }
 
-        private static Task<IList<TSource>> ExtremaBy<TSource, TKey>(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, TKey, int> compare, CancellationToken cancellationToken)
+        private static async Task<IList<TSource>> ExtremaBy<TSource, TKey>(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, TKey, int> compare, CancellationToken cancellationToken)
         {
-            var tcs = new TaskCompletionSource<IList<TSource>>();
-
-            var result = new List<TSource>(); 
-            
-            var hasFirst = false;
-            var current = default(TSource);
-            var resKey = default(TKey);
-
-            var e = source.GetEnumerator();
+            var result = new List<TSource>();
 
-            var f = default(Action<CancellationToken>);
-            f = ct => e.MoveNext(ct).Then(t =>
+            using (var e = source.GetEnumerator())
             {
-                t.Handle(tcs, res =>
-                {
-                    if (!hasFirst)
-                    {
-                        if (!res)
-                        {
-                            tcs.TrySetException(new InvalidOperationException(Strings.NO_ELEMENTS));
-                            return;
-                        }
-
-                        current = e.Current;
+                if (!await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                    throw new InvalidOperationException(Strings.NO_ELEMENTS);
 
-                        try
-                        {
-                            resKey = keySelector(current);
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                            return;
-                        }
+                var current = e.Current;
+                var resKey = keySelector(current);
+                result.Add(current);
 
-                        result.Add(current);
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
+                {
+                    var cur = e.Current;
+                    var key = keySelector(cur);
 
-                        hasFirst = true;
-                        f(ct);
+                    var cmp = compare(key, resKey);
+                    if (cmp == 0)
+                    {
+                        result.Add(cur);
                     }
-                    else
+                    else if (cmp > 0)
                     {
-                        if (res)
-                        {
-                            var key = default(TKey);
-                            var cmp = default(int);
-
-                            try
-                            {
-                                current = e.Current;
-                                key = keySelector(current);
-                                cmp = compare(key, resKey);
-                            }
-                            catch (Exception ex)
-                            {
-                                tcs.TrySetException(ex);
-                                return;
-                            }
-
-                            if (cmp == 0)
-                            {
-                                result.Add(current);
-                            }
-                            else if (cmp > 0)
-                            {
-                                result = new List<TSource> { current };
-                                resKey = key;
-                            }
-
-                            f(ct);
-                        }
-                        else
-                        {
-                            tcs.TrySetResult(result);
-                        }
+                        result = new List<TSource> { cur };
+                        resKey = key;
                     }
-                });
-            });
-
-            f(cancellationToken);
+                }
+            }
 
-            return tcs.Task.Finally(e.Dispose);
+            return result;
         }
     }
 }
diff --git a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Conversions.cs b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Conversions.cs
index bdc5579620..8a9096801b 100644
--- a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Conversions.cs
+++ b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Conversions.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information. 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 using System.Threading;
 
@@ -14,16 +13,16 @@ public static partial class AsyncEnumerable
         public static IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return Create(() =>
             {
                 var e = source.GetEnumerator();
 
                 return Create(
-                    ct => Task.Factory.StartNew(() =>
+                    ct => Task.Run(() =>
                     {
-                        var res = default(bool);
+                        var res = false;
                         try
                         {
                             res = e.MoveNext();
@@ -44,7 +43,7 @@ public static IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this IEnumera
         public static IEnumerable<TSource> ToEnumerable<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return ToEnumerable_(source);
         }
@@ -55,9 +54,7 @@ private static IEnumerable<TSource> ToEnumerable_<TSource>(IAsyncEnumerable<TSou
             {
                 while (true)
                 {
-                    var t = e.MoveNext(CancellationToken.None);
-                    t.Wait();
-                    if (!t.Result)
+                    if (!e.MoveNext(CancellationToken.None).Result)
                         break;
                     var c = e.Current;
                     yield return c;
@@ -68,42 +65,32 @@ private static IEnumerable<TSource> ToEnumerable_<TSource>(IAsyncEnumerable<TSou
         public static IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this Task<TSource> task)
         {
             if (task == null)
-                throw new ArgumentNullException("task");
-
+                throw new ArgumentNullException(nameof(task));
+            
             return Create(() =>
             {
                 var called = 0;
 
+                var value = default(TSource);
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
                         if (Interlocked.CompareExchange(ref called, 1, 0) == 0)
                         {
-                            task.Then(continuedTask =>
-                            {
-                                if (continuedTask.IsCanceled)
-                                    tcs.SetCanceled();
-                                else if (continuedTask.IsFaulted)
-                                    tcs.SetException(continuedTask.Exception.InnerException);
-                                else
-                                    tcs.SetResult(true);
-                            });
+                            value = await task.ConfigureAwait(false);
+                            return true;
                         }
-                        else
-                            tcs.SetResult(false);
-
-                        return tcs.Task;
+                        return false;
                     },
-                    () => task.Result,
+                    () => value,
                     () => { });
             });
         }
 
-#if !NO_RXINTERFACES
         public static IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this IObservable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return Create(() =>
             {
@@ -253,7 +240,7 @@ public void OnNext(T value)
         public static IObservable<TSource> ToObservable<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return new ToObservableObservable<TSource>(source);
         }
@@ -304,6 +291,5 @@ public IDisposable Subscribe(IObserver<T> observer)
                 return Disposable.Create(ctd, e);
             }
         }
-#endif
     }
 }
diff --git a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Creation.cs b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Creation.cs
index 0ec6c9e4b0..98f6363403 100644
--- a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Creation.cs
+++ b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Creation.cs
@@ -11,14 +11,14 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
-        static IAsyncEnumerable<T> Create<T>(Func<IAsyncEnumerator<T>> getEnumerator)
+        private static IAsyncEnumerable<T> Create<T>(Func<IAsyncEnumerator<T>> getEnumerator)
         {
             return new AnonymousAsyncEnumerable<T>(getEnumerator);
         }
 
-        class AnonymousAsyncEnumerable<T> : IAsyncEnumerable<T>
+        private class AnonymousAsyncEnumerable<T> : IAsyncEnumerable<T>
         {
-            Func<IAsyncEnumerator<T>> getEnumerator;
+            private Func<IAsyncEnumerator<T>> getEnumerator;
 
             public AnonymousAsyncEnumerable(Func<IAsyncEnumerator<T>> getEnumerator)
             {
@@ -31,16 +31,41 @@ public IAsyncEnumerator<T> GetEnumerator()
             }
         }
 
-        static IAsyncEnumerator<T> Create<T>(Func<CancellationToken, Task<bool>> moveNext, Func<T> current, Action dispose)
+        private static IAsyncEnumerator<T> Create<T>(Func<CancellationToken, Task<bool>> moveNext, Func<T> current,
+            Action dispose, IDisposable enumerator)
+        {
+            return Create(async ct =>
+            {
+                using (ct.Register(dispose))
+                {
+                    try
+                    {
+                        var result = await moveNext(ct).ConfigureAwait(false);
+                        if (!result)
+                        {
+                            enumerator?.Dispose();
+                        }
+                        return result;
+                    }
+                    catch
+                    {
+                        enumerator?.Dispose();
+                        throw;
+                    }
+                }
+            }, current, dispose);
+        }
+
+        private static IAsyncEnumerator<T> Create<T>(Func<CancellationToken, Task<bool>> moveNext, Func<T> current, Action dispose)
         {
             return new AnonymousAsyncEnumerator<T>(moveNext, current, dispose);
         }
 
-        static IAsyncEnumerator<T> Create<T>(Func<CancellationToken, TaskCompletionSource<bool>, Task<bool>> moveNext, Func<T> current, Action dispose)
+        private static IAsyncEnumerator<T> Create<T>(Func<CancellationToken, TaskCompletionSource<bool>, Task<bool>> moveNext, Func<T> current, Action dispose)
         {
             var self = default(IAsyncEnumerator<T>);
             self = new AnonymousAsyncEnumerator<T>(
-                ct =>
+                async ct =>
                 {
                     var tcs = new TaskCompletionSource<bool>();
 
@@ -50,10 +75,10 @@ static IAsyncEnumerator<T> Create<T>(Func<CancellationToken, TaskCompletionSourc
                         tcs.TrySetCanceled();
                     });
 
-                    var ctr = ct.Register(stop);
-
-                    var res = moveNext(ct, tcs).Finally(ctr.Dispose);
-                    return res;
+                    using (ct.Register(stop))
+                    {
+                        return await moveNext(ct, tcs);
+                    }
                 },
                 current,
                 dispose
@@ -61,7 +86,7 @@ static IAsyncEnumerator<T> Create<T>(Func<CancellationToken, TaskCompletionSourc
             return self;
         }
 
-        class AnonymousAsyncEnumerator<T> : IAsyncEnumerator<T>
+        private class AnonymousAsyncEnumerator<T> : IAsyncEnumerator<T>
         {
             private readonly Func<CancellationToken, Task<bool>> _moveNext;
             private readonly Func<T> _current;
@@ -109,7 +134,7 @@ public static IAsyncEnumerable<TValue> Return<TValue>(TValue value)
         public static IAsyncEnumerable<TValue> Throw<TValue>(Exception exception)
         {
             if (exception == null)
-                throw new ArgumentNullException("exception");
+                throw new ArgumentNullException(nameof(exception));
 
             return Create(() => Create<TValue>(
                 ct => TaskExt.Throw<bool>(exception),
@@ -139,7 +164,7 @@ public static IAsyncEnumerable<TValue> Empty<TValue>()
         public static IAsyncEnumerable<int> Range(int start, int count)
         {
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return Enumerable.Range(start, count).ToAsyncEnumerable();
         }
@@ -147,7 +172,7 @@ public static IAsyncEnumerable<int> Range(int start, int count)
         public static IAsyncEnumerable<TResult> Repeat<TResult>(TResult element, int count)
         {
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return Enumerable.Repeat(element, count).ToAsyncEnumerable();
         }
@@ -167,7 +192,7 @@ public static IAsyncEnumerable<TResult> Repeat<TResult>(TResult element)
         public static IAsyncEnumerable<TSource> Defer<TSource>(Func<IAsyncEnumerable<TSource>> factory)
         {
             if (factory == null)
-                throw new ArgumentNullException("factory");
+                throw new ArgumentNullException(nameof(factory));
 
             return Create(() => factory().GetEnumerator());
         }
@@ -175,11 +200,11 @@ public static IAsyncEnumerable<TSource> Defer<TSource>(Func<IAsyncEnumerable<TSo
         public static IAsyncEnumerable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector)
         {
             if (condition == null)
-                throw new ArgumentNullException("condition");
+                throw new ArgumentNullException(nameof(condition));
             if (iterate == null)
-                throw new ArgumentNullException("iterate");
+                throw new ArgumentNullException(nameof(iterate));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
             return Create(() =>
             {
@@ -223,9 +248,9 @@ public static IAsyncEnumerable<TResult> Generate<TState, TResult>(TState initial
         public static IAsyncEnumerable<TSource> Using<TSource, TResource>(Func<TResource> resourceFactory, Func<TResource, IAsyncEnumerable<TSource>> enumerableFactory) where TResource : IDisposable
         {
             if (resourceFactory == null)
-                throw new ArgumentNullException("resourceFactory");
+                throw new ArgumentNullException(nameof(resourceFactory));
             if (enumerableFactory == null)
-                throw new ArgumentNullException("enumerableFactory");
+                throw new ArgumentNullException(nameof(enumerableFactory));
 
             return Create(() =>
             {
@@ -248,36 +273,29 @@ public static IAsyncEnumerable<TSource> Using<TSource, TResource>(Func<TResource
                 var current = default(TSource);
 
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
-                        e.MoveNext(cts.Token).Then(t =>
+                        bool res;
+                        try
                         {
-                            t.Handle(tcs,
-                                res =>
-                                {
-                                    if (res)
-                                    {
-                                        current = e.Current;
-                                        tcs.TrySetResult(true);
-                                    }
-                                    else
-                                    {
-                                        d.Dispose();
-                                        tcs.TrySetResult(false);
-                                    }
-                                },
-                                ex =>
-                                {
-                                    d.Dispose();
-                                    tcs.TrySetException(ex);
-                                }
-                            );
-                        });
-
-                        return tcs.Task;
+                            res = await e.MoveNext(cts.Token).ConfigureAwait(false);
+                        }
+                        catch (Exception)
+                        {
+                            d.Dispose();
+                            throw;
+                        }
+                        if (res)
+                        {
+                            current = e.Current;
+                            return true;
+                        }
+                        d.Dispose();
+                        return false;
                     },
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    null
                 );
             });
         }
diff --git a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Exceptions.cs b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Exceptions.cs
index 8c344dca9d..f1abe9cc12 100644
--- a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Exceptions.cs
+++ b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Exceptions.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -15,9 +16,9 @@ public static IAsyncEnumerable<TSource> Catch<TSource, TException>(this IAsyncEn
             where TException : Exception
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (handler == null)
-                throw new ArgumentNullException("handler");
+                throw new ArgumentNullException(nameof(handler));
 
             return Create(() =>
             {
@@ -28,74 +29,32 @@ public static IAsyncEnumerable<TSource> Catch<TSource, TException>(this IAsyncEn
                 var d = Disposable.Create(cts, a);
                 var done = false;
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (!done)
                     {
-                        e.MoveNext(ct).Then(t =>
+                        try
                         {
-                            t.Handle(tcs,
-                                res =>
-                                {
-                                    tcs.TrySetResult(res);
-                                },
-                                ex =>
-                                {
-                                    var err = default(IAsyncEnumerator<TSource>);
-
-                                    try
-                                    {
-                                        ex.Flatten().Handle(ex_ =>
-                                        {
-                                            var exx = ex_ as TException;
-                                            if (exx != null)
-                                            {
-                                                err = handler(exx).GetEnumerator();
-                                                return true;
-                                            }
-
-                                            return false;
-                                        });
-                                    }
-                                    catch (Exception ex2)
-                                    {
-                                        tcs.TrySetException(ex2);
-                                        return;
-                                    }
-
-                                    if (err != null)
-                                    {
-                                        e = err;
-                                        a.Disposable = e;
-
-                                        done = true;
-                                        f(tcs, ct);
-                                    }
-                                }
-                            );
-                        });
-                    }
-                    else
-                    {
-                        e.MoveNext(ct).Then(t =>
+                            return await e.MoveNext(ct).ConfigureAwait(false);
+                        }
+                        catch (TException ex)
                         {
-                            t.Handle(tcs, res =>
-                            {
-                                tcs.TrySetResult(res);
-                            });
-                        });
+                            var err = handler(ex).GetEnumerator();
+                            e = err;
+                            a.Disposable = e;
+                            done = true;
+                            return await f(ct).ConfigureAwait(false);
+                        }
                     }
+                    return await e.MoveNext(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(a);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    a
                 );
             });
         }
@@ -103,7 +62,7 @@ public static IAsyncEnumerable<TSource> Catch<TSource, TException>(this IAsyncEn
         public static IAsyncEnumerable<TSource> Catch<TSource>(this IEnumerable<IAsyncEnumerable<TSource>> sources)
         {
             if (sources == null)
-                throw new ArgumentNullException("sources");
+                throw new ArgumentNullException(nameof(sources));
 
             return sources.Catch_();
         }
@@ -111,7 +70,7 @@ public static IAsyncEnumerable<TSource> Catch<TSource>(this IEnumerable<IAsyncEn
         public static IAsyncEnumerable<TSource> Catch<TSource>(params IAsyncEnumerable<TSource>[] sources)
         {
             if (sources == null)
-                throw new ArgumentNullException("sources");
+                throw new ArgumentNullException(nameof(sources));
 
             return sources.Catch_();
         }
@@ -119,9 +78,9 @@ public static IAsyncEnumerable<TSource> Catch<TSource>(params IAsyncEnumerable<T
         public static IAsyncEnumerable<TSource> Catch<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
 
             return new[] { first, second }.Catch_();
         }
@@ -137,36 +96,21 @@ private static IAsyncEnumerable<TSource> Catch_<TSource>(this IEnumerable<IAsync
                 var a = new AssignableDisposable();
                 var d = Disposable.Create(cts, se, a);
 
-                var error = default(Exception);
+                var error = default(ExceptionDispatchInfo);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (e == null)
                     {
-                        var b = false;
-                        try
+                        if (se.MoveNext())
                         {
-                            b = se.MoveNext();
-                            if (b)
-                                e = se.Current.GetEnumerator();
+                            e = se.Current.GetEnumerator();
                         }
-                        catch (Exception ex)
+                        else
                         {
-                            tcs.TrySetException(ex);
-                            return;
-                        }
-
-                        if (!b)
-                        {
-                            if (error != null)
-                            {
-                                tcs.TrySetException(error);
-                                return;
-                            }
-
-                            tcs.TrySetResult(false);
-                            return;
+                            error?.Throw();
+                            return false;
                         }
 
                         error = null;
@@ -174,33 +118,24 @@ private static IAsyncEnumerable<TSource> Catch_<TSource>(this IEnumerable<IAsync
                         a.Disposable = e;
                     }
 
-                    e.MoveNext(ct).Then(t =>
+                    try
+                    {
+                        return await e.MoveNext(ct).ConfigureAwait(false);
+                    }
+                    catch (Exception exception)
                     {
-                        t.Handle(tcs,
-                            res =>
-                            {
-                                tcs.TrySetResult(res);
-                            },
-                            ex =>
-                            {
-                                e.Dispose();
-                                e = null;
-
-                                error = ex;
-                                f(tcs, ct);
-                            }
-                        );
-                    });
+                        e.Dispose();
+                        e = null;
+                        error = ExceptionDispatchInfo.Capture(exception);
+                        return await f(ct).ConfigureAwait(false);
+                    }
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(a);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    a
                 );
             });
         }
@@ -208,9 +143,9 @@ private static IAsyncEnumerable<TSource> Catch_<TSource>(this IEnumerable<IAsync
         public static IAsyncEnumerable<TSource> Finally<TSource>(this IAsyncEnumerable<TSource> source, Action finallyAction)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (finallyAction == null)
-                throw new ArgumentNullException("finallyAction");
+                throw new ArgumentNullException(nameof(finallyAction));
 
             return Create(() =>
             {
@@ -220,26 +155,11 @@ public static IAsyncEnumerable<TSource> Finally<TSource>(this IAsyncEnumerable<T
                 var r = new Disposable(finallyAction);
                 var d = Disposable.Create(cts, e, r);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
-                {
-                    e.MoveNext(ct).Then(t =>
-                    {
-                        t.Handle(tcs, res =>
-                        {
-                            tcs.TrySetResult(res);
-                        });
-                    });
-                };
-
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(r);
-                    },
+                    ct => e.MoveNext(ct),
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    r
                 );
             });
         }
@@ -247,9 +167,9 @@ public static IAsyncEnumerable<TSource> Finally<TSource>(this IAsyncEnumerable<T
         public static IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
 
             return OnErrorResumeNext_(new[] { first, second });
         }
@@ -257,7 +177,7 @@ public static IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(this IAsyncEn
         public static IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(params IAsyncEnumerable<TSource>[] sources)
         {
             if (sources == null)
-                throw new ArgumentNullException("sources");
+                throw new ArgumentNullException(nameof(sources));
 
             return OnErrorResumeNext_(sources);
         }
@@ -265,7 +185,7 @@ public static IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(params IAsync
         public static IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(this IEnumerable<IAsyncEnumerable<TSource>> sources)
         {
             if (sources == null)
-                throw new ArgumentNullException("sources");
+                throw new ArgumentNullException(nameof(sources));
 
             return OnErrorResumeNext_(sources);
         }
@@ -281,69 +201,45 @@ private static IAsyncEnumerable<TSource> OnErrorResumeNext_<TSource>(IEnumerable
                 var a = new AssignableDisposable();
                 var d = Disposable.Create(cts, se, a);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (e == null)
                     {
                         var b = false;
-                        try
+                        b = se.MoveNext();
+                        if (b)
+                            e = se.Current.GetEnumerator();
+                        else
                         {
-                            b = se.MoveNext();
-                            if (b)
-                                e = se.Current.GetEnumerator();
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                            return;
-                        }
-
-                        if (!b)
-                        {
-                            tcs.TrySetResult(false);
-                            return;
+                            return false;
                         }
 
                         a.Disposable = e;
                     }
 
-                    e.MoveNext(ct).Then(t =>
+                    try
+                    {
+                        if (await e.MoveNext(ct).ConfigureAwait(false))
+                        {
+                            return true;
+                        }
+                    }
+                    catch
                     {
-                        t.Handle(tcs,
-                            res =>
-                            {
-                                if (res)
-                                {
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    e.Dispose();
-                                    e = null;
-
-                                    f(tcs, ct);
-                                }
-                            },
-                            ex =>
-                            {
-                                e.Dispose();
-                                e = null;
-
-                                f(tcs, ct);
-                            }
-                        );
-                    });
+                        // ignore
+                    }
+
+                    e.Dispose();
+                    e = null;
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(a);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    a
                 );
             });
         }
@@ -351,7 +247,7 @@ private static IAsyncEnumerable<TSource> OnErrorResumeNext_<TSource>(IEnumerable
         public static IAsyncEnumerable<TSource> Retry<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return new[] { source }.Repeat().Catch();
         }
@@ -359,9 +255,9 @@ public static IAsyncEnumerable<TSource> Retry<TSource>(this IAsyncEnumerable<TSo
         public static IAsyncEnumerable<TSource> Retry<TSource>(this IAsyncEnumerable<TSource> source, int retryCount)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (retryCount < 0)
-                throw new ArgumentOutOfRangeException("retryCount");
+                throw new ArgumentOutOfRangeException(nameof(retryCount));
 
             return new[] { source }.Repeat(retryCount).Catch();
         }
diff --git a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Multiple.cs b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Multiple.cs
index c0549e4041..2f58588e8e 100644
--- a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Multiple.cs
+++ b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Multiple.cs
@@ -14,9 +14,9 @@ public static partial class AsyncEnumerable
         public static IAsyncEnumerable<TSource> Concat<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
 
             return Create(() =>
             {
@@ -27,42 +27,30 @@ public static IAsyncEnumerable<TSource> Concat<TSource>(this IAsyncEnumerable<TS
                 var a = new AssignableDisposable { Disposable = e };
                 var d = Disposable.Create(cts, a);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) => e.MoveNext(ct).Then(t =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    t.Handle(tcs, res =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        if (res)
-                        {
-                            tcs.TrySetResult(true);
-                        }
-                        else
-                        {
-                            if (switched)
-                            {
-                                tcs.TrySetResult(false);
-                            }
-                            else
-                            {
-                                switched = true;
+                        return true;
+                    }
+                    if (switched)
+                    {
+                        return false;
+                    }
+                    switched = true;
 
-                                e = second.GetEnumerator();
-                                a.Disposable = e;
+                    e = second.GetEnumerator();
+                    a.Disposable = e;
 
-                                f(tcs, ct);
-                            }
-                        }
-                    });
-                });
+                    return await f(ct).ConfigureAwait(false);
+                };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(a);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -70,11 +58,11 @@ public static IAsyncEnumerable<TSource> Concat<TSource>(this IAsyncEnumerable<TS
         public static IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> selector)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return Create(() =>
             {
@@ -86,21 +74,13 @@ public static IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IAsyn
                 var d = Disposable.Create(cts, e1, e2);
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        e1.MoveNext(cts.Token).Zip(e2.MoveNext(cts.Token), (f, s) =>
+                    ct => e1.MoveNext(cts.Token).Zip(e2.MoveNext(cts.Token), (f, s) =>
                         {
                             var result = f && s;
                             if (result)
                                 current = selector(e1.Current, e2.Current);
                             return result;
-                        }).Then(t =>
-                        {
-                            t.Handle(tcs, x => tcs.TrySetResult(x));
-                        });
-
-                        return tcs.Task.UsingEnumerator(e1).UsingEnumerator(e2);
-                    },
+                        }),
                     () => current,
                     d.Dispose
                 );
@@ -110,11 +90,11 @@ public static IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IAsyn
         public static IAsyncEnumerable<TSource> Except<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return Create(() =>
             {
@@ -125,40 +105,25 @@ public static IAsyncEnumerable<TSource> Except<TSource>(this IAsyncEnumerable<TS
 
                 var mapTask = default(Task<Dictionary<TSource, TSource>>);
                 var getMapTask = new Func<CancellationToken, Task<Dictionary<TSource, TSource>>>(ct =>
-                {
-                    if (mapTask == null)
-                        mapTask = second.ToDictionary(x => x, comparer, ct);
-                    return mapTask;
-                });
+                    mapTask ?? (mapTask = second.ToDictionary(x => x, comparer, ct)));
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).Then(t =>
+                    if (await e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                if (!mapTask.Result.ContainsKey(e.Current))
-                                    tcs.TrySetResult(true);
-                                else
-                                    f(tcs, ct);
-                            }
-                            else
-                                tcs.TrySetResult(false);
-                        });
-                    });
+                        if (!mapTask.Result.ContainsKey(e.Current))
+                            return true;
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -166,9 +131,9 @@ public static IAsyncEnumerable<TSource> Except<TSource>(this IAsyncEnumerable<TS
         public static IAsyncEnumerable<TSource> Except<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
 
             return first.Except(second, EqualityComparer<TSource>.Default);
         }
@@ -176,11 +141,11 @@ public static IAsyncEnumerable<TSource> Except<TSource>(this IAsyncEnumerable<TS
         public static IAsyncEnumerable<TSource> Intersect<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return Create(() =>
             {
@@ -197,34 +162,23 @@ public static IAsyncEnumerable<TSource> Intersect<TSource>(this IAsyncEnumerable
                     return mapTask;
                 });
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).Then(t =>
+                    if (await e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                if (mapTask.Result.ContainsKey(e.Current))
-                                    tcs.TrySetResult(true);
-                                else
-                                    f(tcs, ct);
-                            }
-                            else
-                                tcs.TrySetResult(false);
-                        });
-                    });
+                        if (mapTask.Result.ContainsKey(e.Current))
+                            return true;
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -232,9 +186,9 @@ public static IAsyncEnumerable<TSource> Intersect<TSource>(this IAsyncEnumerable
         public static IAsyncEnumerable<TSource> Intersect<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
 
             return first.Intersect(second, EqualityComparer<TSource>.Default);
         }
@@ -242,11 +196,11 @@ public static IAsyncEnumerable<TSource> Intersect<TSource>(this IAsyncEnumerable
         public static IAsyncEnumerable<TSource> Union<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return first.Concat(second).Distinct(comparer);
         }
@@ -254,9 +208,9 @@ public static IAsyncEnumerable<TSource> Union<TSource>(this IAsyncEnumerable<TSo
         public static IAsyncEnumerable<TSource> Union<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
 
             return first.Union(second, EqualityComparer<TSource>.Default);
         }
@@ -264,79 +218,39 @@ public static IAsyncEnumerable<TSource> Union<TSource>(this IAsyncEnumerable<TSo
         public static Task<bool> SequenceEqual<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
-            var tcs = new TaskCompletionSource<bool>();
-
-            var e1 = first.GetEnumerator();
-            var e2 = second.GetEnumerator();
+            return SequenceEqual_(first, second, comparer, cancellationToken);
+        }
 
-            var run = default(Action<CancellationToken>);
-            run = ct =>
+        private static async Task<bool> SequenceEqual_<TSource>(IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer,
+            CancellationToken cancellationToken)
+        {
+            using (var e1 = first.GetEnumerator())
+            using (var e2 = second.GetEnumerator())
             {
-                e1.MoveNext(ct).Zip(e2.MoveNext(ct), (f, s) =>
+                while (await e1.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    if (f ^ s)
-                    {
-                        tcs.TrySetResult(false);
-                        return false;
-                    }
-
-                    if (f && s)
-                    {
-                        var eq = default(bool);
-                        try
-                        {
-                            eq = comparer.Equals(e1.Current, e2.Current);
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                            return false;
-                        }
-
-                        if (!eq)
-                        {
-                            tcs.TrySetResult(false);
-                            return false;
-                        }
-                        else
-                            return true;
-                    }
-                    else
+                    if (!(await e2.MoveNext(cancellationToken).ConfigureAwait(false) && comparer.Equals(e1.Current, e2.Current)))
                     {
-                        tcs.TrySetResult(true);
                         return false;
                     }
-                }).Then(t =>
-                {
-                    t.Handle(tcs, res =>
-                    {
-                        if (res)
-                            run(ct);
-                    });
-                });
-            };
-
-            run(cancellationToken);
+                }
 
-            return tcs.Task.Finally(() =>
-            {
-                e1.Dispose();
-                e2.Dispose();
-            });
+                return !await e2.MoveNext(cancellationToken).ConfigureAwait(false);
+            }
         }
 
         public static Task<bool> SequenceEqual<TSource>(this IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, CancellationToken cancellationToken)
         {
             if (first == null)
-                throw new ArgumentNullException("first");
+                throw new ArgumentNullException(nameof(first));
             if (second == null)
-                throw new ArgumentNullException("second");
+                throw new ArgumentNullException(nameof(second));
 
             return first.SequenceEqual(second, EqualityComparer<TSource>.Default, cancellationToken);
         }
@@ -344,131 +258,181 @@ public static Task<bool> SequenceEqual<TSource>(this IAsyncEnumerable<TSource> f
         public static IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (outer == null)
-                throw new ArgumentNullException("outer");
+                throw new ArgumentNullException(nameof(outer));
             if (inner == null)
-                throw new ArgumentNullException("inner");
+                throw new ArgumentNullException(nameof(inner));
             if (outerKeySelector == null)
-                throw new ArgumentNullException("outerKeySelector");
+                throw new ArgumentNullException(nameof(outerKeySelector));
             if (innerKeySelector == null)
-                throw new ArgumentNullException("innerKeySelector");
+                throw new ArgumentNullException(nameof(innerKeySelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
-
-            return Create(() =>
-            {
-                var innerMap = default(Task<ILookup<TKey, TInner>>);
-                var getInnerMap = new Func<CancellationToken, Task<ILookup<TKey, TInner>>>(ct =>
-                {
-                    if (innerMap == null)
-                        innerMap = inner.ToLookup(innerKeySelector, comparer, ct);
-
-                    return innerMap;
-                });
-
-                var outerE = outer.GetEnumerator();
-                var current = default(TResult);
-
-                var cts = new CancellationTokenDisposable();
-                var d = Disposable.Create(cts, outerE);
+                throw new ArgumentNullException(nameof(comparer));
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
-                {
-                    getInnerMap(ct).Then(ti =>
-                    {
-                        ti.Handle(tcs, map =>
-                        {
-                            outerE.MoveNext(ct).Then(to =>
-                            {
-                                to.Handle(tcs, res =>
-                                {
-                                    if (res)
-                                    {
-                                        var element = outerE.Current;
-                                        var key = default(TKey);
-
-                                        try
-                                        {
-                                            key = outerKeySelector(element);
-                                        }
-                                        catch (Exception ex)
-                                        {
-                                            tcs.TrySetException(ex);
-                                            return;
-                                        }
-
-                                        var innerE = default(IAsyncEnumerable<TInner>);
-                                        if (!map.Contains(key))
-                                            innerE = AsyncEnumerable.Empty<TInner>();
-                                        else
-                                            innerE = map[key].ToAsyncEnumerable();
-
-                                        try
-                                        {
-                                            current = resultSelector(element, innerE);
-                                        }
-                                        catch (Exception ex)
-                                        {
-                                            tcs.TrySetException(ex);
-                                            return;
-                                        }
-
-                                        tcs.TrySetResult(true);
-                                    }
-                                    else
-                                    {
-                                        tcs.TrySetResult(false);
-                                    }
-                                });
-                            });
-                        });
-                    });
-                };
 
-                return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(outerE);
-                    },
-                    () => current,
-                    d.Dispose
-                );
-            });
+            return new GroupJoinAsyncEnumerable<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
         }
 
         public static IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, TResult> resultSelector)
         {
             if (outer == null)
-                throw new ArgumentNullException("outer");
+                throw new ArgumentNullException(nameof(outer));
             if (inner == null)
-                throw new ArgumentNullException("inner");
+                throw new ArgumentNullException(nameof(inner));
             if (outerKeySelector == null)
-                throw new ArgumentNullException("outerKeySelector");
+                throw new ArgumentNullException(nameof(outerKeySelector));
             if (innerKeySelector == null)
-                throw new ArgumentNullException("innerKeySelector");
+                throw new ArgumentNullException(nameof(innerKeySelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
             return outer.GroupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
         }
 
+
+        private sealed class GroupJoinAsyncEnumerable<TOuter, TInner, TKey, TResult> : IAsyncEnumerable<TResult>
+        {
+            private readonly IAsyncEnumerable<TOuter> _outer;
+            private readonly IAsyncEnumerable<TInner> _inner;
+            private readonly Func<TOuter, TKey> _outerKeySelector;
+            private readonly Func<TInner, TKey> _innerKeySelector;
+            private readonly Func<TOuter, IAsyncEnumerable<TInner>, TResult> _resultSelector;
+            private readonly IEqualityComparer<TKey> _comparer;
+
+            public GroupJoinAsyncEnumerable(
+                IAsyncEnumerable<TOuter> outer,
+                IAsyncEnumerable<TInner> inner,
+                Func<TOuter, TKey> outerKeySelector,
+                Func<TInner, TKey> innerKeySelector,
+                Func<TOuter, IAsyncEnumerable<TInner>, TResult> resultSelector,
+                IEqualityComparer<TKey> comparer)
+            {
+                _outer = outer;
+                _inner = inner;
+                _outerKeySelector = outerKeySelector;
+                _innerKeySelector = innerKeySelector;
+                _resultSelector = resultSelector;
+                _comparer = comparer;
+            }
+
+            public IAsyncEnumerator<TResult> GetEnumerator()
+                => new GroupJoinAsyncEnumerator(
+                    _outer.GetEnumerator(),
+                    _inner,
+                    _outerKeySelector,
+                    _innerKeySelector,
+                    _resultSelector,
+                    _comparer);
+
+            private sealed class GroupJoinAsyncEnumerator : IAsyncEnumerator<TResult>
+            {
+                private readonly IAsyncEnumerator<TOuter> _outer;
+                private readonly IAsyncEnumerable<TInner> _inner;
+                private readonly Func<TOuter, TKey> _outerKeySelector;
+                private readonly Func<TInner, TKey> _innerKeySelector;
+                private readonly Func<TOuter, IAsyncEnumerable<TInner>, TResult> _resultSelector;
+                private readonly IEqualityComparer<TKey> _comparer;
+
+                private Internal.Lookup<TKey, TInner> _lookup;
+
+                public GroupJoinAsyncEnumerator(
+                    IAsyncEnumerator<TOuter> outer,
+                    IAsyncEnumerable<TInner> inner,
+                    Func<TOuter, TKey> outerKeySelector,
+                    Func<TInner, TKey> innerKeySelector,
+                    Func<TOuter, IAsyncEnumerable<TInner>, TResult> resultSelector,
+                    IEqualityComparer<TKey> comparer)
+                {
+                    _outer = outer;
+                    _inner = inner;
+                    _outerKeySelector = outerKeySelector;
+                    _innerKeySelector = innerKeySelector;
+                    _resultSelector = resultSelector;
+                    _comparer = comparer;
+                }
+
+                public async Task<bool> MoveNext(CancellationToken cancellationToken)
+                {
+                    // nothing to do 
+                    if (!await _outer.MoveNext(cancellationToken).ConfigureAwait(false))
+                    {
+                        return false;
+                    }
+
+                    if (_lookup == null)
+                    {
+                        _lookup = await Internal.Lookup<TKey, TInner>.CreateForJoinAsync(_inner, _innerKeySelector, _comparer, cancellationToken).ConfigureAwait(false);
+                    }
+                    
+                    var item = _outer.Current;
+                    Current = _resultSelector(item, new AsyncEnumerableAdapter<TInner>(_lookup[_outerKeySelector(item)]));
+                    return true;
+                }
+
+                public TResult Current { get; private set; }
+
+                public void Dispose()
+                {
+                    _outer.Dispose();
+                }
+
+      
+            }
+        }
+
+        private sealed class AsyncEnumerableAdapter<T> : IAsyncEnumerable<T>
+        {
+            private readonly IEnumerable<T> _source;
+
+            public AsyncEnumerableAdapter(IEnumerable<T> source)
+            {
+                _source = source;
+            }
+
+            public IAsyncEnumerator<T> GetEnumerator()
+                => new AsyncEnumeratorAdapter(_source.GetEnumerator());
+
+            private sealed class AsyncEnumeratorAdapter : IAsyncEnumerator<T>
+            {
+                private readonly IEnumerator<T> _enumerator;
+
+                public AsyncEnumeratorAdapter(IEnumerator<T> enumerator)
+                {
+                    _enumerator = enumerator;
+                }
+
+                public Task<bool> MoveNext(CancellationToken cancellationToken)
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+
+#if HAS_AWAIT
+                    return Task.FromResult(_enumerator.MoveNext());
+#else
+                    return TaskEx.FromResult(_enumerator.MoveNext());
+#endif
+                }
+
+                public T Current => _enumerator.Current;
+
+                public void Dispose() => _enumerator.Dispose();
+            }
+        }
+
         public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (outer == null)
-                throw new ArgumentNullException("outer");
+                throw new ArgumentNullException(nameof(outer));
             if (inner == null)
-                throw new ArgumentNullException("inner");
+                throw new ArgumentNullException(nameof(inner));
             if (outerKeySelector == null)
-                throw new ArgumentNullException("outerKeySelector");
+                throw new ArgumentNullException(nameof(outerKeySelector));
             if (innerKeySelector == null)
-                throw new ArgumentNullException("innerKeySelector");
+                throw new ArgumentNullException(nameof(innerKeySelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return Create(() =>
             {
@@ -484,25 +448,21 @@ public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this
                 var innerMap = new Dictionary<TKey, List<TInner>>(comparer);
                 var q = new Queue<TResult>();
 
-                var gate = new object();
-
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (q.Count > 0)
                     {
                         current = q.Dequeue();
-                        tcs.TrySetResult(true);
-                        return;
+                        return true;
                     }
 
                     var b = useOuter;
                     if (ie == null && oe == null)
                     {
-                        tcs.TrySetResult(false);
-                        return;
+                        return false;
                     }
-                    else if (ie == null)
+                    if (ie == null)
                         b = true;
                     else if (oe == null)
                         b = false;
@@ -510,135 +470,87 @@ public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this
 
                     var enqueue = new Func<TOuter, TInner, bool>((o, i) =>
                     {
-                        var result = default(TResult);
-                        try
-                        {
-                            result = resultSelector(o, i);
-                        }
-                        catch (Exception exception)
-                        {
-                            tcs.TrySetException(exception);
-                            return false;
-                        }
-
+                        var result = resultSelector(o, i);
                         q.Enqueue(result);
                         return true;
                     });
 
                     if (b)
-                        oe.MoveNext(ct).Then(t =>
+                    {
+                        if (await oe.MoveNext(ct).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
+                            var element = oe.Current;
+                            var key = default(TKey);
+
+                            key = outerKeySelector(element);
+
+                            var outerList = default(List<TOuter>);
+                            if (!outerMap.TryGetValue(key, out outerList))
                             {
-                                if (res)
-                                {
-                                    var element = oe.Current;
-                                    var key = default(TKey);
-
-                                    try
-                                    {
-                                        key = outerKeySelector(element);
-                                    }
-                                    catch (Exception exception)
-                                    {
-                                        tcs.TrySetException(exception);
-                                        return;
-                                    }
-
-                                    var outerList = default(List<TOuter>);
-                                    if (!outerMap.TryGetValue(key, out outerList))
-                                    {
-                                        outerList = new List<TOuter>();
-                                        outerMap.Add(key, outerList);
-                                    }
-
-                                    outerList.Add(element);
-
-                                    var innerList = default(List<TInner>);
-                                    if (!innerMap.TryGetValue(key, out innerList))
-                                    {
-                                        innerList = new List<TInner>();
-                                        innerMap.Add(key, innerList);
-                                    }
-
-                                    foreach (var v in innerList)
-                                    {
-                                        if (!enqueue(element, v))
-                                            return;
-                                    }
-                                    
-                                    f(tcs, ct);
-                                }
-                                else
-                                {
-                                    oe.Dispose();
-                                    oe = null;
-                                    f(tcs, ct);
-                                }
-                            });
-                        });
-                    else
-                        ie.MoveNext(ct).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
+                                outerList = new List<TOuter>();
+                                outerMap.Add(key, outerList);
+                            }
+
+                            outerList.Add(element);
+
+                            var innerList = default(List<TInner>);
+                            if (!innerMap.TryGetValue(key, out innerList))
                             {
-                                if (res)
-                                {
-                                    var element = ie.Current;
-                                    var key = default(TKey);
-
-                                    try
-                                    {
-                                        key = innerKeySelector(element);
-                                    }
-                                    catch (Exception exception)
-                                    {
-                                        tcs.TrySetException(exception);
-                                        return;
-                                    }
-
-                                    var innerList = default(List<TInner>);
-                                    if (!innerMap.TryGetValue(key, out innerList))
-                                    {
-                                        innerList = new List<TInner>();
-                                        innerMap.Add(key, innerList);
-                                    }
-
-                                    innerList.Add(element);
-
-                                    var outerList = default(List<TOuter>);
-                                    if (!outerMap.TryGetValue(key, out outerList))
-                                    {
-                                        outerList = new List<TOuter>();
-                                        outerMap.Add(key, outerList);
-                                    }
-
-                                    foreach (var v in outerList)
-                                    {
-                                        if (!enqueue(v, element))
-                                            return;
-                                    }
-
-                                    f(tcs, ct);
-                                }
-                                else
-                                {
-                                    ie.Dispose();
-                                    ie = null;
-                                    f(tcs, ct);
-                                }
-                            });
-                        });
+                                innerList = new List<TInner>();
+                                innerMap.Add(key, innerList);
+                            }
+
+                            foreach (var v in innerList)
+                            {
+                                if (!enqueue(element, v))
+                                    return false;
+                            }
+
+                            return await f(ct).ConfigureAwait(false);
+                        }
+                        oe.Dispose();
+                        oe = null;
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    if (await ie.MoveNext(ct).ConfigureAwait(false))
+                    {
+                        var element = ie.Current;
+                        var key = innerKeySelector(element);
+
+                        var innerList = default(List<TInner>);
+                        if (!innerMap.TryGetValue(key, out innerList))
+                        {
+                            innerList = new List<TInner>();
+                            innerMap.Add(key, innerList);
+                        }
+
+                        innerList.Add(element);
+
+                        var outerList = default(List<TOuter>);
+                        if (!outerMap.TryGetValue(key, out outerList))
+                        {
+                            outerList = new List<TOuter>();
+                            outerMap.Add(key, outerList);
+                        }
+
+                        foreach (var v in outerList)
+                        {
+                            if (!enqueue(v, element))
+                                return false;
+                        }
+
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    ie.Dispose();
+                    ie = null;
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(oe).UsingEnumerator(ie);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    ie
                 );
             });
         }
@@ -646,15 +558,15 @@ public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this
         public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
         {
             if (outer == null)
-                throw new ArgumentNullException("outer");
+                throw new ArgumentNullException(nameof(outer));
             if (inner == null)
-                throw new ArgumentNullException("inner");
+                throw new ArgumentNullException(nameof(inner));
             if (outerKeySelector == null)
-                throw new ArgumentNullException("outerKeySelector");
+                throw new ArgumentNullException(nameof(outerKeySelector));
             if (innerKeySelector == null)
-                throw new ArgumentNullException("innerKeySelector");
+                throw new ArgumentNullException(nameof(innerKeySelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
             return outer.Join(inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
         }
@@ -662,7 +574,7 @@ public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this
         public static IAsyncEnumerable<TSource> Concat<TSource>(this IEnumerable<IAsyncEnumerable<TSource>> sources)
         {
             if (sources == null)
-                throw new ArgumentNullException("sources");
+                throw new ArgumentNullException(nameof(sources));
 
             return sources.Concat_();
         }
@@ -670,7 +582,7 @@ public static IAsyncEnumerable<TSource> Concat<TSource>(this IEnumerable<IAsyncE
         public static IAsyncEnumerable<TSource> Concat<TSource>(params IAsyncEnumerable<TSource>[] sources)
         {
             if (sources == null)
-                throw new ArgumentNullException("sources");
+                throw new ArgumentNullException(nameof(sources));
 
             return sources.Concat_();
         }
@@ -686,60 +598,39 @@ private static IAsyncEnumerable<TSource> Concat_<TSource>(this IEnumerable<IAsyn
                 var a = new AssignableDisposable();
                 var d = Disposable.Create(cts, se, a);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (e == null)
                     {
                         var b = false;
-                        try
-                        {
-                            b = se.MoveNext();
-                            if (b)
-                                e = se.Current.GetEnumerator();
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                            return;
-                        }
+                        b = se.MoveNext();
+                        if (b)
+                            e = se.Current.GetEnumerator();
 
                         if (!b)
                         {
-                            tcs.TrySetResult(false);
-                            return;
+                            return false;
                         }
 
                         a.Disposable = e;
                     }
 
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                tcs.TrySetResult(true);
-                            }
-                            else
-                            {
-                                e.Dispose();
-                                e = null;
+                        return true;
+                    }
+                    e.Dispose();
+                    e = null;
 
-                                f(tcs, ct);
-                            }
-                        });
-                    });
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(a);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    a
                 );
             });
         }
@@ -747,9 +638,9 @@ private static IAsyncEnumerable<TSource> Concat_<TSource>(this IEnumerable<IAsyn
         public static IAsyncEnumerable<TOther> SelectMany<TSource, TOther>(this IAsyncEnumerable<TSource> source, IAsyncEnumerable<TOther> other)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (other == null)
-                throw new ArgumentNullException("other");
+                throw new ArgumentNullException(nameof(other));
 
             return source.SelectMany(_ => other);
         }
diff --git a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Single.cs b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Single.cs
index c23c22b7fc..4fdcc08d28 100644
--- a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Single.cs
+++ b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerable.Single.cs
@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information. 
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -14,9 +14,9 @@ public static partial class AsyncEnumerable
         public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return Create(() =>
             {
@@ -27,37 +27,18 @@ public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnum
                 var d = Disposable.Create(cts, e);
 
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
-                        e.MoveNext(cts.Token).Then(t =>
+                        if (await e.MoveNext(cts.Token).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    try
-                                    {
-                                        current = selector(e.Current);
-                                    }
-                                    catch (Exception ex)
-                                    {
-                                        tcs.TrySetException(ex);
-                                        return;
-                                    }
-
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    tcs.TrySetResult(false);
-                                }
-                            });
-                        });
-
-                        return tcs.Task.UsingEnumerator(e);
+                            current = selector(e.Current);
+                            return true;
+                        }
+                        return false;
                     },
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -65,9 +46,9 @@ public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnum
         public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return Create(() =>
             {
@@ -79,37 +60,18 @@ public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnum
                 var d = Disposable.Create(cts, e);
 
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
-                        e.MoveNext(cts.Token).Then(t =>
+                        if (await e.MoveNext(cts.Token).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    try
-                                    {
-                                        current = selector(e.Current, checked(index++));
-                                    }
-                                    catch (Exception ex)
-                                    {
-                                        tcs.TrySetException(ex);
-                                        return;
-                                    }
-
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    tcs.TrySetResult(false);
-                                }
-                            });
-                        });
-
-                        return tcs.Task.UsingEnumerator(e);
+                            current = selector(e.Current, checked(index++));
+                            return true;
+                        }
+                        return false;
                     },
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -117,7 +79,7 @@ public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnum
         public static IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Select(x => x);
         }
@@ -125,9 +87,9 @@ public static IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this IAsyncEn
         public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return Create(() =>
             {
@@ -136,45 +98,23 @@ public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSo
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, e);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                var b = false;
-                                try
-                                {
-                                    b = predicate(e.Current);
-                                }
-                                catch (Exception ex)
-                                {
-                                    tcs.TrySetException(ex);
-                                    return;
-                                }
-
-                                if (b)
-                                    tcs.TrySetResult(true);
-                                else
-                                    f(tcs, ct);
-                            }
-                            else
-                                tcs.TrySetResult(false);
-                        });
-                    });
+                        if (predicate(e.Current))
+                            return true;
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    ct => f(cts.Token),
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -182,9 +122,9 @@ public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSo
         public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return Create(() =>
             {
@@ -194,45 +134,23 @@ public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSo
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, e);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                var b = false;
-                                try
-                                {
-                                    b = predicate(e.Current, checked(index++));
-                                }
-                                catch (Exception ex)
-                                {
-                                    tcs.TrySetException(ex);
-                                    return;
-                                }
-
-                                if (b)
-                                    tcs.TrySetResult(true);
-                                else
-                                    f(tcs, ct);
-                            }
-                            else
-                                tcs.TrySetResult(false);
-                        });
-                    });
+                        if (predicate(e.Current, checked(index++)))
+                            return true;
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    ct => f(cts.Token),
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -240,9 +158,9 @@ public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSo
         public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, IAsyncEnumerable<TResult>> selector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return Create(() =>
             {
@@ -254,66 +172,36 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsync
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, innerDisposable, e);
 
-                var outer = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                var inner = default(Action<TaskCompletionSource<bool>, CancellationToken>);
+                var inner = default(Func<CancellationToken, Task<bool>>);
+                var outer = default(Func<CancellationToken, Task<bool>>);
 
-                inner = (tcs, ct) =>
+                inner = async ct =>
                 {
-                    ie.MoveNext(ct).Then(t =>
+                    if (await ie.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                tcs.TrySetResult(true);
-                            }
-                            else
-                            {
-                                innerDisposable.Disposable = null;
-                                outer(tcs, ct);
-                            }
-                        });
-                    });
+                        return true;
+                    }
+                    innerDisposable.Disposable = null;
+                    return await outer(ct).ConfigureAwait(false);
                 };
 
-                outer = (tcs, ct) =>
+                outer = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                try
-                                {
-                                    ie = selector(e.Current).GetEnumerator();
-                                    innerDisposable.Disposable = ie;
-
-                                    inner(tcs, ct);
-                                }
-                                catch (Exception ex)
-                                {
-                                    tcs.TrySetException(ex);
-                                }
-                            }
-                            else
-                                tcs.TrySetResult(false);
-                        });
-                    });
-                };
+                        var enumerable = selector(e.Current);
+                        ie = enumerable.GetEnumerator();
+                        innerDisposable.Disposable = ie;
 
-                return Create(
-                    (ct, tcs) =>
-                    {
-                        if (ie == null)
-                            outer(tcs, cts.Token);
-                        else
-                            inner(tcs, cts.Token);
+                        return await inner(ct).ConfigureAwait(false);
+                    }
+                    return false;
+                };
 
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                return Create(ct => ie == null ? outer(cts.Token) : inner(cts.Token),
                     () => ie.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -321,9 +209,9 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsync
         public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, IAsyncEnumerable<TResult>> selector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return Create(() =>
             {
@@ -337,66 +225,36 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsync
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, innerDisposable, e);
 
-                var outer = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                var inner = default(Action<TaskCompletionSource<bool>, CancellationToken>);
+                var inner = default(Func<CancellationToken, Task<bool>>);
+                var outer = default(Func<CancellationToken, Task<bool>>);
 
-                inner = (tcs, ct) =>
+                inner = async ct =>
                 {
-                    ie.MoveNext(ct).Then(t =>
+                    if (await ie.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                tcs.TrySetResult(true);
-                            }
-                            else
-                            {
-                                innerDisposable.Disposable = null;
-                                outer(tcs, ct);
-                            }
-                        });
-                    });
+                        return true;
+                    }
+                    innerDisposable.Disposable = null;
+                    return await outer(ct).ConfigureAwait(false);
                 };
 
-                outer = (tcs, ct) =>
+                outer = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                try
-                                {
-                                    ie = selector(e.Current, checked(index++)).GetEnumerator();
-                                    innerDisposable.Disposable = ie;
-
-                                    inner(tcs, ct);
-                                }
-                                catch (Exception ex)
-                                {
-                                    tcs.TrySetException(ex);
-                                }
-                            }
-                            else
-                                tcs.TrySetResult(false);
-                        });
-                    });
-                };
+                        var enumerable = selector(e.Current, checked(index++));
+                        ie = enumerable.GetEnumerator();
+                        innerDisposable.Disposable = ie;
 
-                return Create(
-                    (ct, tcs) =>
-                    {
-                        if (ie == null)
-                            outer(tcs, cts.Token);
-                        else
-                            inner(tcs, cts.Token);
+                        return await inner(ct).ConfigureAwait(false);
+                    }
+                    return false;
+                };
 
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                return Create(ct => ie == null ? outer(cts.Token) : inner(cts.Token),
                     () => ie.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -404,11 +262,11 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsync
         public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, IAsyncEnumerable<TCollection>> selector, Func<TSource, TCollection, TResult> resultSelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
             return source.SelectMany(x => selector(x).Select(y => resultSelector(x, y)));
         }
@@ -416,11 +274,11 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult
         public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, IAsyncEnumerable<TCollection>> selector, Func<TSource, TCollection, TResult> resultSelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
             return source.SelectMany((x, i) => selector(x, i).Select(y => resultSelector(x, y)));
         }
@@ -428,7 +286,7 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult
         public static IAsyncEnumerable<TType> OfType<TType>(this IAsyncEnumerable<object> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Where(x => x is TType).Cast<TType>();
         }
@@ -436,7 +294,7 @@ public static IAsyncEnumerable<TType> OfType<TType>(this IAsyncEnumerable<object
         public static IAsyncEnumerable<TResult> Cast<TResult>(this IAsyncEnumerable<object> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Select(x => (TResult)x);
         }
@@ -444,9 +302,9 @@ public static IAsyncEnumerable<TResult> Cast<TResult>(this IAsyncEnumerable<obje
         public static IAsyncEnumerable<TSource> Take<TSource>(this IAsyncEnumerable<TSource> source, int count)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return Create(() =>
             {
@@ -457,28 +315,23 @@ public static IAsyncEnumerable<TSource> Take<TSource>(this IAsyncEnumerable<TSou
                 var d = Disposable.Create(cts, e);
 
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
                         if (n == 0)
-                            return TaskExt.False;
+                            return false;
 
-                        e.MoveNext(cts.Token).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
-                            {
-                                --n;
+                        var result = await e.MoveNext(cts.Token).ConfigureAwait(false);
 
-                                if (n == 0)
-                                    e.Dispose();
+                        --n;
 
-                                tcs.TrySetResult(res);
-                            });
-                        });
+                        if (n == 0)
+                            e.Dispose();
 
-                        return tcs.Task.UsingEnumerator(e);
+                        return result;
                     },
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -486,9 +339,9 @@ public static IAsyncEnumerable<TSource> Take<TSource>(this IAsyncEnumerable<TSou
         public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return Create(() =>
             {
@@ -498,40 +351,17 @@ public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable
                 var d = Disposable.Create(cts, e);
 
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
-                        e.MoveNext(cts.Token).Then(t =>
+                        if (await e.MoveNext(cts.Token).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    var b = false;
-
-                                    try
-                                    {
-                                        b = predicate(e.Current);
-                                    }
-                                    catch (Exception ex)
-                                    {
-                                        tcs.TrySetException(ex);
-                                        return;
-                                    }
-
-                                    if (b)
-                                    {
-                                        tcs.TrySetResult(true);
-                                        return;
-                                    }
-                                }
-                                tcs.TrySetResult(false);
-                            });
-                        });
-
-                        return tcs.Task.UsingEnumerator(e);
+                            return predicate(e.Current);
+                        }
+                        return false;
                     },
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -539,9 +369,9 @@ public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable
         public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return Create(() =>
             {
@@ -552,40 +382,17 @@ public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable
                 var d = Disposable.Create(cts, e);
 
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
-                        e.MoveNext(cts.Token).Then(t =>
+                        if (await e.MoveNext(cts.Token).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    var b = false;
-
-                                    try
-                                    {
-                                        b = predicate(e.Current, checked(index++));
-                                    }
-                                    catch (Exception ex)
-                                    {
-                                        tcs.TrySetException(ex);
-                                        return;
-                                    }
-
-                                    if (b)
-                                    {
-                                        tcs.TrySetResult(true);
-                                        return;
-                                    }
-                                }
-                                tcs.TrySetResult(false);
-                            });
-                        });
-
-                        return tcs.Task.UsingEnumerator(e);
+                            return predicate(e.Current, checked(index++));
+                        }
+                        return false;
                     },
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -593,9 +400,9 @@ public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable
         public static IAsyncEnumerable<TSource> Skip<TSource>(this IAsyncEnumerable<TSource> source, int count)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return Create(() =>
             {
@@ -605,38 +412,27 @@ public static IAsyncEnumerable<TSource> Skip<TSource>(this IAsyncEnumerable<TSou
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, e);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
+                    var moveNext = await e.MoveNext(ct).ConfigureAwait(false);
                     if (n == 0)
-                        e.MoveNext(ct).Then(t =>
-                        {
-                            t.Handle(tcs, x => tcs.TrySetResult(x));
-                        });
-                    else
                     {
-                        --n;
-                        e.MoveNext(ct).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
-                            {
-                                if (!res)
-                                    tcs.TrySetResult(false);
-                                else
-                                    f(tcs, ct);
-                            });
-                        });
+                        return moveNext;
                     }
+                    --n;
+                    if (!moveNext)
+                    {
+                        return false;
+                    }
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    ct => f(cts.Token),
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -644,9 +440,9 @@ public static IAsyncEnumerable<TSource> Skip<TSource>(this IAsyncEnumerable<TSou
         public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return Create(() =>
             {
@@ -656,53 +452,28 @@ public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, e);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (skipping)
-                        e.MoveNext(ct).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    var result = false;
-                                    try
-                                    {
-                                        result = predicate(e.Current);
-                                    }
-                                    catch (Exception ex)
-                                    {
-                                        tcs.TrySetException(ex);
-                                        return;
-                                    }
-                                    if (result)
-                                        f(tcs, ct);
-                                    else
-                                    {
-                                        skipping = false;
-                                        tcs.TrySetResult(true);
-                                    }
-                                }
-                                else
-                                    tcs.TrySetResult(false);
-                            });
-                        });
-                    else
-                        e.MoveNext(ct).Then(t =>
+                    {
+                        if (await e.MoveNext(ct).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, x => tcs.TrySetResult(x));
-                        });
+                            if (predicate(e.Current))
+                                return await f(ct).ConfigureAwait(false);
+                            skipping = false;
+                            return true;
+                        }
+                        return false;
+                    }
+                    return await e.MoveNext(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -710,9 +481,9 @@ public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable
         public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (predicate == null)
-                throw new ArgumentNullException("predicate");
+                throw new ArgumentNullException(nameof(predicate));
 
             return Create(() =>
             {
@@ -723,53 +494,28 @@ public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, e);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (skipping)
-                        e.MoveNext(ct).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    var result = false;
-                                    try
-                                    {
-                                        result = predicate(e.Current, checked(index++));
-                                    }
-                                    catch (Exception ex)
-                                    {
-                                        tcs.TrySetException(ex);
-                                        return;
-                                    }
-                                    if (result)
-                                        f(tcs, ct);
-                                    else
-                                    {
-                                        skipping = false;
-                                        tcs.TrySetResult(true);
-                                    }
-                                }
-                                else
-                                    tcs.TrySetResult(false);
-                            });
-                        });
-                    else
-                        e.MoveNext(ct).Then(t =>
+                    {
+                        if (await e.MoveNext(ct).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, x => tcs.TrySetResult(x));
-                        });
+                            if (predicate(e.Current, checked(index++)))
+                                return await f(ct).ConfigureAwait(false);
+                            skipping = false;
+                            return true;
+                        }
+                        return false;
+                    }
+                    return await e.MoveNext(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => e.Current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -777,7 +523,7 @@ public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable
         public static IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this IAsyncEnumerable<TSource> source, TSource defaultValue)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return Create(() =>
             {
@@ -789,46 +535,31 @@ public static IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this IAsyncEnume
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, e);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (done)
-                        tcs.TrySetResult(false);
-                    else
-                        e.MoveNext(ct).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    hasElements = true;
-                                    current = e.Current;
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    done = true;
-
-                                    if (!hasElements)
-                                    {
-                                        current = defaultValue;
-                                        tcs.TrySetResult(true);
-                                    }
-                                    else
-                                        tcs.TrySetResult(false);
-                                }
-                            });
-                        });
+                        return false;
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
+                    {
+                        hasElements = true;
+                        current = e.Current;
+                        return true;
+                    }
+                    done = true;
+                    if (!hasElements)
+                    {
+                        current = defaultValue;
+                        return true;
+                    }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -836,7 +567,7 @@ public static IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this IAsyncEnume
         public static IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.DefaultIfEmpty(default(TSource));
         }
@@ -844,9 +575,9 @@ public static IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this IAsyncEnume
         public static IAsyncEnumerable<TSource> Distinct<TSource>(this IAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return Defer(() =>
             {
@@ -858,7 +589,7 @@ public static IAsyncEnumerable<TSource> Distinct<TSource>(this IAsyncEnumerable<
         public static IAsyncEnumerable<TSource> Distinct<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.Distinct(EqualityComparer<TSource>.Default);
         }
@@ -866,7 +597,7 @@ public static IAsyncEnumerable<TSource> Distinct<TSource>(this IAsyncEnumerable<
         public static IAsyncEnumerable<TSource> Reverse<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return Create(() =>
             {
@@ -877,29 +608,19 @@ public static IAsyncEnumerable<TSource> Reverse<TSource>(this IAsyncEnumerable<T
                 var d = Disposable.Create(cts, e);
 
                 return Create(
-                    (ct, tcs) =>
+                    async ct =>
                     {
                         if (stack == null)
                         {
-                            Create(() => e).Aggregate(new Stack<TSource>(), (s, x) => { s.Push(x); return s; }, cts.Token).Then(t =>
-                            {
-                                t.Handle(tcs, res =>
-                                {
-                                    stack = res;
-                                    tcs.TrySetResult(stack.Count > 0);
-                                });
-                            });
+                            stack = await Create(() => e).Aggregate(new Stack<TSource>(), (s, x) => { s.Push(x); return s; }, cts.Token).ConfigureAwait(false);
+                            return stack.Count > 0;
                         }
-                        else
-                        {
-                            stack.Pop();
-                            tcs.TrySetResult(stack.Count > 0);
-                        }
-
-                        return tcs.Task.UsingEnumerator(e);
+                        stack.Pop();
+                        return stack.Count > 0;
                     },
                     () => stack.Peek(),
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -907,11 +628,11 @@ public static IAsyncEnumerable<TSource> Reverse<TSource>(this IAsyncEnumerable<T
         public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return new OrderedAsyncEnumerable<TSource, TKey>(
                 Create(() =>
@@ -919,23 +640,14 @@ public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyn
                     var current = default(IEnumerable<TSource>);
 
                     return Create(
-                        ct =>
+                        async ct =>
                         {
-                            var tcs = new TaskCompletionSource<bool>();
                             if (current == null)
                             {
-                                source.ToList(ct).Then(t =>
-                                {
-                                    t.Handle(tcs, res =>
-                                    {
-                                        current = res;
-                                        tcs.TrySetResult(true);
-                                    });
-                                });
+                                current = await source.ToList(ct).ConfigureAwait(false);
+                                return true;
                             }
-                            else
-                                tcs.TrySetResult(false);
-                            return tcs.Task;
+                            return false;
                         },
                         () => current,
                         () => { }
@@ -949,9 +661,9 @@ public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyn
         public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.OrderBy(keySelector, Comparer<TKey>.Default);
         }
@@ -959,11 +671,11 @@ public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyn
         public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.OrderBy(keySelector, new ReverseComparer<TKey>(comparer));
         }
@@ -971,9 +683,9 @@ public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(
         public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.OrderByDescending(keySelector, Comparer<TKey>.Default);
         }
@@ -981,9 +693,9 @@ public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(
         public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.ThenBy(keySelector, Comparer<TKey>.Default);
         }
@@ -991,11 +703,11 @@ public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrder
         public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.CreateOrderedEnumerable(keySelector, comparer, false);
         }
@@ -1003,9 +715,9 @@ public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrder
         public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.ThenByDescending(keySelector, Comparer<TKey>.Default);
         }
@@ -1013,11 +725,11 @@ public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(t
         public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.CreateOrderedEnumerable(keySelector, comparer, true);
         }
@@ -1070,74 +782,35 @@ IAsyncEnumerable<IEnumerable<T>> Classes()
                     var d1 = new AssignableDisposable();
                     var d = Disposable.Create(cts, e, d1);
 
-                    var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                    var g = default(Action<TaskCompletionSource<bool>, CancellationToken>);
+                    var f = default(Func<CancellationToken, Task<bool>>);
 
-                    f = (tcs, ct) =>
+                    f = async ct =>
                     {
-                        e.MoveNext(ct).Then(t =>
+                        if (await e.MoveNext(ct).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    try
-                                    {
-                                        foreach (var group in e.Current.OrderBy(keySelector, comparer).GroupUntil(keySelector, x => x, comparer))
-                                            list.Add(group);
-                                        f(tcs, ct);
-                                    }
-                                    catch (Exception exception)
-                                    {
-                                        tcs.TrySetException(exception);
-                                        return;
-                                    }
-                                }
-                                else
-                                {
-                                    e.Dispose();
-
-                                    e1 = list.GetEnumerator();
-                                    d1.Disposable = e1;
-
-                                    g(tcs, ct);
-                                }
-                            });
-                        });
-                    };
-
-                    g = (tcs, ct) =>
-                    {
-                        var res = false;
-                        try
-                        {
-                            res = e1.MoveNext();
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                            return;
+                            list.AddRange(e.Current.OrderBy(keySelector, comparer).GroupUntil(keySelector, x => x, comparer));
+                            return await f(ct).ConfigureAwait(false);
                         }
+                        e.Dispose();
+
+                        e1 = list.GetEnumerator();
+                        d1.Disposable = e1;
 
-                        tcs.TrySetResult(res);
+                        return e1.MoveNext();
                     };
 
                     return Create(
-                        (ct, tcs) =>
+                        async ct =>
                         {
                             if (e1 != null)
                             {
-                                g(tcs, cts.Token);
-                                return tcs.Task.UsingEnumerator(e1);
-                            }
-                            else
-                            {
-                                f(tcs, cts.Token);
-                                return tcs.Task.UsingEnumerator(e);
+                                return e1.MoveNext();
                             }
+                            return await f(cts.Token).ConfigureAwait(false);
                         },
                         () => e1.Current,
-                        d.Dispose
+                        d.Dispose,
+                        e
                     );
                 });
             }
@@ -1166,13 +839,13 @@ public int Compare(T x, T y)
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return Create(() =>
             {
@@ -1187,9 +860,9 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource,
                 var index = 0;
 
                 var current = default(IAsyncGrouping<TKey, TElement>);
-                var faulted = default(Exception);
+                var faulted = default(ExceptionDispatchInfo);
 
-                var task = default(Task<bool>);
+                var res = default(bool?);
 
                 var cts = new CancellationTokenDisposable();
                 var refCount = new Disposable(
@@ -1202,126 +875,94 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource,
                 var d = Disposable.Create(cts, refCount);
 
                 var iterateSource = default(Func<CancellationToken, Task<bool>>);
-                iterateSource = ct =>
+                iterateSource = async ct =>
                 {
-                    var tcs = default(TaskCompletionSource<bool>);
                     lock (gate)
                     {
-                        if (task != null)
+                        if (res != null)
                         {
-                            return task;
-                        }
-                        else
-                        {
-                            tcs = new TaskCompletionSource<bool>();
-                            task = tcs.Task.UsingEnumerator(e);
+                            return res.Value;
                         }
+                        res = null;
                     }
 
-                    if (faulted != null)
-                    {
-                        tcs.TrySetException(faulted);
-                        return task;
-                    }
+                    faulted?.Throw();
 
-                    e.MoveNext(ct).Then(t =>
+                    try
                     {
-                        t.Handle(tcs,
-                            res =>
+                        res = await e.MoveNext(ct).ConfigureAwait(false);
+                        if (res == true)
+                        {
+                            var key = default(TKey);
+                            var element = default(TElement);
+
+                            var cur = e.Current;
+                            try
                             {
-                                if (res)
-                                {
-                                    var key = default(TKey);
-                                    var element = default(TElement);
-
-                                    var cur = e.Current;
-                                    try
-                                    {
-                                        key = keySelector(cur);
-                                        element = elementSelector(cur);
-                                    }
-                                    catch (Exception exception)
-                                    {
-                                        foreach (var v in map.Values)
-                                            v.Error(exception);
-
-                                        tcs.TrySetException(exception);
-                                        return;
-                                    }
-
-                                    var group = default(Grouping<TKey, TElement>);
-                                    if (!map.TryGetValue(key, out group))
-                                    {
-                                        group = new Grouping<TKey, TElement>(key, iterateSource, refCount);
-                                        map.Add(key, group);
-                                        lock (list)
-                                            list.Add(group);
-
-                                        Interlocked.Increment(ref count);
-                                    }
-                                    group.Add(element);
-                                }
-
-                                tcs.TrySetResult(res);
-                            },
-                            ex =>
+                                key = keySelector(cur);
+                                element = elementSelector(cur);
+                            }
+                            catch (Exception exception)
                             {
                                 foreach (var v in map.Values)
-                                    v.Error(ex);
+                                    v.Error(exception);
 
-                                faulted = ex;
-                                tcs.TrySetException(ex);
+                                throw;
                             }
-                        );
 
-                        lock (gate)
-                        {
-                            task = null;
+                            var group = default(Grouping<TKey, TElement>);
+                            if (!map.TryGetValue(key, out group))
+                            {
+                                group = new Grouping<TKey, TElement>(key, iterateSource, refCount);
+                                map.Add(key, group);
+                                lock (list)
+                                    list.Add(group);
+
+                                Interlocked.Increment(ref count);
+                            }
+                            group.Add(element);
                         }
-                    });
 
-                    return tcs.Task.UsingEnumerator(e);
+                        return res.Value;
+                    }
+                    catch (Exception ex)
+                    {
+                        foreach (var v in map.Values)
+                            v.Error(ex);
+
+                        faulted = ExceptionDispatchInfo.Capture(ex);
+                        throw;
+                    }
+                    finally
+                    {
+                        res = null;
+                    }
                 };
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    iterateSource(ct).Then(t =>
+                    var result = await iterateSource(ct).ConfigureAwait(false);
+
+                    current = null;
+                    lock (list)
                     {
-                        t.Handle(tcs,
-                            res =>
-                            {
-                                current = null;
-                                lock (list)
-                                {
-                                    if (index < list.Count)
-                                        current = list[index++];
-                                }
-
-                                if (current != null)
-                                {
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    if (res)
-                                        f(tcs, ct);
-                                    else
-                                        tcs.TrySetResult(false);
-                                }
-                            }
-                        );
-                    });
+                        if (index < list.Count)
+                            current = list[index++];
+                    }
+
+                    if (current != null)
+                    {
+                        return true;
+                    }
+                    return result && await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task;
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -1329,11 +970,11 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource,
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
 
             return source.GroupBy(keySelector, elementSelector, EqualityComparer<TKey>.Default);
         }
@@ -1341,11 +982,11 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource,
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.GroupBy(keySelector, x => x, comparer);
         }
@@ -1353,9 +994,9 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, T
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.GroupBy(keySelector, x => x, EqualityComparer<TKey>.Default);
         }
@@ -1363,15 +1004,15 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, T
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.GroupBy(keySelector, elementSelector, comparer).Select(g => resultSelector(g.Key, g));
         }
@@ -1379,13 +1020,13 @@ public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, TResult> resultSelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (elementSelector == null)
-                throw new ArgumentNullException("elementSelector");
+                throw new ArgumentNullException(nameof(elementSelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
             return source.GroupBy(keySelector, elementSelector, EqualityComparer<TKey>.Default).Select(g => resultSelector(g.Key, g));
         }
@@ -1393,13 +1034,13 @@ public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IAsyncEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.GroupBy(keySelector, x => x, comparer).Select(g => resultSelector(g.Key, g));
         }
@@ -1407,11 +1048,11 @@ public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAs
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IAsyncEnumerable<TSource>, TResult> resultSelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (resultSelector == null)
-                throw new ArgumentNullException("resultSelector");
+                throw new ArgumentNullException(nameof(resultSelector));
 
             return source.GroupBy(keySelector, x => x, EqualityComparer<TKey>.Default).Select(g => resultSelector(g.Key, g));
         }
@@ -1422,7 +1063,7 @@ class Grouping<TKey, TElement> : IAsyncGrouping<TKey, TElement>
             private readonly IDisposable sourceDisposable;
             private readonly List<TElement> elements = new List<TElement>();
             private bool done = false;
-            private Exception exception = null;
+            private ExceptionDispatchInfo exception = null;
 
             public Grouping(TKey key, Func<CancellationToken, Task<bool>> iterateSource, IDisposable sourceDisposable)
             {
@@ -1446,7 +1087,7 @@ public void Add(TElement element)
             public void Error(Exception exception)
             {
                 done = true;
-                this.exception = exception;
+                this.exception = ExceptionDispatchInfo.Capture(exception);
             }
 
             public IAsyncEnumerator<TElement> GetEnumerator()
@@ -1456,8 +1097,8 @@ public IAsyncEnumerator<TElement> GetEnumerator()
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, sourceDisposable);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     var size = 0;
                     lock (elements)
@@ -1465,39 +1106,29 @@ public IAsyncEnumerator<TElement> GetEnumerator()
 
                     if (index < size)
                     {
-                        tcs.TrySetResult(true);
+                        return true;
                     }
-                    else if (done)
+                    if (done)
                     {
-                        if (exception != null)
-                            tcs.TrySetException(exception);
-                        else
-                            tcs.TrySetResult(false);
+                        exception?.Throw();
+                        return false;
                     }
-                    else
+                    if (await iterateSource(ct).ConfigureAwait(false))
                     {
-                        iterateSource(ct).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                    f(tcs, ct);
-                                else
-                                    tcs.TrySetResult(false);
-                            });
-                        });
+                        return await f(ct).ConfigureAwait(false);
                     }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
+                    ct =>
                     {
                         ++index;
-                        f(tcs, cts.Token);
-                        return tcs.Task;
+                        return f(cts.Token);
                     },
                     () => elements[index],
-                    d.Dispose
+                    d.Dispose,
+                    null
                 );
             }
         }
@@ -1507,9 +1138,9 @@ public IAsyncEnumerator<TElement> GetEnumerator()
         public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource> onNext)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (onNext == null)
-                throw new ArgumentNullException("onNext");
+                throw new ArgumentNullException(nameof(onNext));
 
             return DoHelper(source, onNext, _ => { }, () => { });
         }
@@ -1517,11 +1148,11 @@ public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSourc
         public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource> onNext, Action onCompleted)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (onNext == null)
-                throw new ArgumentNullException("onNext");
+                throw new ArgumentNullException(nameof(onNext));
             if (onCompleted == null)
-                throw new ArgumentNullException("onCompleted");
+                throw new ArgumentNullException(nameof(onCompleted));
 
             return DoHelper(source, onNext, _ => { }, onCompleted);
         }
@@ -1529,11 +1160,11 @@ public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSourc
         public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (onNext == null)
-                throw new ArgumentNullException("onNext");
+                throw new ArgumentNullException(nameof(onNext));
             if (onError == null)
-                throw new ArgumentNullException("onError");
+                throw new ArgumentNullException(nameof(onError));
 
             return DoHelper(source, onNext, onError, () => { });
         }
@@ -1541,13 +1172,13 @@ public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSourc
         public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (onNext == null)
-                throw new ArgumentNullException("onNext");
+                throw new ArgumentNullException(nameof(onNext));
             if (onError == null)
-                throw new ArgumentNullException("onError");
+                throw new ArgumentNullException(nameof(onError));
             if (onCompleted == null)
-                throw new ArgumentNullException("onCompleted");
+                throw new ArgumentNullException(nameof(onCompleted));
 
             return DoHelper(source, onNext, onError, onCompleted);
         }
@@ -1556,9 +1187,9 @@ public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSourc
         public static IAsyncEnumerable<TSource> Do<TSource>(this IAsyncEnumerable<TSource> source, IObserver<TSource> observer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (observer == null)
-                throw new ArgumentNullException("observer");
+                throw new ArgumentNullException(nameof(observer));
 
             return DoHelper(source, observer.OnNext, observer.OnError, observer.OnCompleted);
         }
@@ -1575,51 +1206,39 @@ private static IAsyncEnumerable<TSource> DoHelper<TSource>(this IAsyncEnumerable
 
                 var current = default(TSource);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    try
                     {
-                        if (!t.IsCanceled)
+                        var result = await e.MoveNext(ct).ConfigureAwait(false);
+                        if (!result)
                         {
-                            try
-                            {
-                                if (t.IsFaulted)
-                                {
-                                    onError(t.Exception);
-                                }
-                                else if (!t.Result)
-                                {
-                                    onCompleted();
-                                }
-                                else
-                                {
-                                    current = e.Current;
-                                    onNext(current);
-                                }
-                            }
-                            catch (Exception ex)
-                            {
-                                tcs.TrySetException(ex);
-                                return;
-                            }
+                            onCompleted();
                         }
-
-                        t.Handle(tcs, res =>
+                        else
                         {
-                            tcs.TrySetResult(res);
-                        });
-                    });
+                            current = e.Current;
+                            onNext(current);
+                        }
+                        return result;
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        throw;
+                    }
+                    catch (Exception ex)
+                    {
+                        onError(ex);
+                        throw;
+                    }
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -1627,9 +1246,9 @@ private static IAsyncEnumerable<TSource> DoHelper<TSource>(this IAsyncEnumerable
         public static void ForEach<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource> action, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (action == null)
-                throw new ArgumentNullException("action");
+                throw new ArgumentNullException(nameof(action));
 
             source.ForEachAsync(action, cancellationToken).Wait(cancellationToken);
         }
@@ -1637,9 +1256,9 @@ public static void ForEach<TSource>(this IAsyncEnumerable<TSource> source, Actio
         public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource> action, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (action == null)
-                throw new ArgumentNullException("action");
+                throw new ArgumentNullException(nameof(action));
 
             return source.ForEachAsync((x, i) => action(x), cancellationToken);
         }
@@ -1647,9 +1266,9 @@ public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source,
         public static void ForEach<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource, int> action, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (action == null)
-                throw new ArgumentNullException("action");
+                throw new ArgumentNullException(nameof(action));
 
             source.ForEachAsync(action, cancellationToken).Wait(cancellationToken);
         }
@@ -1657,54 +1276,31 @@ public static void ForEach<TSource>(this IAsyncEnumerable<TSource> source, Actio
         public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource, int> action, CancellationToken cancellationToken)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (action == null)
-                throw new ArgumentNullException("action");
-
-            var tcs = new TaskCompletionSource<bool>();
-
-            var e = source.GetEnumerator();
+                throw new ArgumentNullException(nameof(action));
 
-            var i = 0;
+            return ForEachAsync_(source, action, cancellationToken);
+        }
 
-            var f = default(Action<CancellationToken>);
-            f = ct =>
+        private static async Task ForEachAsync_<TSource>(IAsyncEnumerable<TSource> source, Action<TSource, int> action, CancellationToken cancellationToken)
+        {
+            var index = 0;
+            using (var e = source.GetEnumerator())
             {
-                e.MoveNext(ct).Then(t =>
+                while (await e.MoveNext(cancellationToken).ConfigureAwait(false))
                 {
-                    t.Handle(tcs, res =>
-                    {
-                        if (res)
-                        {
-                            try
-                            {
-                                action(e.Current, i++);
-                            }
-                            catch (Exception ex)
-                            {
-                                tcs.TrySetException(ex);
-                                return;
-                            }
-
-                            f(ct);
-                        }
-                        else
-                            tcs.TrySetResult(true);
-                    });
-                });
-            };
-
-            f(cancellationToken);
-
-            return tcs.Task.UsingEnumerator(e);
+                    action(e.Current, checked(index++));
+                }
+            }
         }
 
         public static IAsyncEnumerable<TSource> Repeat<TSource>(this IAsyncEnumerable<TSource> source, int count)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return Create(() =>
             {
@@ -1716,56 +1312,35 @@ public static IAsyncEnumerable<TSource> Repeat<TSource>(this IAsyncEnumerable<TS
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, a);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (e == null)
                     {
                         if (n-- == 0)
                         {
-                            tcs.TrySetResult(false);
-                            return;
+                            return false;
                         }
 
-                        try
-                        {
-                            e = source.GetEnumerator();
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                            return;
-                        }
+                        e = source.GetEnumerator();
 
                         a.Disposable = e;
                     }
 
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                current = e.Current;
-                                tcs.TrySetResult(true);
-                            }
-                            else
-                            {
-                                e = null;
-                                f(tcs, ct);
-                            }
-                        });
-                    });
+                        current = e.Current;
+                        return true;
+                    }
+                    e = null;
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(d);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -1773,7 +1348,7 @@ public static IAsyncEnumerable<TSource> Repeat<TSource>(this IAsyncEnumerable<TS
         public static IAsyncEnumerable<TSource> Repeat<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return Create(() =>
             {
@@ -1784,50 +1359,30 @@ public static IAsyncEnumerable<TSource> Repeat<TSource>(this IAsyncEnumerable<TS
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, a);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (e == null)
                     {
-                        try
-                        {
-                            e = source.GetEnumerator();
-                        }
-                        catch (Exception ex)
-                        {
-                            tcs.TrySetException(ex);
-                            return;
-                        }
+                        e = source.GetEnumerator();
 
                         a.Disposable = e;
                     }
 
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                current = e.Current;
-                                tcs.TrySetResult(true);
-                            }
-                            else
-                            {
-                                e = null;
-                                f(tcs, ct);
-                            }
-                        });
-                    });
+                        current = e.Current;
+                        return true;
+                    }
+                    e = null;
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(d);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -1835,7 +1390,7 @@ public static IAsyncEnumerable<TSource> Repeat<TSource>(this IAsyncEnumerable<TS
         public static IAsyncEnumerable<TSource> IgnoreElements<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return Create(() =>
             {
@@ -1844,32 +1399,22 @@ public static IAsyncEnumerable<TSource> IgnoreElements<TSource>(this IAsyncEnume
                 var cts = new CancellationTokenDisposable();
                 var d = Disposable.Create(cts, e);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (!await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (!res)
-                            {
-                                tcs.TrySetResult(false);
-                                return;
-                            }
+                        return false;
+                    }
 
-                            f(tcs, ct);
-                        });
-                    });
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create<TSource>(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => { throw new InvalidOperationException(); },
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -1877,7 +1422,7 @@ public static IAsyncEnumerable<TSource> IgnoreElements<TSource>(this IAsyncEnume
         public static IAsyncEnumerable<TSource> StartWith<TSource>(this IAsyncEnumerable<TSource> source, params TSource[] values)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return values.ToAsyncEnumerable().Concat(source);
         }
@@ -1885,9 +1430,9 @@ public static IAsyncEnumerable<TSource> StartWith<TSource>(this IAsyncEnumerable
         public static IAsyncEnumerable<IList<TSource>> Buffer<TSource>(this IAsyncEnumerable<TSource> source, int count)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (count <= 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return source.Buffer_(count, count);
         }
@@ -1895,11 +1440,11 @@ public static IAsyncEnumerable<IList<TSource>> Buffer<TSource>(this IAsyncEnumer
         public static IAsyncEnumerable<IList<TSource>> Buffer<TSource>(this IAsyncEnumerable<TSource> source, int count, int skip)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (count <= 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
             if (skip <= 0)
-                throw new ArgumentOutOfRangeException("skip");
+                throw new ArgumentOutOfRangeException(nameof(skip));
 
             return source.Buffer_(count, skip);
         }
@@ -1920,66 +1465,46 @@ private static IAsyncEnumerable<IList<TSource>> Buffer_<TSource>(this IAsyncEnum
                 var current = default(IList<TSource>);
                 var stopped = false;
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (!stopped)
                     {
-                        e.MoveNext(ct).Then(t =>
+                        if (await e.MoveNext(ct).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
+                            var item = e.Current;
+
+                            if (i++ % skip == 0)
+                                buffers.Enqueue(new List<TSource>(count));
+
+                            foreach (var buffer in buffers)
+                                buffer.Add(item);
+
+                            if (buffers.Count > 0 && buffers.Peek().Count == count)
                             {
-                                if (res)
-                                {
-                                    var item = e.Current;
-
-                                    if (i++ % skip == 0)
-                                        buffers.Enqueue(new List<TSource>(count));
-
-                                    foreach (var buffer in buffers)
-                                        buffer.Add(item);
-
-                                    if (buffers.Count > 0 && buffers.Peek().Count == count)
-                                    {
-                                        current = buffers.Dequeue();
-                                        tcs.TrySetResult(true);
-                                        return;
-                                    }
-
-                                    f(tcs, ct);
-                                }
-                                else
-                                {
-                                    stopped = true;
-                                    e.Dispose();
-
-                                    f(tcs, ct);
-                                }
-                            });
-                        });
+                                current = buffers.Dequeue();
+                                return true;
+                            }
+                            return await f(ct).ConfigureAwait(false);
+                        }
+                        stopped = true;
+                        e.Dispose();
+
+                        return await f(ct).ConfigureAwait(false);
                     }
-                    else
+                    if (buffers.Count > 0)
                     {
-                        if (buffers.Count > 0)
-                        {
-                            current = buffers.Dequeue();
-                            tcs.TrySetResult(true);
-                        }
-                        else
-                        {
-                            tcs.TrySetResult(false);
-                        }
+                        current = buffers.Dequeue();
+                        return true;
                     }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -1987,11 +1512,11 @@ private static IAsyncEnumerable<IList<TSource>> Buffer_<TSource>(this IAsyncEnum
         public static IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return Defer(() =>
             {
@@ -2003,9 +1528,9 @@ public static IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this IAsyncEnume
         public static IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.Distinct(keySelector, EqualityComparer<TKey>.Default);
         }
@@ -2013,7 +1538,7 @@ public static IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this IAsyncEnume
         public static IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
 
             return source.DistinctUntilChanged_(x => x, EqualityComparer<TSource>.Default);
         }
@@ -2021,9 +1546,9 @@ public static IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this IAsyn
         public static IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this IAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.DistinctUntilChanged_(x => x, comparer);
         }
@@ -2031,9 +1556,9 @@ public static IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this IAsyn
         public static IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
 
             return source.DistinctUntilChanged_(keySelector, EqualityComparer<TKey>.Default);
         }
@@ -2041,11 +1566,11 @@ public static IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this
         public static IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (keySelector == null)
-                throw new ArgumentNullException("keySelector");
+                throw new ArgumentNullException(nameof(keySelector));
             if (comparer == null)
-                throw new ArgumentNullException("comparer");
+                throw new ArgumentNullException(nameof(comparer));
 
             return source.DistinctUntilChanged_(keySelector, comparer);
         }
@@ -2063,63 +1588,40 @@ private static IAsyncEnumerable<TSource> DistinctUntilChanged_<TSource, TKey>(th
                 var hasCurrentKey = false;
                 var current = default(TSource);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
+                        var item = e.Current;
+                        var key = default(TKey);
+                        var comparerEquals = false;
+
+                        key = keySelector(item);
+
+                        if (hasCurrentKey)
                         {
-                            if (res)
-                            {
-                                var item = e.Current;
-                                var key = default(TKey);
-                                var comparerEquals = false;
-
-                                try
-                                {
-                                    key = keySelector(item);
-
-                                    if (hasCurrentKey)
-                                    {
-                                        comparerEquals = comparer.Equals(currentKey, key);
-                                    }
-                                }
-                                catch (Exception ex)
-                                {
-                                    tcs.TrySetException(ex);
-                                    return;
-                                }
-
-                                if (!hasCurrentKey || !comparerEquals)
-                                {
-                                    hasCurrentKey = true;
-                                    currentKey = key;
-
-                                    current = item;
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    f(tcs, ct);
-                                }
-                            }
-                            else
-                            {
-                                tcs.TrySetResult(false);
-                            }
-                        });
-                    });
+                            comparerEquals = comparer.Equals(currentKey, key);
+                        }
+
+                        if (!hasCurrentKey || !comparerEquals)
+                        {
+                            hasCurrentKey = true;
+                            currentKey = key;
+
+                            current = item;
+                            return true;
+                        }
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -2127,9 +1629,9 @@ private static IAsyncEnumerable<TSource> DistinctUntilChanged_<TSource, TKey>(th
         public static IAsyncEnumerable<TSource> Expand<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, IAsyncEnumerable<TSource>> selector)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (selector == null)
-                throw new ArgumentNullException("selector");
+                throw new ArgumentNullException(nameof(selector));
 
             return Create(() =>
             {
@@ -2144,8 +1646,8 @@ public static IAsyncEnumerable<TSource> Expand<TSource>(this IAsyncEnumerable<TS
 
                 var current = default(TSource);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (e == null)
                     {
@@ -2153,67 +1655,31 @@ public static IAsyncEnumerable<TSource> Expand<TSource>(this IAsyncEnumerable<TS
                         {
                             var src = queue.Dequeue();
 
-                            try
-                            {
-                                e = src.GetEnumerator();
-                            }
-                            catch (Exception ex)
-                            {
-                                tcs.TrySetException(ex);
-                                return;
-                            }
+                            e = src.GetEnumerator();
 
                             a.Disposable = e;
-                            f(tcs, ct);
-                        }
-                        else
-                        {
-                            tcs.TrySetResult(false);
+                            return await f(ct).ConfigureAwait(false);
                         }
+                        return false;
                     }
-                    else
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        e.MoveNext(ct).Then(t =>
-                        {
-                            t.Handle(tcs, res =>
-                            {
-                                if (res)
-                                {
-                                    var item = e.Current;
-
-                                    var next = default(IAsyncEnumerable<TSource>);
-                                    try
-                                    {
-                                        next = selector(item);
-                                    }
-                                    catch (Exception ex)
-                                    {
-                                        tcs.TrySetException(ex);
-                                        return;
-                                    }
-
-                                    queue.Enqueue(next);
-                                    current = item;
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    e = null;
-                                    f(tcs, ct);
-                                }
-                            });
-                        });
+                        var item = e.Current;
+                        var next = selector(item);
+
+                        queue.Enqueue(next);
+                        current = item;
+                        return true;
                     }
+                    e = null;
+                    return await f(ct).ConfigureAwait(false);
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(a);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -2221,9 +1687,9 @@ public static IAsyncEnumerable<TSource> Expand<TSource>(this IAsyncEnumerable<TS
         public static IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (accumulator == null)
-                throw new ArgumentNullException("accumulator");
+                throw new ArgumentNullException(nameof(accumulator));
 
             return Create(() =>
             {
@@ -2235,44 +1701,26 @@ public static IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this IAsy
                 var acc = seed;
                 var current = default(TAccumulate);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (!await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (!res)
-                            {
-                                tcs.TrySetResult(false);
-                                return;
-                            }
+                        return false;
+                    }
 
-                            var item = e.Current;
-                            try
-                            {
-                                acc = accumulator(acc, item);
-                            }
-                            catch (Exception ex)
-                            {
-                                tcs.TrySetException(ex);
-                                return;
-                            }
+                    var item = e.Current;
+                    acc = accumulator(acc, item);
 
-                            current = acc;
-                            tcs.TrySetResult(true);
-                        });
-                    });
+                    current = acc;
+                    return true;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -2280,9 +1728,9 @@ public static IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this IAsy
         public static IAsyncEnumerable<TSource> Scan<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (accumulator == null)
-                throw new ArgumentNullException("accumulator");
+                throw new ArgumentNullException(nameof(accumulator));
 
             return Create(() =>
             {
@@ -2295,53 +1743,34 @@ public static IAsyncEnumerable<TSource> Scan<TSource>(this IAsyncEnumerable<TSou
                 var acc = default(TSource);
                 var current = default(TSource);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (!await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (!res)
-                            {
-                                tcs.TrySetResult(false);
-                                return;
-                            }
+                        return false;
+                    }
 
-                            var item = e.Current;
+                    var item = e.Current;
 
-                            if (!hasSeed)
-                            {
-                                hasSeed = true;
-                                acc = item;
-                                f(tcs, ct);
-                                return;
-                            }
+                    if (!hasSeed)
+                    {
+                        hasSeed = true;
+                        acc = item;
+                        return await f(ct).ConfigureAwait(false);
+                    }
 
-                            try
-                            {
-                                acc = accumulator(acc, item);
-                            }
-                            catch (Exception ex)
-                            {
-                                tcs.TrySetException(ex);
-                                return;
-                            }
+                    acc = accumulator(acc, item);
 
-                            current = acc;
-                            tcs.TrySetResult(true);
-                        });
-                    });
+                    current = acc;
+                    return true;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -2349,9 +1778,9 @@ public static IAsyncEnumerable<TSource> Scan<TSource>(this IAsyncEnumerable<TSou
         public static IAsyncEnumerable<TSource> TakeLast<TSource>(this IAsyncEnumerable<TSource> source, int count)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return Create(() =>
             {
@@ -2364,57 +1793,42 @@ public static IAsyncEnumerable<TSource> TakeLast<TSource>(this IAsyncEnumerable<
                 var done = false;
                 var current = default(TSource);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
                     if (!done)
                     {
-                        e.MoveNext(ct).Then(t =>
+                        if (await e.MoveNext(ct).ConfigureAwait(false))
                         {
-                            t.Handle(tcs, res =>
+                            if (count > 0)
                             {
-                                if (res)
-                                {                                    
-                                    if (count > 0)
-                                    {
-                                        var item = e.Current;
-                                        if (q.Count >= count)
-                                            q.Dequeue();
-                                        q.Enqueue(item);
-                                    }
-                                }
-                                else
-                                {
-                                    done = true;
-                                    e.Dispose();
-                                }
-
-                                f(tcs, ct);
-                            });
-                        });
-                    }
-                    else
-                    {
-                        if (q.Count > 0)
-                        {
-                            current = q.Dequeue();
-                            tcs.TrySetResult(true);
+                                var item = e.Current;
+                                if (q.Count >= count)
+                                    q.Dequeue();
+                                q.Enqueue(item);
+                            }
                         }
                         else
                         {
-                            tcs.TrySetResult(false);
+                            done = true;
+                            e.Dispose();
                         }
+
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    if (q.Count > 0)
+                    {
+                        current = q.Dequeue();
+                        return true;
                     }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
@@ -2422,9 +1836,9 @@ public static IAsyncEnumerable<TSource> TakeLast<TSource>(this IAsyncEnumerable<
         public static IAsyncEnumerable<TSource> SkipLast<TSource>(this IAsyncEnumerable<TSource> source, int count)
         {
             if (source == null)
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             if (count < 0)
-                throw new ArgumentOutOfRangeException("count");
+                throw new ArgumentOutOfRangeException(nameof(count));
 
             return Create(() =>
             {
@@ -2436,44 +1850,29 @@ public static IAsyncEnumerable<TSource> SkipLast<TSource>(this IAsyncEnumerable<
                 var q = new Queue<TSource>();
                 var current = default(TSource);
 
-                var f = default(Action<TaskCompletionSource<bool>, CancellationToken>);
-                f = (tcs, ct) =>
+                var f = default(Func<CancellationToken, Task<bool>>);
+                f = async ct =>
                 {
-                    e.MoveNext(ct).Then(t =>
+                    if (await e.MoveNext(ct).ConfigureAwait(false))
                     {
-                        t.Handle(tcs, res =>
-                        {
-                            if (res)
-                            {
-                                var item = e.Current;
+                        var item = e.Current;
 
-                                q.Enqueue(item);
-                                if (q.Count > count)
-                                {
-                                    current = q.Dequeue();
-                                    tcs.TrySetResult(true);
-                                }
-                                else
-                                {
-                                    f(tcs, ct);
-                                }
-                            }
-                            else
-                            {
-                                tcs.TrySetResult(false);
-                            }
-                        });
-                    });
+                        q.Enqueue(item);
+                        if (q.Count > count)
+                        {
+                            current = q.Dequeue();
+                            return true;
+                        }
+                        return await f(ct).ConfigureAwait(false);
+                    }
+                    return false;
                 };
 
                 return Create(
-                    (ct, tcs) =>
-                    {
-                        f(tcs, cts.Token);
-                        return tcs.Task.UsingEnumerator(e);
-                    },
+                    f,
                     () => current,
-                    d.Dispose
+                    d.Dispose,
+                    e
                 );
             });
         }
diff --git a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerator.cs b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerator.cs
index b854b29a2f..71fd60b2f0 100644
--- a/Ix.NET/Source/System.Interactive.Async/AsyncEnumerator.cs
+++ b/Ix.NET/Source/System.Interactive.Async/AsyncEnumerator.cs
@@ -20,7 +20,7 @@ public static class AsyncEnumerator
         public static Task<bool> MoveNext<T>(this IAsyncEnumerator<T> enumerator)
         {
             if (enumerator == null)
-                throw new ArgumentNullException("enumerator");
+                throw new ArgumentNullException(nameof(enumerator));
 
             return enumerator.MoveNext(CancellationToken.None);
         }
diff --git a/Ix.NET/Source/System.Interactive.Async/EmptyArray.cs b/Ix.NET/Source/System.Interactive.Async/EmptyArray.cs
new file mode 100644
index 0000000000..02757b7d97
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/EmptyArray.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information. 
+#if NO_ARRAY_EMPTY
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    internal sealed class EmptyArray<TElement>
+    {
+        public static readonly TElement[] Value = new TElement[0];
+    }
+}
+#endif
diff --git a/Ix.NET/Source/System.Interactive.Async/Grouping.cs b/Ix.NET/Source/System.Interactive.Async/Grouping.cs
new file mode 100644
index 0000000000..60d1c897cf
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/Grouping.cs
@@ -0,0 +1,131 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information. 
+using System.Collections;
+using System.Collections.Generic;
+
+namespace System.Linq.Internal
+{
+    /// Adapted from System.Linq.Grouping from .NET Framework
+    /// Source: https://github.com/dotnet/corefx/blob/b90532bc97b07234a7d18073819d019645285f1c/src/System.Linq/src/System/Linq/Grouping.cs#L64
+    internal class Grouping<TKey, TElement> : IGrouping<TKey, TElement>, IList<TElement>
+    {
+        internal TKey _key;
+        internal int _hashCode;
+        internal TElement[] _elements;
+        internal int _count;
+        internal Grouping<TKey, TElement> _hashNext;
+        internal Grouping<TKey, TElement> _next;
+
+        internal Grouping()
+        {
+        }
+
+        internal void Add(TElement element)
+        {
+            if (_elements.Length == _count)
+            {
+                Array.Resize(ref _elements, checked(_count * 2));
+            }
+
+            _elements[_count] = element;
+            _count++;
+        }
+
+        internal void Trim()
+        {
+            if (_elements.Length != _count)
+            {
+                Array.Resize(ref _elements, _count);
+            }
+        }
+
+        public IEnumerator<TElement> GetEnumerator()
+        {
+            for (int i = 0; i < _count; i++)
+            {
+                yield return _elements[i];
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        // DDB195907: implement IGrouping<>.Key implicitly
+        // so that WPF binding works on this property.
+        public TKey Key
+        {
+            get { return _key; }
+        }
+
+        int ICollection<TElement>.Count
+        {
+            get { return _count; }
+        }
+
+        bool ICollection<TElement>.IsReadOnly
+        {
+            get { return true; }
+        }
+
+        void ICollection<TElement>.Add(TElement item)
+        {
+            throw new NotSupportedException(Strings.NOT_SUPPORTED);
+        }
+
+        void ICollection<TElement>.Clear()
+        {
+            throw new NotSupportedException(Strings.NOT_SUPPORTED);
+        }
+
+        bool ICollection<TElement>.Contains(TElement item)
+        {
+            return Array.IndexOf(_elements, item, 0, _count) >= 0;
+        }
+
+        void ICollection<TElement>.CopyTo(TElement[] array, int arrayIndex)
+        {
+            Array.Copy(_elements, 0, array, arrayIndex, _count);
+        }
+
+        bool ICollection<TElement>.Remove(TElement item)
+        {
+            throw new NotSupportedException(Strings.NOT_SUPPORTED);
+        }
+
+        int IList<TElement>.IndexOf(TElement item)
+        {
+            return Array.IndexOf(_elements, item, 0, _count);
+        }
+
+        void IList<TElement>.Insert(int index, TElement item)
+        {
+            throw new NotSupportedException(Strings.NOT_SUPPORTED);
+        }
+
+        void IList<TElement>.RemoveAt(int index)
+        {
+            throw new NotSupportedException(Strings.NOT_SUPPORTED);
+        }
+
+        TElement IList<TElement>.this[int index]
+        {
+            get
+            {
+                if (index < 0 || index >= _count)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index));
+                }
+
+                return _elements[index];
+            }
+
+            set
+            {
+                throw new NotSupportedException(Strings.NOT_SUPPORTED);
+            }
+        }
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/Lookup.cs b/Ix.NET/Source/System.Interactive.Async/Lookup.cs
new file mode 100644
index 0000000000..e1e6703bc4
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/Lookup.cs
@@ -0,0 +1,275 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information. 
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq.Internal
+{
+    internal class Lookup<TKey, TElement> : ILookup<TKey, TElement>
+    {
+        private readonly IEqualityComparer<TKey> _comparer;
+        private Grouping<TKey, TElement>[] _groupings;
+        private Grouping<TKey, TElement> _lastGrouping;
+        private int _count;
+
+        internal static Lookup<TKey, TElement> Create<TSource>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
+        {
+            Debug.Assert(source != null);
+            Debug.Assert(keySelector != null);
+            Debug.Assert(elementSelector != null);
+
+            Lookup<TKey, TElement> lookup = new Lookup<TKey, TElement>(comparer);
+            foreach (TSource item in source)
+            {
+                lookup.GetGrouping(keySelector(item), create: true).Add(elementSelector(item));
+            }
+
+            return lookup;
+        }
+
+        internal static async Task<Lookup<TKey, TElement>> CreateAsync<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
+        {
+            Debug.Assert(source != null);
+            Debug.Assert(keySelector != null);
+            Debug.Assert(elementSelector != null);
+
+            Lookup<TKey, TElement> lookup = new Lookup<TKey, TElement>(comparer);
+            using (var enu = source.GetEnumerator())
+            {
+                while (await enu.MoveNext(cancellationToken)
+                                .ConfigureAwait(false))
+                {
+                    lookup.GetGrouping(keySelector(enu.Current), create: true).Add(elementSelector(enu.Current));
+                }
+            }
+
+            return lookup;
+        }
+
+        internal static Lookup<TKey, TElement> Create(IEnumerable<TElement> source, Func<TElement, TKey> keySelector, IEqualityComparer<TKey> comparer)
+        {
+            Debug.Assert(source != null);
+            Debug.Assert(keySelector != null);
+
+            Lookup<TKey, TElement> lookup = new Lookup<TKey, TElement>(comparer);
+            foreach (TElement item in source)
+            {
+                lookup.GetGrouping(keySelector(item), create: true).Add(item);
+            }
+
+            return lookup;
+        }
+
+        internal static Lookup<TKey, TElement> CreateForJoin(IEnumerable<TElement> source, Func<TElement, TKey> keySelector, IEqualityComparer<TKey> comparer)
+        {
+            Lookup<TKey, TElement> lookup = new Lookup<TKey, TElement>(comparer);
+            foreach (TElement item in source)
+            {
+                TKey key = keySelector(item);
+                if (key != null)
+                {
+                    lookup.GetGrouping(key, create: true).Add(item);
+                }
+            }
+
+            return lookup;
+        }
+
+        internal static async Task<Lookup<TKey, TElement>> CreateForJoinAsync(IAsyncEnumerable<TElement> source, Func<TElement, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
+        {
+            Lookup<TKey, TElement> lookup = new Lookup<TKey, TElement>(comparer);
+            using (var enu = source.GetEnumerator())
+            {
+                while (await enu.MoveNext(cancellationToken)
+                                .ConfigureAwait(false))
+                {
+                    TKey key = keySelector(enu.Current);
+                    if (key != null)
+                    {
+                        lookup.GetGrouping(key, create: true).Add(enu.Current);
+                    }
+                }
+            }
+
+            return lookup;
+        }
+
+        private Lookup(IEqualityComparer<TKey> comparer)
+        {
+            _comparer = comparer ?? EqualityComparer<TKey>.Default;
+            _groupings = new Grouping<TKey, TElement>[7];
+        }
+
+        public int Count
+        {
+            get { return _count; }
+        }
+
+        public IEnumerable<TElement> this[TKey key]
+        {
+            get
+            {
+                Grouping<TKey, TElement> grouping = GetGrouping(key, create: false);
+                if (grouping != null)
+                {
+                    return grouping;
+                }
+
+#if NO_ARRAY_EMPTY
+                return EmptyArray<TElement>.Value;
+#else
+                return Array.Empty<TElement>();
+#endif
+            }
+        }
+
+        public bool Contains(TKey key)
+        {
+            return GetGrouping(key, create: false) != null;
+        }
+
+        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
+        {
+            Grouping<TKey, TElement> g = _lastGrouping;
+            if (g != null)
+            {
+                do
+                {
+                    g = g._next;
+                    yield return g;
+                }
+                while (g != _lastGrouping);
+            }
+        }
+
+        internal TResult[] ToArray<TResult>(Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
+        {
+            TResult[] array = new TResult[_count];
+            int index = 0;
+            Grouping<TKey, TElement> g = _lastGrouping;
+            if (g != null)
+            {
+                do
+                {
+                    g = g._next;
+                    g.Trim();
+                    array[index] = resultSelector(g._key, g._elements);
+                    ++index;
+                }
+                while (g != _lastGrouping);
+            }
+
+            return array;
+        }
+
+
+        internal List<TResult> ToList<TResult>(Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
+        {
+            List<TResult> list = new List<TResult>(_count);
+            Grouping<TKey, TElement> g = _lastGrouping;
+            if (g != null)
+            {
+                do
+                {
+                    g = g._next;
+                    g.Trim();
+                    list.Add(resultSelector(g._key, g._elements));
+                }
+                while (g != _lastGrouping);
+            }
+
+            return list;
+        }
+
+        public IEnumerable<TResult> ApplyResultSelector<TResult>(Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
+        {
+            Grouping<TKey, TElement> g = _lastGrouping;
+            if (g != null)
+            {
+                do
+                {
+                    g = g._next;
+                    g.Trim();
+                    yield return resultSelector(g._key, g._elements);
+                }
+                while (g != _lastGrouping);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        internal int InternalGetHashCode(TKey key)
+        {
+            // Handle comparer implementations that throw when passed null
+            return (key == null) ? 0 : _comparer.GetHashCode(key) & 0x7FFFFFFF;
+        }
+
+        internal Grouping<TKey, TElement> GetGrouping(TKey key, bool create)
+        {
+            int hashCode = InternalGetHashCode(key);
+            for (Grouping<TKey, TElement> g = _groupings[hashCode % _groupings.Length]; g != null; g = g._hashNext)
+            {
+                if (g._hashCode == hashCode && _comparer.Equals(g._key, key))
+                {
+                    return g;
+                }
+            }
+
+            if (create)
+            {
+                if (_count == _groupings.Length)
+                {
+                    Resize();
+                }
+
+                int index = hashCode % _groupings.Length;
+                Grouping<TKey, TElement> g = new Grouping<TKey, TElement>();
+                g._key = key;
+                g._hashCode = hashCode;
+                g._elements = new TElement[1];
+                g._hashNext = _groupings[index];
+                _groupings[index] = g;
+                if (_lastGrouping == null)
+                {
+                    g._next = g;
+                }
+                else
+                {
+                    g._next = _lastGrouping._next;
+                    _lastGrouping._next = g;
+                }
+
+                _lastGrouping = g;
+                _count++;
+                return g;
+            }
+
+            return null;
+        }
+
+        private void Resize()
+        {
+            int newSize = checked((_count * 2) + 1);
+            Grouping<TKey, TElement>[] newGroupings = new Grouping<TKey, TElement>[newSize];
+            Grouping<TKey, TElement> g = _lastGrouping;
+            do
+            {
+                g = g._next;
+                int index = g._hashCode % newSize;
+                g._hashNext = newGroupings[index];
+                newGroupings[index] = g;
+            }
+            while (g != _lastGrouping);
+
+            _groupings = newGroupings;
+        }
+    }
+
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/Strings.cs b/Ix.NET/Source/System.Interactive.Async/Strings.cs
index 3578ff1f8b..1fbcb54807 100644
--- a/Ix.NET/Source/System.Interactive.Async/Strings.cs
+++ b/Ix.NET/Source/System.Interactive.Async/Strings.cs
@@ -7,5 +7,6 @@ internal static class Strings
     {
         public static string NO_ELEMENTS = "Source sequence doesn't contain any elements.";
         public static string MORE_THAN_ONE_ELEMENT = "Source sequence contains more than one element.";
+        public static string NOT_SUPPORTED = "Specified method is not supported.";
     }
 }
diff --git a/Ix.NET/Source/System.Interactive.Async/TaskExt.cs b/Ix.NET/Source/System.Interactive.Async/TaskExt.cs
index 009a8024bd..cd584fbda4 100644
--- a/Ix.NET/Source/System.Interactive.Async/TaskExt.cs
+++ b/Ix.NET/Source/System.Interactive.Async/TaskExt.cs
@@ -1,30 +1,15 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information. 
-using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace System.Threading.Tasks
 {
     static class TaskExt
     {
-        public static readonly Task<bool> True;
-        public static readonly Task<bool> False;
-
-        static TaskExt()
-        {
-            True = Return(true);
-            False = Return(false);
-        }
-
-        public static Task<T> Return<T>(T value)
-        {
-            var tcs = new TaskCompletionSource<T>();
-            tcs.TrySetResult(value);
-            return tcs.Task;
-        }
-
+        public static readonly Task<bool> True = Task.FromResult(true);
+        public static readonly Task<bool> False = Task.FromResult(false);
+        
         public static Task<T> Throw<T>(Exception exception)
         {
             var tcs = new TaskCompletionSource<T>();
@@ -32,98 +17,8 @@ public static Task<T> Throw<T>(Exception exception)
             return tcs.Task;
         }
 
-        public static void Handle<T, R>(this Task<T> task, TaskCompletionSource<R> tcs, Action<T> success)
-        {
-            if (task.IsFaulted)
-                tcs.TrySetException(task.Exception.InnerExceptions);
-            else if (task.IsCanceled)
-                tcs.TrySetCanceled();
-            else if (task.IsCompleted)
-                success(task.Result);
-        }
-
-        public static void Handle<T, R>(this Task<T> task, TaskCompletionSource<R> tcs, Action<T> success, Action<AggregateException> error)
-        {
-            if (task.IsFaulted)
-                error(task.Exception);
-            else if (task.IsCanceled)
-                tcs.TrySetCanceled();
-            else if (task.IsCompleted)
-                success(task.Result);
-        }
-
-        public static void Handle<T, R>(this Task<T> task, TaskCompletionSource<R> tcs, Action<T> success, Action<AggregateException> error, Action canceled)
-        {
-            if (task.IsFaulted)
-                error(task.Exception);
-            else if (task.IsCanceled)
-                canceled();
-            else if (task.IsCompleted)
-                success(task.Result);
-        }
-
-        public static Task Then<T>(this Task<T> task, Action<Task<T>> continuation)
-        {
-            //
-            // Central location to deal with continuations; allows for experimentation with flags.
-            // Note that right now, we don't go for synchronous execution. Users can block on the
-            // task returned from MoveNext, which can cause deadlocks (e.g. typical uses of GroupBy
-            // involve some aggregate). We'd need deeper asynchrony to make this work with less
-            // spawning of tasks.
-            //
-            return task.ContinueWith(continuation);
-        }
-
-        public static Task<R> Then<T, R>(this Task<T> task, Func<Task<T>, R> continuation)
-        {
-            //
-            // See comment on Then<T> for rationale.
-            //
-            return task.ContinueWith(continuation);
-        }
-
-        public static Task<bool> UsingEnumerator(this Task<bool> task, IDisposable disposable)
-        {
-            return task.Finally(() =>
-            {
-                if (task.IsFaulted || task.IsCanceled || !task.Result)
-                    disposable.Dispose();
-            });
-        }
-
-        public static Task<R> Finally<R>(this Task<R> task, Action action)
-        {
-            var tcs = new TaskCompletionSource<R>();
-
-            task.ContinueWith(t =>
-            {
-                try
-                {
-                    action();
-                }
-                finally
-                {
-                    switch (t.Status)
-                    {
-                        case TaskStatus.Canceled:
-                            tcs.SetCanceled();
-                            break;
-                        case TaskStatus.Faulted:
-                            tcs.SetException(t.Exception.InnerException);
-                            break;
-                        case TaskStatus.RanToCompletion:
-                            tcs.SetResult(t.Result);
-                            break;
-                    }
-                }
-            }, TaskContinuationOptions.ExecuteSynchronously);
-
-            return tcs.Task;
-        }
-
         public static Task<V> Zip<T, U, V>(this Task<T> t1, Task<U> t2, Func<T, U, V> f)
         {
-            var gate = new object();
             var tcs = new TaskCompletionSource<V>();
 
             var i = 2;
diff --git a/Ix.NET/Source/System.Interactive.Async/project.json b/Ix.NET/Source/System.Interactive.Async/project.json
index a09ce4ec6a..df3ca529ee 100644
--- a/Ix.NET/Source/System.Interactive.Async/project.json
+++ b/Ix.NET/Source/System.Interactive.Async/project.json
@@ -33,12 +33,33 @@
         "define": [
           "HAS_AWAIT",
           "HAS_APTCA",
+          "NO_ARRAY_EMPTY",
           "DESKTOPCLR",
           "DESKTOPCLR45"
         ]
       }
     },
+    "net46": {
+      "buildOptions": {
+        "define": [
+          "HAS_AWAIT",
+          "HAS_APTCA",
+          "DESKTOPCLR",
+          "DESKTOPCLR46"
+        ]
+      }
+    },
     "netstandard1.0": {
+      "buildOptions": {
+        "define": [
+          "HAS_AWAIT",
+          "NO_ARRAY_EMPTY",
+          "CRIPPLED_REFLECTION",
+          "PLIB"
+        ]
+      }
+    },
+    "netstandard1.3": {
       "buildOptions": {
         "define": [
           "HAS_AWAIT",
diff --git a/Ix.NET/Source/Tests/AsyncTests.Aggregates.cs b/Ix.NET/Source/Tests/AsyncTests.Aggregates.cs
index a38c738597..92ceef1c15 100644
--- a/Ix.NET/Source/Tests/AsyncTests.Aggregates.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.Aggregates.cs
@@ -6,37 +6,42 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Xunit;
 using System.Collections;
 using System.Threading;
+using System.Threading.Tasks;
+// ReSharper disable InvokeAsExtensionMethod
+// ReSharper disable InconsistentNaming
+// ReSharper disable RedundantTypeArgumentsOfMethod
 
 namespace Tests
 {
     public partial class AsyncTests
     {
+        private const int WaitTimeoutMs = 5000;
+
         [Fact]
-        public void Aggregate_Null()
+        public async Task Aggregate_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(null, (x, y) => x + y));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(null, (x, y) => x + y));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(null, 0, (x, y) => x + y));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(AsyncEnumerable.Return(42), 0, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(null, 0, (x, y) => x + y));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(AsyncEnumerable.Return(42), 0, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(null, 0, (x, y) => x + y, z => z));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, null, z => z));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(null, 0, (x, y) => x + y, z => z));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, null, z => z));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(null, (x, y) => x + y, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(null, (x, y) => x + y, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(null, 0, (x, y) => x + y, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(AsyncEnumerable.Return(42), 0, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(null, 0, (x, y) => x + y, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(AsyncEnumerable.Return(42), 0, null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(null, 0, (x, y) => x + y, z => z, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, null, z => z, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(null, 0, (x, y) => x + y, z => z, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, null, z => z, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null, CancellationToken.None));
         }
 
         [Fact]
@@ -52,7 +57,7 @@ public void Aggregate2()
         {
             var xs = new int[0].ToAsyncEnumerable();
             var ys = xs.Aggregate((x, y) => x * y);
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -61,7 +66,7 @@ public void Aggregate3()
             var ex = new Exception("Bang!");
             var xs = AsyncEnumerable.Throw<int>(ex);
             var ys = xs.Aggregate((x, y) => x * y);
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -70,7 +75,7 @@ public void Aggregate4()
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Aggregate((x, y) => { throw ex; });
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -95,7 +100,7 @@ public void Aggregate7()
             var ex = new Exception("Bang!");
             var xs = AsyncEnumerable.Throw<int>(ex);
             var ys = xs.Aggregate(1, (x, y) => x * y);
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -104,7 +109,7 @@ public void Aggregate8()
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Aggregate(1, (x, y) => { throw ex; });
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -129,7 +134,7 @@ public void Aggregate11()
             var ex = new Exception("Bang!");
             var xs = AsyncEnumerable.Throw<int>(ex);
             var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1);
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -138,7 +143,7 @@ public void Aggregate12()
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Aggregate(1, (x, y) => { throw ex; }, x => x + 1);
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -147,19 +152,19 @@ public void Aggregate13()
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Aggregate<int, int, int>(1, (x, y) => x * y, x => { throw ex; });
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void Count_Null()
+        public async Task Count_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Count<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Count<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -167,7 +172,7 @@ public void Count1()
         {
             Assert.Equal(new int[0].ToAsyncEnumerable().Count().Result, 0);
             Assert.Equal(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count().Result, 3);
-            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).Count().Wait());
+            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).Count().Wait(WaitTimeoutMs));
         }
 
         [Fact]
@@ -175,7 +180,7 @@ public void Count2()
         {
             Assert.Equal(new int[0].ToAsyncEnumerable().Count(x => x < 3).Result, 0);
             Assert.Equal(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => x < 3).Result, 2);
-            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).Count(x => x < 3).Wait());
+            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).Count(x => x < 3).Wait(WaitTimeoutMs));
         }
 
         [Fact]
@@ -183,19 +188,19 @@ public void Count3()
         {
             var ex = new Exception("Bang!");
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => { throw ex; });
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void LongCount_Null()
+        public async Task LongCount_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -203,7 +208,7 @@ public void LongCount1()
         {
             Assert.Equal(new int[0].ToAsyncEnumerable().LongCount().Result, 0);
             Assert.Equal(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount().Result, 3);
-            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).LongCount().Wait());
+            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).LongCount().Wait(WaitTimeoutMs));
         }
 
         [Fact]
@@ -211,7 +216,7 @@ public void LongCount2()
         {
             Assert.Equal(new int[0].ToAsyncEnumerable().LongCount(x => x < 3).Result, 0);
             Assert.Equal(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => x < 3).Result, 2);
-            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).LongCount(x => x < 3).Wait());
+            AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).LongCount(x => x < 3).Wait(WaitTimeoutMs));
         }
 
         [Fact]
@@ -219,17 +224,17 @@ public void LongCount3()
         {
             var ex = new Exception("Bang!");
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => { throw ex; });
-            AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void All_Null()
+        public async Task All_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.All<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.All<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.All<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.All<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -251,7 +256,7 @@ public void All3()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).All(x => x % 2 == 0);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -259,19 +264,19 @@ public void All4()
         {
             var ex = new Exception("Bang!");
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => { throw ex; });
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void Any_Null()
+        public async Task Any_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Any<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Any<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -293,7 +298,7 @@ public void Any3()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).Any(x => x % 2 == 0);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -301,7 +306,7 @@ public void Any4()
         {
             var ex = new Exception("Bang!");
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => { throw ex; });
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -319,15 +324,15 @@ public void Any6()
         }
 
         [Fact]
-        public void Contains_Null()
+        public async Task Contains_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(AsyncEnumerable.Return(42), 42, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(AsyncEnumerable.Return(42), 42, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(AsyncEnumerable.Return(42), 42, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(AsyncEnumerable.Return(42), 42, null, CancellationToken.None));
         }
 
         [Fact]
@@ -376,36 +381,36 @@ public int GetHashCode(int obj)
         }
 
         [Fact]
-        public void First_Null()
+        public async Task First_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.First<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.First<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.First<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
         public void First1()
         {
             var res = AsyncEnumerable.Empty<int>().First();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
         public void First2()
         {
             var res = AsyncEnumerable.Empty<int>().First(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
         public void First3()
         {
             var res = AsyncEnumerable.Return(42).First(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -427,7 +432,7 @@ public void First6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).First();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -435,7 +440,7 @@ public void First7()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).First(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -453,15 +458,15 @@ public void First9()
         }
 
         [Fact]
-        public void FirstOrDefault_Null()
+        public async Task FirstOrDefault_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -504,7 +509,7 @@ public void FirstOrDefault6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).FirstOrDefault();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -512,7 +517,7 @@ public void FirstOrDefault7()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).FirstOrDefault(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -537,36 +542,36 @@ public void FirstOrDefault10()
         }
 
         [Fact]
-        public void Last_Null()
+        public async Task Last_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Last<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Last<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
         public void Last1()
         {
             var res = AsyncEnumerable.Empty<int>().Last();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
         public void Last2()
         {
             var res = AsyncEnumerable.Empty<int>().Last(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
         public void Last3()
         {
             var res = AsyncEnumerable.Return(42).Last(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -588,7 +593,7 @@ public void Last6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).Last();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -596,7 +601,7 @@ public void Last7()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).Last(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -614,15 +619,15 @@ public void Last9()
         }
 
         [Fact]
-        public void LastOrDefault_Null()
+        public async Task LastOrDefault_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -665,7 +670,7 @@ public void LastOrDefault6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).LastOrDefault();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -673,7 +678,7 @@ public void LastOrDefault7()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).LastOrDefault(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -698,36 +703,36 @@ public void LastOrDefault10()
         }
 
         [Fact]
-        public void Single_Null()
+        public async Task Single_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Single<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Single<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
         public void Single1()
         {
             var res = AsyncEnumerable.Empty<int>().Single();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
         public void Single2()
         {
             var res = AsyncEnumerable.Empty<int>().Single(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
         public void Single3()
         {
             var res = AsyncEnumerable.Return(42).Single(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -749,7 +754,7 @@ public void Single6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).Single();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -757,14 +762,14 @@ public void Single7()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).Single(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
         public void Single8()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -778,19 +783,19 @@ public void Single9()
         public void Single10()
         {
             var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
-        public void SingleOrDefault_Null()
+        public async Task SingleOrDefault_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, x => true));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, x => true, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, x => true, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -833,7 +838,7 @@ public void SingleOrDefault6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).SingleOrDefault();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -841,14 +846,14 @@ public void SingleOrDefault7()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).SingleOrDefault(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
         public void SingleOrDefault8()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -869,24 +874,24 @@ public void SingleOrDefault10()
         public void SingleOrDefault11()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => true);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
-        public void ElementAt_Null()
+        public async Task ElementAt_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAt<int>(null, 0));
-            AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAt<int>(AsyncEnumerable.Return(42), -1));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ElementAt<int>(null, 0));
+            await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAt<int>(AsyncEnumerable.Return(42), -1));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAt<int>(null, 0, CancellationToken.None));
-            AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAt<int>(AsyncEnumerable.Return(42), -1, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ElementAt<int>(null, 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAt<int>(AsyncEnumerable.Return(42), -1, CancellationToken.None));
         }
 
         [Fact]
         public void ElementAt1()
         {
             var res = AsyncEnumerable.Empty<int>().ElementAt(0);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
         }
 
         [Fact]
@@ -900,7 +905,7 @@ public void ElementAt2()
         public void ElementAt3()
         {
             var res = AsyncEnumerable.Return<int>(42).ElementAt(1);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
         }
 
         [Fact]
@@ -914,7 +919,7 @@ public void ElementAt4()
         public void ElementAt5()
         {
             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(7);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
         }
 
         [Fact]
@@ -922,17 +927,17 @@ public void ElementAt6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).ElementAt(15);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void ElementAtOrDefault_Null()
+        public async Task ElementAtOrDefault_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAtOrDefault<int>(null, 0));
-            AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAtOrDefault<int>(AsyncEnumerable.Return(42), -1));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ElementAtOrDefault<int>(null, 0));
+            await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAtOrDefault<int>(AsyncEnumerable.Return(42), -1));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAtOrDefault<int>(null, 0, CancellationToken.None));
-            AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAtOrDefault<int>(AsyncEnumerable.Return(42), -1, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ElementAtOrDefault<int>(null, 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAtOrDefault<int>(AsyncEnumerable.Return(42), -1, CancellationToken.None));
         }
 
         [Fact]
@@ -975,14 +980,14 @@ public void ElementAtOrDefault6()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).ElementAtOrDefault(15);
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void ToList_Null()
+        public async Task ToList_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToList<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToList<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToList<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToList<int>(null, CancellationToken.None));
         }
 
         [Fact]
@@ -1006,14 +1011,14 @@ public void ToList3()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).ToList();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void ToArray_Null()
+        public async Task ToArray_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToArray<int>(null));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToArray<int>(null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToArray<int>(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToArray<int>(null, CancellationToken.None));
         }
 
         [Fact]
@@ -1037,43 +1042,43 @@ public void ToArray3()
         {
             var ex = new Exception("Bang!");
             var res = AsyncEnumerable.Throw<int>(ex).ToArray();
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void ToDictionary_Null()
+        public async Task ToDictionary_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), x => 0, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), x => 0, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None));
         }
 
         [Fact]
@@ -1089,7 +1094,7 @@ public void ToDictionary1()
         public void ToDictionary2()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
+            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
         }
 
         [Fact]
@@ -1105,7 +1110,7 @@ public void ToDictionary3()
         public void ToDictionary4()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, x => x + 1).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
+            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, x => x + 1).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
         }
 
         [Fact]
@@ -1121,7 +1126,7 @@ public void ToDictionary5()
         public void ToDictionary6()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, new Eq()).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
+            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, new Eq()).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
         }
 
         [Fact]
@@ -1134,39 +1139,39 @@ public void ToDictionary7()
         }
 
         [Fact]
-        public void ToLookup_Null()
+        public async Task ToLookup_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), x => 0, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), x => 0, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None));
         }
 
         [Fact]
@@ -1276,73 +1281,73 @@ public void ToLookup9()
         }
 
         [Fact]
-        public void Average_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), x => x));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
+        public async Task Average_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), x => x));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
         }
 
         [Fact]
@@ -1440,7 +1445,7 @@ public void Average11()
         {
             var xs = new int[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -1456,7 +1461,7 @@ public void Average13()
         {
             var xs = new long[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -1472,7 +1477,7 @@ public void Average15()
         {
             var xs = new double[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -1488,7 +1493,7 @@ public void Average17()
         {
             var xs = new float[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -1504,7 +1509,7 @@ public void Average19()
         {
             var xs = new decimal[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -1516,87 +1521,87 @@ public void Average20()
         }
 
         [Fact]
-        public void Min_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), x => x));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>), CancellationToken.None));
+        public async Task Min_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), x => x));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>), CancellationToken.None));
         }
 
         [Fact]
@@ -1699,87 +1704,87 @@ public void Min11()
         }
 
         [Fact]
-        public void Max_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), x => x));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>), CancellationToken.None));
+        public async Task Max_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), x => x));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>), CancellationToken.None));
         }
 
         [Fact]
@@ -1882,73 +1887,73 @@ public void Max11()
         }
 
         [Fact]
-        public void Sum_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), x => x));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
+        public async Task Sum_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), x => x));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
         }
 
         [Fact]
@@ -2042,21 +2047,21 @@ public void Sum10()
         }
 
         [Fact]
-        public void MinBy_Null()
+        public async Task MinBy_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>), CancellationToken.None));
         }
 
         [Fact]
@@ -2073,7 +2078,7 @@ public void MinBy2()
         {
             var xs = new int[0].ToAsyncEnumerable().MinBy(x => x / 2);
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -2082,7 +2087,7 @@ public void MinBy3()
             var ex = new Exception("Bang!");
             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 3) throw ex; return x; });
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2091,7 +2096,7 @@ public void MinBy4()
             var ex = new Exception("Bang!");
             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 4) throw ex; return x; });
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2100,25 +2105,25 @@ public void MinBy5()
             var ex = new Exception("Bang!");
             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw<int>(ex)).MinBy(x => x, Comparer<int>.Default);
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void MaxBy_Null()
+        public async Task MaxBy_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>)));
-                                                                      
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>)));
                                                                       
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>)));
                                                                       
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), CancellationToken.None));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>), CancellationToken.None));
         }
 
         [Fact]
@@ -2135,7 +2140,7 @@ public void MaxBy2()
         {
             var xs = new int[0].ToAsyncEnumerable().MaxBy(x => x / 2);
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
         }
 
         [Fact]
@@ -2144,7 +2149,7 @@ public void MaxBy3()
             var ex = new Exception("Bang!");
             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 3) throw ex; return x; });
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2153,7 +2158,7 @@ public void MaxBy4()
             var ex = new Exception("Bang!");
             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 4) throw ex; return x; });
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2162,7 +2167,7 @@ public void MaxBy5()
             var ex = new Exception("Bang!");
             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw<int>(ex)).MaxBy(x => x, Comparer<int>.Default);
 
-            AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
     }
 }
diff --git a/Ix.NET/Source/Tests/AsyncTests.Bugs.cs b/Ix.NET/Source/Tests/AsyncTests.Bugs.cs
index a77f853a75..5a47249d2c 100644
--- a/Ix.NET/Source/Tests/AsyncTests.Bugs.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.Bugs.cs
@@ -157,7 +157,7 @@ public void CorrectCancel()
 
             try
             {
-                t.Wait();
+                t.Wait(WaitTimeoutMs);
             }
             catch
             {
@@ -191,7 +191,7 @@ public void CanCancelMoveNext()
 
             try
             {
-                t.Wait();
+                t.Wait(WaitTimeoutMs);
                 Assert.True(false);
             }
             catch
diff --git a/Ix.NET/Source/Tests/AsyncTests.Conversions.cs b/Ix.NET/Source/Tests/AsyncTests.Conversions.cs
index c137a7a3f7..bee6a767e9 100644
--- a/Ix.NET/Source/Tests/AsyncTests.Conversions.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.Conversions.cs
@@ -40,7 +40,7 @@ public void ToAsyncEnumerable2()
             var xs = ToAsyncEnumerable_Sequence(ex).ToAsyncEnumerable();
             var e = xs.GetEnumerator();
             HasNext(e, 42);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
         private IEnumerable<int> ToAsyncEnumerable_Sequence(Exception e)
@@ -95,7 +95,7 @@ public void ToAsyncEnumerable4()
 
             Assert.True(subscribed);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -121,7 +121,7 @@ public void ToAsyncEnumerable_With_Faulted_Task()
             var xs = tcs.Task.ToAsyncEnumerable();
             var e = xs.GetEnumerator();
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -133,7 +133,7 @@ public void ToAsyncEnumerable_With_Canceled_Task()
             var xs = tcs.Task.ToAsyncEnumerable();
             var e = xs.GetEnumerator();
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() is TaskCanceledException);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() is TaskCanceledException);
         }
 
         class MyObservable<T> : IObservable<T>
diff --git a/Ix.NET/Source/Tests/AsyncTests.Creation.cs b/Ix.NET/Source/Tests/AsyncTests.Creation.cs
index 127d500fca..1e9e7e755b 100644
--- a/Ix.NET/Source/Tests/AsyncTests.Creation.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.Creation.cs
@@ -71,7 +71,7 @@ public void Throw()
             var xs = AsyncEnumerable.Throw<int>(ex);
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
             AssertThrows<InvalidOperationException>(() => Nop(e.Current));
         }
 
@@ -207,7 +207,7 @@ public void Generate2()
             var xs = AsyncEnumerable.Generate(0, x => { throw ex; }, x => x + 1, x => x * x);
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -218,7 +218,7 @@ public void Generate3()
 
             var e = xs.GetEnumerator();
             HasNext(e, 0);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -229,7 +229,7 @@ public void Generate4()
 
             var e = xs.GetEnumerator();
             HasNext(e, 0);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -354,7 +354,7 @@ public void Using5()
             var e = xs.GetEnumerator();
             Assert.Equal(1, i);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
 
             Assert.True(disposed.Task.Result);
         }
@@ -388,7 +388,7 @@ public void Using6()
 
             try
             {
-                t.Wait();
+                t.Wait(WaitTimeoutMs);
             }
             catch (AggregateException ex)
             {
diff --git a/Ix.NET/Source/Tests/AsyncTests.Exceptions.cs b/Ix.NET/Source/Tests/AsyncTests.Exceptions.cs
index ac41331130..931e60a4fb 100644
--- a/Ix.NET/Source/Tests/AsyncTests.Exceptions.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.Exceptions.cs
@@ -114,7 +114,7 @@ public void Catch4()
             HasNext(e, 2);
             HasNext(e, 3);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
 
             Assert.False(err);
         }
@@ -135,7 +135,7 @@ public void Catch5()
             HasNext(e, 2);
             HasNext(e, 3);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex2);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex2);
         }
 
         [Fact]
@@ -162,7 +162,7 @@ public void Catch6()
             HasNext(e, 2);
             HasNext(e, 3);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -233,7 +233,7 @@ public void Catch10()
             HasNext(e, 2);
             HasNext(e, 3);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
         }
 
         private IEnumerable<IAsyncEnumerable<int>> CatchXss()
@@ -259,7 +259,7 @@ public void Catch11()
             HasNext(e, 2);
             HasNext(e, 3);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -323,7 +323,7 @@ public void Finally3()
             var e = xs.GetEnumerator();
 
             Assert.False(b);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
 
             Assert.True(b);
         }
@@ -379,7 +379,7 @@ public void Finally6()
 
             var t = e.MoveNext(cts.Token);
             cts.Cancel();
-            t.Wait();
+            t.Wait(WaitTimeoutMs);
 
             Assert.True(b);
         }
@@ -467,7 +467,7 @@ public void OnErrorResumeNext10()
             HasNext(e, 2);
             HasNext(e, 3);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
         }
 
         private IEnumerable<IAsyncEnumerable<int>> OnErrorResumeNextXss()
diff --git a/Ix.NET/Source/Tests/AsyncTests.Multiple.cs b/Ix.NET/Source/Tests/AsyncTests.Multiple.cs
index 58e4f50ab2..8b86235710 100644
--- a/Ix.NET/Source/Tests/AsyncTests.Multiple.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.Multiple.cs
@@ -9,6 +9,7 @@
 using System.Text;
 using Xunit;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace Tests
 {
@@ -48,7 +49,7 @@ public void Concat2()
             HasNext(e, 1);
             HasNext(e, 2);
             HasNext(e, 3);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -58,7 +59,7 @@ public void Concat3()
             var ys = AsyncEnumerable.Throw<int>(ex).Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable());
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -98,7 +99,7 @@ public void Concat5()
             HasNext(e, 3);
             HasNext(e, 4);
             HasNext(e, 5);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -112,7 +113,7 @@ public void Concat6()
             HasNext(e, 3);
             HasNext(e, 4);
             HasNext(e, 5);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
         }
 
         static IEnumerable<IAsyncEnumerable<int>> ConcatXss()
@@ -181,7 +182,7 @@ public void Zip4()
             var res = xs.Zip(ys, (x, y) => x * y);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -193,7 +194,7 @@ public void Zip5()
             var res = xs.Zip(ys, (x, y) => x * y);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -205,7 +206,7 @@ public void Zip6()
             var res = xs.Zip(ys, (x, y) => { if (x > 0) throw ex; return x * y; });
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -324,21 +325,21 @@ public void Except2()
         }
 
         [Fact]
-        public void SequenceEqual_Null()
+        public async Task SequenceEqual_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq()));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq()));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq()));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq()));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq(), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq(), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq(), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq(), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
         [Fact]
@@ -392,7 +393,7 @@ public void SequenceEqual6()
             var ys = AsyncEnumerable.Throw<int>(ex);
             var res = xs.SequenceEqual(ys);
 
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -403,7 +404,7 @@ public void SequenceEqual7()
             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys);
 
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -457,7 +458,7 @@ public void SequenceEqual13()
             var ys = AsyncEnumerable.Throw<int>(ex);
             var res = xs.SequenceEqual(ys, new Eq());
 
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -468,7 +469,7 @@ public void SequenceEqual14()
             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
 
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -486,7 +487,7 @@ public void SequenceEqual16()
             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new EqEx());
-            AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
+            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
         }
 
         class EqEx : IEqualityComparer<int>
@@ -559,7 +560,7 @@ public void GroupJoin3()
             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -572,7 +573,7 @@ public void GroupJoin4()
             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -585,7 +586,7 @@ public void GroupJoin5()
             var res = xs.GroupJoin(ys, x => { throw ex; }, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -598,7 +599,7 @@ public void GroupJoin6()
             var res = xs.GroupJoin(ys, x => x % 3, y => { throw ex; }, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -616,7 +617,7 @@ public void GroupJoin7()
 
             var e = res.GetEnumerator();
             HasNext(e, "0 - 36");
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -704,7 +705,7 @@ public void Join5()
             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -717,7 +718,7 @@ public void Join6()
             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -730,7 +731,7 @@ public void Join7()
             var res = xs.Join(ys, x => { throw ex; }, y => y, (x, y) => x + y);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -743,7 +744,7 @@ public void Join8()
             var res = xs.Join(ys, x => x, y => { throw ex; }, (x, y) => x + y);
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -756,7 +757,7 @@ public void Join9()
             var res = xs.Join<int, int, int, int>(ys, x => x, y => y, (x, y) => { throw ex; });
 
             var e = res.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
diff --git a/Ix.NET/Source/Tests/AsyncTests.Single.cs b/Ix.NET/Source/Tests/AsyncTests.Single.cs
index fdc5956f26..ab21d77b74 100644
--- a/Ix.NET/Source/Tests/AsyncTests.Single.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.Single.cs
@@ -9,6 +9,7 @@
 using System.Text;
 using Xunit;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace Tests
 {
@@ -56,7 +57,7 @@ public void Select3()
             var ys = xs.Select(x => 1 / x);
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
         }
 
         [Fact]
@@ -66,7 +67,7 @@ public void Select4()
             var ys = xs.Select((x, i) => 1 / i);
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
         }
 
         [Fact]
@@ -118,7 +119,7 @@ public void Where3()
             HasNext(e, 8);
             HasNext(e, 5);
             HasNext(e, 7);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -132,7 +133,7 @@ public void Where4()
             HasNext(e, 8);
             HasNext(e, 5);
             HasNext(e, 7);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -143,7 +144,7 @@ public void Where5()
             var ys = xs.Where(x => true);
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -154,7 +155,7 @@ public void Where6()
 
             var ys = xs.Where((x, i) => true);
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -206,7 +207,7 @@ public void SelectMany2()
             HasNext(e, 0);
             HasNext(e, 0);
             HasNext(e, 1);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -217,7 +218,7 @@ public void SelectMany3()
             var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable());
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -237,7 +238,7 @@ public void SelectMany4()
             HasNext(e, 0);
             HasNext(e, 0);
             HasNext(e, 1);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -273,7 +274,7 @@ public void SelectMany6()
             HasNext(e, 0);
             HasNext(e, 0);
             HasNext(e, 1);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -284,7 +285,7 @@ public void SelectMany7()
             var ys = xs.SelectMany((x, i) => Enumerable.Range(0, x).ToAsyncEnumerable());
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -304,7 +305,7 @@ public void SelectMany8()
             HasNext(e, 0);
             HasNext(e, 0);
             HasNext(e, 1);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -356,7 +357,7 @@ public void SelectMany11()
             HasNext(e, 6);
             HasNext(e, 8);
             HasNext(e, 9);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -375,7 +376,7 @@ public void SelectMany12()
             HasNext(e, 3);
             HasNext(e, 8);
             HasNext(e, 10);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -484,7 +485,7 @@ public void Do2()
             var ys = xs.Do(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -544,11 +545,11 @@ public void Do5()
             var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; }, () => { done = true; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ex_.InnerException == ex);
 
             Assert.False(hasv);
             Assert.False(done);
-            Assert.Same(((AggregateException)exa).Flatten().InnerExceptions.Single(), ex);
+            Assert.Same(exa, ex);
         }
 
         [Fact]
@@ -561,24 +562,24 @@ public void Do6()
             var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ex_.InnerException == ex);
 
             Assert.False(hasv);
-            Assert.Same(((AggregateException)exa).Flatten().InnerExceptions.Single(), ex);
+            Assert.Same(exa, ex);
         }
 
         [Fact]
-        public void ForEachAsync_Null()
+        public async Task ForEachAsync_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, x => { }));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, (x, i) => { }));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int, int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, x => { }));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, (x, i) => { }));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, x => { }, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int>), CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, (x, i) => { }, CancellationToken.None));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int, int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, x => { }, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, (x, i) => { }, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int, int>), CancellationToken.None));
         }
 
         [Fact]
@@ -601,7 +602,7 @@ public void ForEachAsync1()
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            xs.ForEachAsync(x => sum += x).Wait();
+            xs.ForEachAsync(x => sum += x).Wait(WaitTimeoutMs);
             Assert.Equal(10, sum);
         }
 
@@ -631,7 +632,7 @@ public void ForEach2()
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            xs.ForEachAsync((x, i) => sum += x * i).Wait();
+            xs.ForEachAsync((x, i) => sum += x * i).Wait(WaitTimeoutMs);
             Assert.Equal(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum);
         }
 
@@ -641,7 +642,7 @@ public void ForEachAsync3()
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            AssertThrows<Exception>(() => xs.ForEachAsync(x => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.ForEachAsync(x => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -659,7 +660,7 @@ public void ForEachAsync4()
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            AssertThrows<Exception>(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -677,7 +678,7 @@ public void ForEachAsync5()
             var ex = new Exception("Bang");
             var xs = AsyncEnumerable.Throw<int>(ex);
 
-            AssertThrows<Exception>(() => xs.ForEachAsync(x => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.ForEachAsync(x => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -695,7 +696,7 @@ public void ForEachAsync6()
             var ex = new Exception("Bang");
             var xs = AsyncEnumerable.Throw<int>(ex);
 
-            AssertThrows<Exception>(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -758,7 +759,7 @@ public void Take4()
             var ys = xs.Take(2);
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -826,7 +827,7 @@ public void TakeWhile5()
             var ys = xs.TakeWhile(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -873,7 +874,7 @@ public void TakeWhile9()
             var ys = xs.TakeWhile((x, i) => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -927,7 +928,7 @@ public void Skip4()
             var ys = xs.Skip(2);
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -998,7 +999,7 @@ public void SkipWhile5()
             var ys = xs.SkipWhile(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1045,7 +1046,7 @@ public void SkipWhile9()
             var ys = xs.SkipWhile((x, i) => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1128,7 +1129,7 @@ public void DefaultIfEmpty7()
             var xs = AsyncEnumerable.Throw<int>(ex).DefaultIfEmpty();
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1138,7 +1139,7 @@ public void DefaultIfEmpty8()
             var xs = AsyncEnumerable.Throw<int>(ex).DefaultIfEmpty(24);
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1225,7 +1226,7 @@ public void Reverse4()
             var ys = xs.Reverse();
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1282,7 +1283,7 @@ public void OrderBy2()
             var ys = xs.OrderBy<int, int>(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1293,7 +1294,7 @@ public void ThenBy2()
             var ys = xs.OrderBy<int, int>(x => x).ThenBy<int, int>(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1316,7 +1317,7 @@ public void OrderByDescending2()
             var ys = xs.OrderByDescending<int, int>(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1327,7 +1328,7 @@ public void ThenByDescending2()
             var ys = xs.OrderBy<int, int>(x => x).ThenByDescending<int, int>(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1578,7 +1579,7 @@ public void GroupBy4()
             var ys = xs.GroupBy(x => x);
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1601,9 +1602,9 @@ public void GroupBy5()
             var g2e = g2.GetEnumerator();
             HasNext(g2e, 43);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
-            AssertThrows<Exception>(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
-            AssertThrows<Exception>(() => g2e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrows<Exception>(() => g2e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
         }
 
         [Fact]
@@ -1619,9 +1620,9 @@ public void GroupBy6()
             Assert.Equal(g1.Key, 42);
             var g1e = g1.GetEnumerator();
             HasNext(g1e, 42);
-            AssertThrows<Exception>(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");           
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");           
         }
 
         static IEnumerable<int> GetXs()
@@ -1639,7 +1640,7 @@ public void GroupBy7()
             var ys = xs.GroupBy<int, int>(x => { throw ex; });
 
             var e = ys.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1663,9 +1664,9 @@ public void GroupBy8()
             var g2e = g2.GetEnumerator();
             HasNext(g2e, 2);
 
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
-            AssertThrows<Exception>(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
-            AssertThrows<Exception>(() => g2e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => g2e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -1941,7 +1942,7 @@ public int GetHashCode(int obj)
         [Fact]
         public void AsAsyncEnumerable_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.AsAsyncEnumerable<int>(null));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.AsAsyncEnumerable<int>((IAsyncEnumerable<int>)null));
         }
 
         [Fact]
@@ -2032,7 +2033,7 @@ public void RepeatSeq4()
             var xs = new FailRepeat().ToAsyncEnumerable().Repeat();
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
         }
 
         [Fact]
@@ -2041,7 +2042,7 @@ public void RepeatSeq5()
             var xs = new FailRepeat().ToAsyncEnumerable().Repeat(3);
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
         }
 
         class FailRepeat : IEnumerable<int>
@@ -2103,7 +2104,7 @@ public void IgnoreElements4()
             var xs = AsyncEnumerable.Throw<int>(ex).IgnoreElements();
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2145,7 +2146,7 @@ public void StartWith3()
             var e = xs.GetEnumerator();
             HasNext(e, 1);
             HasNext(e, 2);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2271,7 +2272,7 @@ public void DistinctUntilChanged3()
             HasNext(e, 1);
             HasNext(e, 2);
             HasNext(e, 3);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2304,7 +2305,7 @@ public void Expand2()
             var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => { throw ex; });
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2315,7 +2316,7 @@ public void Expand3()
             var e = xs.GetEnumerator();
             HasNext(e, 2);
             HasNext(e, 3);
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NullReferenceException);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NullReferenceException);
         }
 
         [Fact]
@@ -2358,7 +2359,7 @@ public void Scan3()
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => { throw ex; });
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2368,7 +2369,7 @@ public void Scan4()
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => { throw ex; });
 
             var e = xs.GetEnumerator();
-            AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+            AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
         [Fact]
@@ -2432,7 +2433,7 @@ public void TakeLast_BugFix_TakeLast_Zero_TakesForever()
             new int[] { 1, 2, 3, 4 }.ToAsyncEnumerable()
                 .TakeLast(0)
                 .ForEachAsync(_ => { isSet = true; })
-                .Wait();
+                .Wait(WaitTimeoutMs);
 
             Assert.False(isSet);
 
diff --git a/Ix.NET/Source/Tests/AsyncTests.cs b/Ix.NET/Source/Tests/AsyncTests.cs
index c7fb76c35e..5aa5fa9491 100644
--- a/Ix.NET/Source/Tests/AsyncTests.cs
+++ b/Ix.NET/Source/Tests/AsyncTests.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Tests
@@ -19,6 +20,13 @@ public void AssertThrows<E>(Action a)
             Assert.Throws<E>(a);
         }
 
+        [Obsolete("Don't use this, use Assert.ThrowsAsync and await it", true)]
+        public Task AssertThrows<E>(Func<Task> func)
+            where E : Exception
+        {
+            return Assert.ThrowsAsync<E>(func);
+        }
+
         public void AssertThrows<E>(Action a, Func<E, bool> assert)
             where E : Exception
         {