使用 LINQ 对时间戳列表中的重复项进行排序、舍入和删除

Question

I'm trying to process some data based on their time stamps. I have a working solution, but I feel that it could be expressed in a much cleaner way using LINQ.

I need to do the following:

1. Sort the list, based on the timestamp
2. Round off the milliseconds
3. Remove any duplicate values (does not matter which is removed)

Here is my current working solution:

using MoreLinq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SortingWITSMLRealTimeSignals
{
    class Program
    {
        class Foo
        {
            public DateTime TimeStampUtc;
            public int SomeData;
        }

        static void Main(string[] args)
        {
            List<Foo> testData = new List<Foo> { 
                new Foo { TimeStampUtc = new DateTime(2019, 11, 12, 20, 20, 23, 515), SomeData = 42 },
                new Foo { TimeStampUtc = new DateTime(2019, 11, 12, 20, 20, 24, 515), SomeData = 42 },
                new Foo { TimeStampUtc = new DateTime(2019, 11, 12, 20, 20, 25, 515), SomeData = 42 },
                new Foo { TimeStampUtc = new DateTime(2019, 11, 12, 20, 20, 25, 245), SomeData = 33 },
                new Foo { TimeStampUtc = new DateTime(2019, 11, 12, 20, 20, 27, 515), SomeData = 42 },
                new Foo { TimeStampUtc = new DateTime(2019, 11, 12, 20, 20, 28, 515), SomeData = 42 },
            };

            List<Foo> orderedTestData = testData.OrderBy(rs => rs.TimeStampUtc).ToList();

            List<Foo> roundedTestData = new List<Foo>();
            foreach (var otd in orderedTestData)
            {
                otd.TimeStampUtc = otd.TimeStampUtc.AddMilliseconds(-otd.TimeStampUtc.Millisecond);
                roundedTestData.Add(otd);
            }

            var filteredTestData = roundedTestData.DistinctBy(x => x.TimeStampUtc).ToList();
        }
    }
}

Answer 1

This works:

var result =
    testData
        .GroupBy(otd => otd.TimeStampUtc.AddMilliseconds(-otd.TimeStampUtc.Millisecond))
        .SelectMany(x => x.Take(1))
        .ToList();

From your source data, I get:

Answer 2

You could also try this LINQ query:

var result = testData
    .Select(td => new Foo
    {
        TimeStampUtc = td.TimeStampUtc.AddMilliseconds(-td.TimeStampUtc.Millisecond),
        SomeData = td.SomeData
    })
    .OrderBy(td => td.TimeStampUtc)
    .DistinctBy(otd => otd.TimeStampUtc)
    .ToList();

Since we want the final collection to be sorted, putting the OrderBy last here is a good idea. Also sorting on the the unique values returned from DistinctBy instead of all the items will yield better performance for larger sets. There is also no guarantee that DistinctBy will return items in order, so sorting last is a good idea. Following the SELECT, DISTINCT and ORDERBY order of statements is recommended with SQL queries anyways, so applying the same logic to LINQ makes sense.