Sum of TimeSpans in C#

I have a collection of objects that include a TimeSpan variable:

MyObject
{ 
    TimeSpan TheDuration { get; set; }
}

I want to use LINQ to sum those times. Of course, (from r in MyCollection select r.TheDuration).Sum(); doesn't work!

I'm thinking of changing the datatype of TheDuration to an int and then summing it and converting the sum to a TimeSpan. That will be messy because each TheDuration in my collection is used in as a timespan somewhere else.

Any suggestion on this summation?

Unfortunately, there isn't a an overload of Sum that accepts an IEnumerable<TimeSpan>. Additionally, there's no current way of specifying operator-based generic constraints for type-parameters, so even though TimeSpan is "natively" summable, that fact can't be picked up easily by generic code.

One option would be to, as you say, sum up an integral-type equivalent to the timespan instead, and then turn that sum into a TimeSpan again. The ideal property for this is TimeSpan.Ticks, which round-trips accurately. But it's not necessary to change the property-type on your class at all; you can just project:

var totalSpan = new TimeSpan(myCollection.Sum(r => r.TheDuration.Ticks));

Alternatively, if you want to stick to the TimeSpan's + operator to do the summing, you can use the Aggregate operator:

var totalSpan = myCollection.Aggregate
                (TimeSpan.Zero, 
                (sumSoFar, nextMyObject) => sumSoFar + nextMyObject.TheDuration);

This works well (code based on Ani's answer)

public static class StatisticExtensions
{    
    public static TimeSpan Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, TimeSpan> selector)
    {
        return source.Select(selector).Aggregate(TimeSpan.Zero, (t1, t2) => t1 + t2);
    }
}

Usage :

If Periods is a list of objects with a Duration property

TimeSpan total = Periods.Sum(s => s.Duration)

I believe this is the cleanest LINQ extension:

public static class LinqExtensions
{
    public static TimeSpan Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, TimeSpan> func)
    {
        return new TimeSpan(source.Sum(item => func(item).Ticks));
    }
}

Usage is the same:

TimeSpan total = Periods.Sum(s => s.Duration)

Here's what I tried and it worked:

System.Collections.Generic.List<MyObject> collection = new List<MyObject>();
MyObject mb = new MyObject();
mb.TheDuration = new TimeSpan(100000);
collection.Add(mb);
mb.TheDuration = new TimeSpan(100000);
collection.Add(mb);
mb.TheDuration = new TimeSpan(100000);
collection.Add(mb);
var sum = (from r in collection select r.TheDuration.Ticks).Sum();
Console.WriteLine( sum.ToString());
//here we have new timespan that is sum of all time spans
TimeSpan sumedup = new TimeSpan(sum);


public class MyObject
{
    public TimeSpan TheDuration { get; set; }
}

I put this in a class to add an extension method to a collection of timespans:

public static class Extensions:
{
	public static TimeSpan TotalTime(this IEnumerable<TimeSpan> TheCollection)
	{
		int i = 0;
		int TotalSeconds = 0;

		var ArrayDuration = TheCollection.ToArray();

		for (i = 0; i < ArrayDuration.Length; i++)
		{
			TotalSeconds = (int)(ArrayDuration[i].TotalSeconds) + TotalSeconds;
		}

		return TimeSpan.FromSeconds(TotalSeconds);
	}
}

So now, I can write TotalDuration = (my LINQ query that returns a collection of timespan).TotalTime();

Voila!

This works for both a collection, and a property within a collection;

void Main()
{
	var periods = new[] {
		new TimeSpan(0, 10, 0),
		new TimeSpan(0, 10, 0),
		new TimeSpan(0, 10, 0),
	};
	TimeSpan total = periods.Sum();
	TimeSpan total2 = periods.Sum(p => p);
	
	Debug.WriteLine(total);
	Debug.WriteLine(total2);

    // output: 00:30:00
    // output: 00:30:00
}


public static class LinqExtensions
{
	public static TimeSpan Sum(this IEnumerable<TimeSpan> timeSpanCollection)
	{
		return timeSpanCollection.Sum(s => s);
	}

	public static TimeSpan Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, TimeSpan> func)
	{
		return new TimeSpan(source.Sum(item => func(item).Ticks));
	}
}

You can use .Aggregate rather than .Sum, and pass it a timespan-summing function that you write, like this:

    TimeSpan AddTimeSpans(TimeSpan a, TimeSpan b)
    {
        return a + b;
    }

Once you understand that timespans can't be summed and know to use Ticks, it seems to me that this extension to just convert a long into a timespan looks more linq-ee. I believe it lets the reader have a more readable view of the operation:

var times = new[] { new TimeSpan(0, 10, 0), new TimeSpan(0, 20, 0), new TimeSpan(0, 30, 0) };

times.Sum(p => p.Ticks)
     .ToTimeSpan();      // output: 01:00:00
     

Here is the one extension:

public static class LongExtensions
{
    public static TimeSpan ToTimeSpan(this long ticks)
        => new TimeSpan(ticks);
}

I created extension method for IEnumerable<TimeSpan>

public static class TimeSpanExtensions
{
    public static TimeSpan Sum(this IEnumerable<TimeSpan> source)
    {
        return source.Aggregate(TimeSpan.Zero, (subtotal, time) => subtotal.Add(time));
    }
}

Thanks to that I can use:

 IEnumerable<TimeSpan> times = new List<TimeSpan>();
 TimeSpan totalTime = times.Sum();