Summe der Zeitspannen in C #

Habe ich eine Sammlung von Objekten gehören, die einen TimeSpan-variable:

MyObject
{ 
    TimeSpan TheDuration { get; set; }
}

Möchte ich LINQ, um die Summe dieser Zeiten.
Natürlich, (von r in MyCollection wählen Sie r.TheDuration).Summe(); funktioniert nicht!

Ich überlege, ändern Sie den Datentyp TheDuration ein int und dann addieren und die Umwandlung der Summe zu einer Zeitspanne. Das wird chaotisch, weil jeder TheDuration in meiner Sammlung verwendet wird, als eine Zeitspanne irgendwo sonst.

Jeder Vorschlag, auf diese Summe?

InformationsquelleAutor der Frage frenchie | 2011-01-16

c#linq timespan

77

Leider gibt es nicht eine überlastung der Sum nimmt eine IEnumerable<TimeSpan>. Zudem gibt es keine aktuellen Art und Weise der Angabe der operator-basierte generische constraints für Typ-Parameter, so dass, obwohl TimeSpan ist "nativ" summierbare, dass Tatsache, die abgeholt werden können nicht einfach durch generischen code.

Eine option wäre, wie du sagst, die Summe einem integral-Typ entspricht der Zeitspanne statt, und drehen Sie dann , dass Summe in ein TimeSpan wieder. Die ideale Immobilie für diese ist TimeSpan.Zecken, die round-trips genau. Aber es ist nicht notwendig, um die Eigenschaft zu ändern-type-in Ihrer Klasse bei allen; können Sie nur Projekt:
```
var totalSpan = new TimeSpan(myCollection.Sum(r => r.TheDuration.Ticks));
```
Alternativ, wenn Sie wollen, zu bleiben, um die Zeitspanne ist + Betreiber zu tun, die Summen, die Sie verwenden können, die Aggregate Betreiber:
```
var totalSpan = myCollection.Aggregate
                (TimeSpan.Zero, 
                (sumSoFar, nextMyObject) => sumSoFar + nextMyObject.TheDuration);
```
InformationsquelleAutor der Antwort Ani

Diese gut funktioniert (code basierend auf Ani ' s Antwort)

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);
    }
}

Verwendung :

Wenn Perioden ist eine Liste von Objekten mit einem Duration-Eigenschaft

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

InformationsquelleAutor der Antwort grantnz

Lege ich diese in einer Klasse eine Erweiterung hinzufügen-Methode, um eine Sammlung von Zeitspannen:

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, jetzt kann ich schreiben TotalDuration = (meine LINQ-Abfrage, gibt eine Sammlung von timespan).TotalTime();

Voila!

InformationsquelleAutor der Antwort frenchie

0

Können Sie .Aggregate eher als .Sum, und übergeben Sie ein timespan-Summen-Funktion, die Sie schreiben, wie diese:
```
    TimeSpan AddTimeSpans(TimeSpan a, TimeSpan b)
    {
        return a + b;
    }
```
InformationsquelleAutor der Antwort CesarGon

Hier ist, was ich versucht und es funktionierte:

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; }
}

InformationsquelleAutor der Antwort Shekhar_Pro

Ich glaube, das ist die sauberste 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));
    }
}

Benutzung ist die gleiche:

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

InformationsquelleAutor der Antwort Matt Williams

Dies funktioniert sowohl für eine Sammlung, und eine Eigenschaft in einer Sammlung;

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));
    }
}

InformationsquelleAutor der Antwort wonea

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.