11,484,402 members (65,236 online)

# Cumulating values with LINQ

, 26 Jul 2012 CPOL 7.6K 55 4
 Rate this:
This tip describes few examples how ro cumulate values using an extension method with LINQ

## Introduction

Sometimes a cumulation of values is needed in a program. A typical example is calculation of cumulative sum. Here are few examples how to handle data cumulatively with LINQ.

## Cumulative sum

A typical need is to calculate a cumulative sum. The LINQ doesn't directly have a method to do this, but by building a small extension method, this can be easily done.

The following extension method calculates cumulative sum for decimal numbers:

```/// <summary>
/// Calculates a cumulative value for decimal numbers
/// </summary>
/// <param name="numbers">Numbers to sum</param>
/// <returns>Cumulative sum</returns>
public static System.Collections.Generic.IEnumerable<decimal> CumulativeSum(
this System.Collections.Generic.IEnumerable<decimal> numbers) {

decimal summedNumber = 0;

foreach (decimal number in numbers) {
summedNumber = summedNumber + number;
yield return summedNumber;
}
}```

The above code iterates through all the decimal numbers in the collection and for each iteration it calculates the current cumulative sum and returns it using the yield keyword.

To test the functionality let's sum some numbers:

```// Array of test numbers
decimal[] numbers = new decimal[] { 1, 3, 5, 7, 11 };

// Calculate and print the cumulative sum for the numbers
System.Diagnostics.Debug.WriteLine("The cumulative sum contains the following results");
foreach (decimal partialSum in numbers.CumulativeSum()) {
System.Diagnostics.Debug.WriteLine("   - {0}", partialSum);
}
System.Diagnostics.Debug.WriteLine("The cumulative sum total is {0}", numbers.CumulativeSum().Last());    ```

Running the code above would produce the following to the output window of Visual Studio:

```The cumulative sum contains the following results
- 1
- 4
- 9
- 16
- 27
The cumulative sum total is 27```

## Cumulating strings

Cumulating string values is basically the same as with numbers, so let's take a bit different kind of example.

Using the String.Split method it's easy to break a path into separate directories. But if you need to know all the valid paths in a given path, you can split the original path and then use a cumulative extension method to concatenate the directories.

```/// <summary>
/// Builds a cumulative path based on directory names
/// </summary>
/// <param name="pathPart">Individual directories</param>
/// <returns>Cumulated path</returns>
public static System.Collections.Generic.IEnumerable<string> CumulativePath(
this System.Collections.Generic.IEnumerable<string> pathPart) {
System.Text.StringBuilder concatenated = new System.Text.StringBuilder();

foreach (string part in pathPart) {
if (concatenated.Length != 0) {
concatenated.Append('\\');
}
concatenated.Append(part);
yield return concatenated.ToString();
}
}```

The idea is almost the same as with summing the numbers. The minor difference is that since now we're playing with paths, a path separator (`\`) is added between directories.

To test this, consider the following

```// Some random path
string somePath = @"C:\Some directory\Some subdirectory\Somefile.txt";

// Split the path and print out each cumulated portion of the path
System.Diagnostics.Debug.WriteLine("The path contains the following parts");
foreach (string partialPath in somePath.Split('\\').CumulativePath()) {
System.Diagnostics.Debug.WriteLine("   - '{0}'", new object[] { partialPath });
}```

Running this would produce the following output

```The path contains the following parts
- 'C:'
- 'C:\Some directory'
- 'C:\Some directory\Some subdirectory'
- 'C:\Some directory\Some subdirectory\Somefile.txt'```

For example if you have a path to a file and you want to test which of the directories are valid or accessible you could use a code like

```// Some partially existing path
string somePath2 = @"C:\Windows\Some non-existent directory\Some non-existent file.txt";

// Split the path and print out each cumulated portion of the path
System.Diagnostics.Debug.WriteLine("The path parts are valid as follows");
foreach (string partialPath in somePath2.Split('\\').AllButLast().CumulativePath()) {
System.Diagnostics.Debug.WriteLine("   - '{0}' does exist: {1}",
partialPath,
System.IO.Directory.Exists(partialPath));
}```

This would result to

```The path parts are valid as follows
- 'C:' does exist: True
- 'C:\Windows' does exist: True
- 'C:\Windows\Some non-existent directory' does exist: False```

## History

• July 26, 2012: Tip created.

## Share

Architect
Finland
I've been a programmer since mid 80's using languages like assembler, C/C++, PL/I (mainframe environment), pascal, VB (I know, I know, no comments please) and C# and utilizing different techniques and tools.

However I'm specialized in databases and database modeling. Mostly I have used products like Oracle (from version 6), SQL Server (from version 4.2), DB2 and Solid Server (nowadays an IBM product).

For the past 10+ years my main concerns have been dealing with different business processes and how to create software to implement and improve them. At my spare time (what ever that actually means) I'm also teaching and consulting on different areas of database management, development and database oriented software design.

 First Prev Next
 Message Removed killer_ism18-May-15 0:06 killer_ism 18-May-15 0:06
 My vote of 5 Maciej Los12-Apr-15 0:29 Maciej Los 12-Apr-15 0:29
 Re: My vote of 5 Mika Wendelius13-Apr-15 18:41 Mika Wendelius 13-Apr-15 18:41
 Neat example, illustration useful techniques Espen Harlinn30-Jul-12 12:26 Espen Harlinn 30-Jul-12 12:26
 My vote of 1 Jasper4C#29-Jul-12 22:25 Jasper4C# 29-Jul-12 22:25
 Re: My vote of 1 Mika Wendelius30-Jul-12 3:12 Mika Wendelius 30-Jul-12 3:12
 Linq Aggregation is already build in Jasper4C#29-Jul-12 22:25 Jasper4C# 29-Jul-12 22:25
 Re: Linq Aggregation is already build in Mika Wendelius30-Jul-12 3:10 Mika Wendelius 30-Jul-12 3:10
 Last Visit: 31-Dec-99 19:00     Last Update: 25-May-15 11:49 Refresh 1