Generating Sum operators.

Ix.NET/Source/System.Interactive.Async/Sum.cs → Ix.NET/Source/System.Interactive.Async/Sum.Generated.cs

@@ -2,9 +2,7 @@
 // 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;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -12,221 +10,220 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
-        public static Task<int> Sum(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
+        public static Task<int> Sum(this IAsyncEnumerable<int> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return source.Aggregate(0, (x, y) => x + y, cancellationToken);
+            return source.Aggregate(0, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<long> Sum(this IAsyncEnumerable<long> source, CancellationToken cancellationToken)
+        public static Task<int> Sum(this IAsyncEnumerable<int> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return source.Aggregate(0L, (x, y) => x + y, cancellationToken);
+            return source.Aggregate(0, (x, y) => x + y, cancellationToken);
         }
 
-        public static Task<double> Sum(this IAsyncEnumerable<double> source, CancellationToken cancellationToken)
+        public static Task<int> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return source.Aggregate(0.0, (x, y) => x + y, cancellationToken);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<float> Sum(this IAsyncEnumerable<float> source, CancellationToken cancellationToken)
+        public static Task<int> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return source.Aggregate(0f, (x, y) => x + y, cancellationToken);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
+        public static Task<long> Sum(this IAsyncEnumerable<long> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return source.Aggregate(0m, (x, y) => x + y, cancellationToken);
+            return source.Aggregate(0L, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<int?> Sum(this IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
+        public static Task<long> Sum(this IAsyncEnumerable<long> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return source.Aggregate((int?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            return source.Aggregate(0L, (x, y) => x + y, cancellationToken);
         }
 
-        public static Task<long?> Sum(this IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
+        public static Task<long> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return source.Aggregate((long?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<double?> Sum(this IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
+        public static Task<long> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return source.Aggregate((double?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<float?> Sum(this IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
+        public static Task<float> Sum(this IAsyncEnumerable<float> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return source.Aggregate((float?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            return source.Aggregate(0.0f, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<decimal?> Sum(this IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
+        public static Task<float> Sum(this IAsyncEnumerable<float> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return source.Aggregate((decimal?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
+            return source.Aggregate(0.0f, (x, y) => x + y, cancellationToken);
         }
 
-        public static Task<int> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
+        public static Task<float> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<long> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
+        public static Task<float> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<double> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
+        public static Task<double> Sum(this IAsyncEnumerable<double> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Aggregate(0.0, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<float> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
+        public static Task<double> Sum(this IAsyncEnumerable<double> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Aggregate(0.0, (x, y) => x + y, cancellationToken);
         }
 
-        public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
+        public static Task<double> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<int?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
+        public static Task<double> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<long?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
+        public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Aggregate(0m, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<double?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
+        public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Aggregate(0m, (x, y) => x + y, cancellationToken);
         }
 
-
-        public static Task<int> Sum(this IAsyncEnumerable<int> source)
+        public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, CancellationToken.None);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<long> Sum(this IAsyncEnumerable<long> source)
+        public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, CancellationToken.None);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<double> Sum(this IAsyncEnumerable<double> source)
+        public static Task<int?> Sum(this IAsyncEnumerable<int?> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Sum(source, CancellationToken.None);
+            return source.Aggregate((int?)0, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<float> Sum(this IAsyncEnumerable<float> source)
+        public static Task<int?> Sum(this IAsyncEnumerable<int?> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Sum(source, CancellationToken.None);
+            return source.Aggregate((int?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
 
-        public static Task<decimal> Sum(this IAsyncEnumerable<decimal> source)
+        public static Task<int?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, CancellationToken.None);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<int?> Sum(this IAsyncEnumerable<int?> source)
+        public static Task<int?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, CancellationToken.None);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
         public static Task<long?> Sum(this IAsyncEnumerable<long?> source)
@@ -234,143 +231,133 @@ namespace System.Linq
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Sum(source, CancellationToken.None);
+            return source.Aggregate((long?)0L, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<double?> Sum(this IAsyncEnumerable<double?> source)
+        public static Task<long?> Sum(this IAsyncEnumerable<long?> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
 
-            return Sum(source, CancellationToken.None);
+            return source.Aggregate((long?)0L, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
 
-        public static Task<float?> Sum(this IAsyncEnumerable<float?> source)
+        public static Task<long?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, CancellationToken.None);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<decimal?> Sum(this IAsyncEnumerable<decimal?> source)
+        public static Task<long?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, CancellationToken.None);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<int> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector)
+        public static Task<float?> Sum(this IAsyncEnumerable<float?> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Aggregate((float?)0.0f, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<long> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector)
+        public static Task<float?> Sum(this IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Aggregate((float?)0.0f, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
 
-        public static Task<double> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector)
+        public static Task<float?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<float> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector)
+        public static Task<float?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<decimal> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector)
+        public static Task<double?> Sum(this IAsyncEnumerable<double?> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Aggregate((double?)0.0, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<int?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector)
+        public static Task<double?> Sum(this IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Aggregate((double?)0.0, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
 
-        public static Task<long?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector)
+        public static Task<double?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
-        public static Task<double?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector)
+        public static Task<double?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Select(selector).Sum(cancellationToken);
         }
 
-        public static Task<float?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector)
+        public static Task<decimal?> Sum(this IAsyncEnumerable<decimal?> source)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Aggregate((decimal?)0m, (x, y) => x + y, CancellationToken.None);
         }
 
-        public static Task<decimal?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector)
+        public static Task<decimal?> Sum(this IAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
-            if (selector == null)
-                throw new ArgumentNullException(nameof(selector));
 
-            return Sum(source, selector, CancellationToken.None);
+            return source.Aggregate((decimal?)0m, (x, y) => x + y.GetValueOrDefault(), cancellationToken);
         }
 
-
-        public static Task<float?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
+        public static Task<decimal?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector)
         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Select(selector).Sum(CancellationToken.None);
         }
 
         public static Task<decimal?> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
@@ -380,8 +367,8 @@ namespace System.Linq
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return source.Select(selector)
-                         .Sum(cancellationToken);
+            return source.Select(selector).Sum(cancellationToken);
         }
+
     }
-}
+}

Ix.NET/Source/System.Interactive.Async/Sum.Generated.tt

@@ -0,0 +1,78 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+// 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.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerable
+    {
+<#
+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" },
+};
+
+foreach (var o in os)
+{
+    var n = o.type.EndsWith("?") ? ".GetValueOrDefault()" : "";
+#>
+        public static Task<<#=o.type#>> Sum(this IAsyncEnumerable<<#=o.type#>> source)
+        {
+            if (source == null)
+                throw new ArgumentNullException(nameof(source));
+
+            return source.Aggregate(<#=o.zero#>, (x, y) => x + y, CancellationToken.None);
+        }
+
+        public static Task<<#=o.type#>> Sum(this IAsyncEnumerable<<#=o.type#>> source, CancellationToken cancellationToken)
+        {
+            if (source == null)
+                throw new ArgumentNullException(nameof(source));
+
+            return source.Aggregate(<#=o.zero#>, (x, y) => x + y<#=n#>, cancellationToken);
+        }
+
+        public static Task<<#=o.type#>> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, <#=o.type#>> selector)
+        {
+            if (source == null)
+                throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
+
+            return source.Select(selector).Sum(CancellationToken.None);
+        }
+
+        public static Task<<#=o.type#>> Sum<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, <#=o.type#>> selector, CancellationToken cancellationToken)
+        {
+            if (source == null)
+                throw new ArgumentNullException(nameof(source));
+            if (selector == null)
+                throw new ArgumentNullException(nameof(selector));
+
+            return source.Select(selector).Sum(cancellationToken);
+        }
+
+<#
+}
+#>
+    }
+}

Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj

@@ -11,4 +11,31 @@
     <EmbeddedResource Include="Properties\System.Interactive.Async.rd.xml" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Include="Sum.Generated.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Sum.Generated.tt</DependentUpon>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Sum.Generated.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Sum.Generated.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Sum.Generated.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Sum.Generated.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
 </Project>