linq-Gruppe durch eine Startzeit zu Endzeit DateTime-Spalte

Ok das ist ein bisschen chaotisch Abfrage und ich bin nur mit begrenztem Erfolg mit ihm. Ich habe eine Liste von ein Foo Klasse, die eine datetime-Eigenschaft und andere Daten. Ich habe eine Klasse/Zeile für fast jede minute, einige fehlen und einige ganze Tage fehlen, wie ein Urlaub oder ein Wochenende. Mein Ziel ist die Gruppe jeden Tag für alle Zeilen aus einer Zeit start Zeit Ende Zeit.

So dass in einigen Tagen mein start Zeit 9:30 Uhr und Endzeit 3:00 Uhr. Diese situation kann ich das umgehen, indem die folgenden:

DateTime sd = new DateTime(2000, 1, 1, 9, 30, 0);
DateTime ed = new DateTime(2000, 1, 1, 15, 0, 0);
var z = Foos.Where(a=> a.FooDate.TimeOfDay >= sd.TimeOfDay &&
    a.FooDate.TimeOfDay < ed.TimeOfDay)
    .GroupBy(a=>a.FooDate.Date);

Diese funktioniert einwandfrei. Mein problem ist, manchmal habe ich eine Startzeit von 9 Uhr und einer Endzeit von 6 Uhr morgens. In diesem Fall möchte ich die Gruppe der foos gehen über Nacht, und wenn die 9pm ist an einem Freitag und es gibt keine Zeilen bis zum nächsten Montag möchte ich das die Gruppe sich über das Wochenende. Ich würde auch gerne einen Vorschlag, der eine Abfrage damit würde immer gehen, um für den nächsten Tag.

Ich hoffe das ist klar und schätzen alle Ideen. Ich habe versucht, eine Menge andere Möglichkeiten, dies zu tun mit Schleifen und erstellen eine weitere Liste der unterschiedlichen Terminen und so, aber ich bin nicht glücklich mit ihm.

  • Ich bin verwirrt, was Sie versuchen, zu bestimmen. Sind Sie versuchen, um die Zeit zwischen den Einträgen (Foos)? oder sind Sie zählen die Anzahl der Einträge zwischen den zwei Zeiten?
  • Im Versuch, die Gruppe der Liste der foo-Objekte in eine Zeit reichen. So, am ersten Tag, es gibt Daten, es würde die Gruppe aus der start-Zeit des Tages, um am nächsten Tag gibt es Daten endtime. Dann an diesem Tag wieder starten zu Beginn Zeit und weiter.
InformationsquelleAutor RBear | 2009-05-14
  1. 3

    In der Physik, wenn vor einem relativen problem, Sie erhalten zu wählen, wo null ist. So tun wir.

    //time range expressed as an example in "absolute" terms
DateTime sd = new DateTime(2000, 1, 1, 9, 30, 0);
DateTime ed = new DateTime(2000, 1, 2, 6, 0, 0);

//time range expressed as a zero and range - "relative" terms
TimeSpan zero = sd.TimeOfDay;
TimeSpan range = ed.Subtract(sd);

 //the inputs
List<DateTime> myList = new List<DateTime>()
{
  new DateTime(2009, 1, 1, 10, 0, 0),  //group1
  new DateTime(2009, 1, 1, 17, 0, 0),  //group1
  new DateTime(2009, 1, 2, 9, 0, 0),  //this is filtered
  new DateTime(2009, 1, 2, 10, 0, 0),  //group2
  new DateTime(2009, 1, 2, 15, 0, 0),  //group2
  new DateTime(2009, 1, 3, 3, 0, 0),   //group2
  new DateTime(2009, 1, 3, 7, 0, 0),  //this is filtered
  new DateTime(2009, 1, 3, 10, 0, 0)   //group3
};

  //at last, the query.
var query = myList
  .Where(d => d.Subtract(zero).TimeOfDay < range)
  .GroupBy(d => d.Subtract(zero).Date);

 // output the results
foreach (var g in query)
{
  Console.WriteLine("{0}", g.Count());
  foreach (var d in g)
  {
    Console.WriteLine("  {0}", d);
  }
}

    Ergebnisse:

    2
  1/1/2009 10:00:00 AM
  1/1/2009 5:00:00 PM
3
  1/2/2009 10:00:00 AM
  1/2/2009 3:00:00 PM
  1/3/2009 3:00:00 AM
1
  1/3/2009 10:00:00 AM
    • WOW!!! Das ist genau das, was ich Suche. Es funktioniert auf meiner normalen Fall auch zu. Ich danke Ihnen sehr!
    InformationsquelleAutor Amy B
  2. 0

    Wird dies funktionieren, aber es kann nicht sein, schöner als das, was Sie bereits tut

        private List<groupFoo> groupFoos(List<foo> foos)
    {

        //Group by Day into groupFoo
        var z = foos.GroupBy(a => a.FooDate.ToShortDateString()).Select(x => new groupFoo() { Key = x.Key, Start = x.First().FooDate, End = x.Last().FooDate }).ToList();


        //Create new list to hold groups
        var groupedFoos = new List<groupFoo>();

        //add all the good groups to the list
        groupedFoos.AddRange(z.FindAll(zz => zz.Start.CompareTo(zz.End) != 0));

        //Remove all of the good groups from the orignal list
        groupedFoos.ForEach(gf => z.RemoveAt(z.IndexOf(gf)));

        //Sort whats left
        z.Sort((a, b) => { return a.Start.CompareTo(b.Start); });

        while (z.Count > 1)
        {
            //grab the first 2 
            var y = z.Take(2);

            //create a new group foo and add it to the good list
            groupedFoos.Add(y.Aggregate((a, b) => new groupFoo() { Key = a.Key, Start = a.Start, End = b.End }));

            //remove the bad ones
            y.ToList().ForEach(yy => z.RemoveAt(z.IndexOf(yy)));


        }

        return groupedFoos;
    }

    und groupFoo sieht wie folgt aus

    public class groupFoo
{

    public string Key { get; set; }
    public DateTime Start { get; set; }
    public DateTime End { get; set; }

}

    die Probe, die ich verwendet

            List<foo> foos = new List<foo>();

        foos.Add(new foo() { FooDate = new DateTime(2009, 1, 1, 9, 0, 0) });
        foos.Add(new foo() { FooDate = new DateTime(2009, 1, 1, 17, 0, 0) });
        foos.Add(new foo() { FooDate = new DateTime(2009, 1, 2, 9, 30, 0) });
        foos.Add(new foo() { FooDate = new DateTime(2009, 1, 3, 6, 0, 0) });
        foos.Add(new foo() { FooDate = new DateTime(2009, 1, 4, 9, 0, 0) });
        foos.Add(new foo() { FooDate = new DateTime(2009, 1, 4, 21, 0, 0) });
    InformationsquelleAutor Jeremy
Schreibe einen Kommentar