Inline Sum implementations.

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs

@@ -66,20 +66,82 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<int> SumCore(IAsyncEnumerable<int> source, CancellationToken cancellationToken)
+        private static async Task<int> SumCore(IAsyncEnumerable<int> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate(0, (x, y) => x + y, cancellationToken);
+            var sum = 0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    checked
+                    {
+                        sum += e.Current;
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<int> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
+        private static async Task<int> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    checked
+                    {
+                        sum += value;
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<int> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<int>> selector, CancellationToken cancellationToken)
+        private static async Task<int> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<int>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    checked
+                    {
+                        sum += value;
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<long> Sum(this IAsyncEnumerable<long> source)
         {
             if (source == null)
@@ -136,20 +198,82 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<long> SumCore(IAsyncEnumerable<long> source, CancellationToken cancellationToken)
+        private static async Task<long> SumCore(IAsyncEnumerable<long> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate(0L, (x, y) => x + y, cancellationToken);
+            var sum = 0L;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    checked
+                    {
+                        sum += e.Current;
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<long> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
+        private static async Task<long> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0L;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    checked
+                    {
+                        sum += value;
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<long> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<long>> selector, CancellationToken cancellationToken)
+        private static async Task<long> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<long>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0L;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    checked
+                    {
+                        sum += value;
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<float> Sum(this IAsyncEnumerable<float> source)
         {
             if (source == null)
@@ -206,20 +330,73 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<float> SumCore(IAsyncEnumerable<float> source, CancellationToken cancellationToken)
+        private static async Task<float> SumCore(IAsyncEnumerable<float> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate(0.0f, (x, y) => x + y, cancellationToken);
+            var sum = 0.0f;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    sum += e.Current;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<float> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
+        private static async Task<float> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0f;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    sum += value;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<float> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<float>> selector, CancellationToken cancellationToken)
+        private static async Task<float> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<float>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0f;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    sum += value;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<double> Sum(this IAsyncEnumerable<double> source)
         {
             if (source == null)
@@ -276,20 +453,73 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<double> SumCore(IAsyncEnumerable<double> source, CancellationToken cancellationToken)
+        private static async Task<double> SumCore(IAsyncEnumerable<double> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate(0.0, (x, y) => x + y, cancellationToken);
+            var sum = 0.0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    sum += e.Current;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<double> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
+        private static async Task<double> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    sum += value;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<double> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<double>> selector, CancellationToken cancellationToken)
+        private static async Task<double> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<double>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    sum += value;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source)
         {
             if (source == null)
@@ -346,20 +576,73 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<decimal> SumCore(IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
+        private static async Task<decimal> SumCore(IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate(0m, (x, y) => x + y, cancellationToken);
+            var sum = 0m;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    sum += e.Current;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<decimal> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
+        private static async Task<decimal> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0m;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    sum += value;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<decimal> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<decimal>> selector, CancellationToken cancellationToken)
+        private static async Task<decimal> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<decimal>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0m;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    sum += value;
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<int?> Sum(this IAsyncEnumerable<int?> source)
         {
             if (source == null)
@@ -416,20 +699,82 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<int?> SumCore(IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
+        private static async Task<int?> SumCore(IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate((int?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            var sum = 0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    checked
+                    {
+                        sum += e.Current.GetValueOrDefault();
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<int?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
+        private static async Task<int?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    checked
+                    {
+                        sum += value.GetValueOrDefault();
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<int?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<int?>> selector, CancellationToken cancellationToken)
+        private static async Task<int?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<int?>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    checked
+                    {
+                        sum += value.GetValueOrDefault();
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<long?> Sum(this IAsyncEnumerable<long?> source)
         {
             if (source == null)
@@ -486,20 +831,82 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<long?> SumCore(IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
+        private static async Task<long?> SumCore(IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate((long?)0L, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            var sum = 0L;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    checked
+                    {
+                        sum += e.Current.GetValueOrDefault();
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<long?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
+        private static async Task<long?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0L;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    checked
+                    {
+                        sum += value.GetValueOrDefault();
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<long?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<long?>> selector, CancellationToken cancellationToken)
+        private static async Task<long?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<long?>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0L;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    checked
+                    {
+                        sum += value.GetValueOrDefault();
+                    }
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<float?> Sum(this IAsyncEnumerable<float?> source)
         {
             if (source == null)
@@ -556,20 +963,73 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<float?> SumCore(IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
+        private static async Task<float?> SumCore(IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate((float?)0.0f, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            var sum = 0.0f;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    sum += e.Current.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<float?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
+        private static async Task<float?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0f;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    sum += value.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<float?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<float?>> selector, CancellationToken cancellationToken)
+        private static async Task<float?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<float?>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0f;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    sum += value.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<double?> Sum(this IAsyncEnumerable<double?> source)
         {
             if (source == null)
@@ -626,20 +1086,73 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<double?> SumCore(IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
+        private static async Task<double?> SumCore(IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate((double?)0.0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            var sum = 0.0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    sum += e.Current.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<double?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
+        private static async Task<double?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    sum += value.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<double?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<double?>> selector, CancellationToken cancellationToken)
+        private static async Task<double?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<double?>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0.0;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    sum += value.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
         public static Task<decimal?> Sum(this IAsyncEnumerable<decimal?> source)
         {
             if (source == null)
@@ -696,19 +1209,72 @@ namespace System.Linq
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<decimal?> SumCore(IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
+        private static async Task<decimal?> SumCore(IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate((decimal?)0m, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            var sum = 0m;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    sum += e.Current.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<decimal?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
+        private static async Task<decimal?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0m;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+                    sum += value.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<decimal?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<decimal?>> selector, CancellationToken cancellationToken)
+        private static async Task<decimal?> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<decimal?>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = 0m;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+                    sum += value.GetValueOrDefault();
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
     }
 }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt

@@ -19,16 +19,16 @@ namespace System.Linq
 <#
 var os = new[]
 {
-    new { type = "int", zero = "0" },
-    new { type = "long", zero = "0L" },
-    new { type = "float", zero = "0.0f" },
-    new { type = "double", zero = "0.0" },
-    new { type = "decimal", zero = "0m" },
-    new { type = "int?", zero = "(int?)0" },
-    new { type = "long?", zero = "(long?)0L" },
-    new { type = "float?", zero = "(float?)0.0f" },
-    new { type = "double?", zero = "(double?)0.0" },
-    new { type = "decimal?", zero = "(decimal?)0m" },
+    new { type = "int", zero = "0", @checked = true },
+    new { type = "long", zero = "0L", @checked = true },
+    new { type = "float", zero = "0.0f", @checked = false },
+    new { type = "double", zero = "0.0", @checked = false },
+    new { type = "decimal", zero = "0m", @checked = false },
+    new { type = "int?", zero = "0", @checked = true },
+    new { type = "long?", zero = "0L", @checked = true },
+    new { type = "float?", zero = "0.0f", @checked = false },
+    new { type = "double?", zero = "0.0", @checked = false },
+    new { type = "decimal?", zero = "0m", @checked = false },
 };
 
 foreach (var o in os)
@@ -91,20 +91,121 @@ foreach (var o in os)
             return SumCore(source, selector, cancellationToken);
         }
 
-        private static Task<<#=o.type#>> SumCore(IAsyncEnumerable<<#=o.type#>> source, CancellationToken cancellationToken)
+        private static async Task<<#=o.type#>> SumCore(IAsyncEnumerable<<#=o.type#>> source, CancellationToken cancellationToken)
         {
-            return source.Aggregate(<#=o.zero#>, (x, y) => x + y<#=n#>, cancellationToken);
+            var sum = <#=o.zero#>;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+<#
+if (o.@checked)
+{
+#>
+                    checked
+                    {
+                        sum += e.Current<#=n#>;
+                    }
+<#
+}
+else
+{
+#>
+                    sum += e.Current<#=n#>;
+<#
+}
+#>
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<<#=o.type#>> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, <#=o.type#>> selector, CancellationToken cancellationToken)
+        private static async Task<<#=o.type#>> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, <#=o.type#>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = <#=o.zero#>;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = selector(e.Current);
+
+<#
+if (o.@checked)
+{
+#>
+                    checked
+                    {
+                        sum += value<#=n#>;
+                    }
+<#
+}
+else
+{
+#>
+                    sum += value<#=n#>;
+<#
+}
+#>
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
 
-        private static Task<<#=o.type#>> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<<#=o.type#>>> selector, CancellationToken cancellationToken)
+        private static async Task<<#=o.type#>> SumCore<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, Task<<#=o.type#>>> selector, CancellationToken cancellationToken)
         {
-            return source.Select(selector).Sum(cancellationToken);
+            var sum = <#=o.zero#>;
+
+            var e = source.GetAsyncEnumerator(cancellationToken);
+
+            try
+            {
+                while (await e.MoveNextAsync().ConfigureAwait(false))
+                {
+                    var value = await selector(e.Current).ConfigureAwait(false);
+
+<#
+if (o.@checked)
+{
+#>
+                    checked
+                    {
+                        sum += value<#=n#>;
+                    }
+<#
+}
+else
+{
+#>
+                    sum += value<#=n#>;
+<#
+}
+#>
+                }
+            }
+            finally
+            {
+                await e.DisposeAsync().ConfigureAwait(false);
+            }
+
+            return sum;
         }
+
 <#
 }
 #>