使用LINQ分组列表条目

Question

I have the following model:

public class Entry
{
    public int UseraccountId { get; set; }
    public int CompanyId { get; set; }
    public DateTime CreationDate { get; set; }
    public string Target { get; set; }
    public string Message { get; set; }
}

And a list with a lot of entries:

List<Entry> entries = ... //get all entries.

Example:

I'd now like row 2 and 3 to be grouped because they have the same UserId, same CompanyId, same target and almost (and this is the difficult part), let's say in a range of 5 seconds, the same date time.

After grouping my list should look like this:

Is there any easy approach for this problem? Any advices? I bet Linq will help me around but I'm not sure how.

Edit: Thank you all for your feedback. I decided to change the design and to ensure that the datetime is now really the same. So grouping with linq is now very easy.

Answer 1

As @dtb menitons, grouping by "close" is difficult because you can end up with a bigger "bucket" than you intended. For example, If you have 100 entries that are created 4 seconds apart from each other, grouping items that are within 5 seconds of the "next" item would put all of them in one bucket!

If, however, you want to round the creating date to the nearest, say, 5 seconds and then group, you could use:

TimeSpan ts = new TimeSpan(0, 0, 5);  // 5 seconds
entries.GroupBy(i => new {
                          UserId = i.UserId, 
                          CompanyId = i.CompanyId, 
                          Target = i.Target, 
                          RoundedTime = DateTime.MinValue.AddTicks(
                                            (long)(Math.Round((decimal)i.CreationDate.Ticks / ts.Ticks) * ts.Ticks)
                                        ) ;
                          ))
       .Select(g => new {
                         UserId = g.Key.UserId, 
                         CompanyId = g.Key.CompanyId, 
                         Target = g.Key.Target, 
                         RoundedTime = g.Key.RoundedTime,
                         Message = string.Join(", ",g.Select(i=> i.Message).ToArray())
                        } );

That will group by items that are rounded to the nearest 5 seconds - it's possible that two items one second apart will be in different buckets, but you don't have the problem with cummutativity that your stated requirement has.

Answer 2

This would give a range of -5 seconds, but for a full matching (clustering) algorithm on the CreationDate, I'm guessing it'll be far more difficult. You get the idea, though.

List<Entry> entries = entries.GroupBy(a => a.UserId)
                             .ThenBy(a => a.CompanyId)
                             .ThenBy(a => a.CreationDate.AddSeconds(-5));

Answer 3

There is no straightforward answer as this depends on what you consider to be a match. There are simple as well as complicated approaches and anywhere in between. You'll need to come up with the algorithm for that. An easy approach would be to shave off the seconds and just match down to the minute however that may be too long. You could write a method normalizes timestamps down to 5 or 10 seconds and group on that as suggested already.

If you want to group any two messages that are within x seconds together then this approach will only mostly work. There will always be those values that are within the range but fall on either side of the cutoff. If you are OK with this and value simplicity, then the above answer will work.

If that doesn't work and you want to group across the artificial cutoff then you'll need another approach. A simple approach in this case could be that you use LINQ to group by everything but the timestamp. This will do a preliminary grouping of your data. Then you can iterate through each group and compare each time value to each other time value in the same group and determine if it is within your range. Then manually grab those values that fall within the specified range and group them together.

This has an additional edge case that you'll need to make a decision on. If you decide that you will group within 1 second and you have three entries whose seconds are (simplified) 1, 2, and 3. 1 and 2 are within a second and 2 and 3 are also within a second but 1 and 3 aren't. Would you group these based on 2 being within one second of the others, or would you group 1 and 2, making 2 ineligible to be grouped with 3 and 3 would be by itself.

You'll ultimately wind up with a solution who's bucket's can grow based on chaining values together, or a different artificial cutoff based on first group created rather than hard time cutoffs. The hard time is far more simple so unless you are going to have growing buckets, I'd recommend just going with a normalized timestamp and grouping on that.

You need to define what you mean by almost and plan accordingly.