Question

Given class

public class SomeType
{
    public string Name;
    public string Field2;
    public DateTime CreatedOnDateTime
}

I want to take a List<SomeType> and divide it into several List<SomeType> where each List contains items with an equal CreatedOnDateTime stamp. In many cases CreatedOnDateTime will be the same, it would be nice to allow a tolerance of a couple seconds.

I could run a LINQ query N number of times to create each distinct list. Is there a more efficient mechanism? In other words, can this type of query be built with LINQ using some type of grouping mechanism? (when I say grouping I am imagining a RegEx)

Answer 1

Why would you use a regex? That’s for textual pattern matching. It sounds like you want ToLookup:

var lookup = list.ToLookup(x => x.CreatedOnDateTime);

foreach (var entry in lookup)
{
    Console.WriteLine("Created: {0}", entry.Key);
    foreach (var item in entry)
    {
        Console.WriteLine("  {0}, {1}", item.Name, item.Field2);
    }
}

Note that that will go for identical timestamps. Creating a “tolerance” as such is difficult, but you could effectively “round down” the entries to a couple of seconds:

var lookup = list.ToLookup(x => RoundDownToTwoSeconds(x.CreatedOnDateTime));

...

private static DateTime RoundDownToTwoSeconds(DateTime input)
{
    return new DateTime(input.Year, input.Month, input.Day, input.Hour,
                        input.Minute, (input.Second / 2) * 2,
                        input.Kind);
}

(Think of a better name if you want 🙂

The reason simple “tolerance” is hard is this situation:

Entry 1: 12:05:14
Entry 2: 12:05:15
Entry 3: 12:05:16
Entry 4: 12:05:17

Entries 1 and 2 are only a second apart… so they should go in the same bucket. But entries 2 and 3 are only a second apart… so they should go in the same bucket too. Entries 3 and 4 are only a second apart, so entry 4 should go in the same bucket as well. Now we’ve got entries 1 and 4, three seconds apart, in the same bucket.