C# 根据优先级合并重复时间

您好，我可以为您解答这个问题。

如果您想要根据优先级合并重复时间，可以使用 C# 中的 LINQ 查询进行实现。以下是一个简单的示例代码：

List<DateTime> dates = new List<DateTime>() { new DateTime(2022, 1, 1, 12, 0, 0), new DateTime(2022, 1, 1, 13, 0, 0), new DateTime(2022, 1, 1, 12, 30, 0), new DateTime(2022, 1, 2, 10, 0, 0) };

var result = dates.GroupBy(d => d.Date)
                  .Select(g => g.OrderBy(d => d.TimeOfDay)
                                .First())
                  .OrderBy(d => d);

foreach (var date in result)
{
    Console.WriteLine(date);
}

以上代码会将 dates 列表中的日期按照日期进行分组，然后按照时间排序，选择每个组中优先级最高的日期进行输出，最后按照日期进行排序输出结果。

希望这个代码可以帮助到您。如果您还有其他问题，请继续提问。

相关问题

C# 根据优先级合并重复时间段，结束时间是上一个的结束时间

如果您想要根据优先级合并重复时间段，并且将结束时间设置为上一个时间段的结束时间，可以使用 C# 中的 LINQ 查询和时间操作进行实现。以下是一个简单的示例代码：

List<(DateTime start, DateTime? end)> timeRanges = new List<(DateTime start, DateTime? end)>()
{
    (new DateTime(2022, 1, 1, 12, 0, 0), new DateTime(2022, 1, 1, 13, 0, 0)),
    (new DateTime(2022, 1, 1, 12, 30, 0), new DateTime(2022, 1, 1, 14, 0, 0)),
    (new DateTime(2022, 1, 2, 10, 0, 0), new DateTime(2022, 1, 2, 11, 0, 0)),
    (new DateTime(2022, 1, 2, 11, 0, 0), new DateTime(2022, 1, 2, 12, 0, 0))
};

var result = timeRanges.OrderBy(tr => tr.start)
                      .Aggregate(new List<(DateTime start, DateTime end)>(), (acc, tr) =>
                      {
                          if (acc.Count == 0 || tr.start > acc.Last().end)
                          {
                              acc.Add((tr.start, tr.end ?? tr.start));
                          }
                          else if (tr.end > acc.Last().end)
                          {
                              acc[acc.Count - 1] = (acc.Last().start, tr.end ?? acc.Last().end);
                          }
                          return acc;
                      });

foreach (var timeRange in result)
{
    Console.WriteLine($"{timeRange.start} - {timeRange.end}");
}

以上代码会将 timeRanges 列表中的时间段按照开始时间排序，然后使用 Aggregate 函数进行合并。如果当前时间段的开始时间晚于上一个时间段的结束时间，将当前时间段加入结果列表中；如果当前时间段的结束时间晚于上一个时间段的结束时间，将上一个时间段的结束时间设置为当前时间段的结束时间。最后输出合并后的时间段列表。

希望这个代码可以帮助到您。如果您还有其他问题，请继续提问。

C# list 时间段，判断是否重复，重复按照优先级合并

好的，下面是一个 C# 的示例代码，可以对一组时间段进行判断，判断它们是否有重叠部分，并且如果有重叠部分，能够按照优先级将它们合并。

using System;
using System.Collections.Generic;

public class TimeInterval
{
    public DateTime Start { get; set; }
    public DateTime End { get; set; }
    public int Priority { get; set; }
}

public static class TimeIntervalExtensions
{
    public static List<TimeInterval> Merge(this List<TimeInterval> intervals)
    {
        // 按照起始时间升序排序
        intervals.Sort((a, b) => a.Start.CompareTo(b.Start));

        List<TimeInterval> merged = new List<TimeInterval>();
        TimeInterval current = null;

        foreach (TimeInterval interval in intervals)
        {
            // 如果当前时间段不存在，或者与当前时间段没有重叠部分
            if (current == null || interval.Start > current.End)
            {
                // 直接添加到结果中
                merged.Add(interval);
                current = interval;
            }
            // 如果与当前时间段存在重叠部分
            else if (interval.End > current.End)
            {
                // 将当前时间段的结束时间更新为较晚的时间
                current.End = interval.End;
            }

            // 如果两个时间段有相同的起始时间，按照优先级合并
            if (interval.Start == current.Start && interval.Priority > current.Priority)
            {
                current.Priority = interval.Priority;
            }
        }

        return merged;
    }
}

// 示例用法
public static void Main()
{
    List<TimeInterval> intervals = new List<TimeInterval>
    {
        new TimeInterval { Start = new DateTime(2021, 1, 1, 9, 0, 0), End = new DateTime(2021, 1, 1, 10, 0, 0), Priority = 2 },
        new TimeInterval { Start = new DateTime(2021, 1, 1, 9, 30, 0), End = new DateTime(2021, 1, 1, 11, 0, 0), Priority = 1 },
        new TimeInterval { Start = new DateTime(2021, 1, 1, 11, 0, 0), End = new DateTime(2021, 1, 1, 12, 0, 0), Priority = 3 },
    };

    List<TimeInterval> merged = intervals.Merge();

    foreach (TimeInterval interval in merged)
    {
        Console.WriteLine($"Start: {interval.Start}, End: {interval.End}, Priority: {interval.Priority}");
    }
}

这里我们定义了一个 `TimeInterval` 类，其中包含了时间段的起始时间、结束时间和优先级属性。然后我们定义了一个静态扩展方法 `Merge`，用于将一组时间段进行合并。在 `Merge` 方法中，我们首先按照起始时间升序排序，然后遍历每个时间段，将它们合并到一个新的列表中。

对于每个时间段，我们检查它与当前时间段是否有重叠部分。如果没有重叠部分，我们直接将它添加到结果列表中，并将当前时间段更新为它。如果有重叠部分，我们将当前时间段的结束时间更新为较晚的时间。

最后，我们还添加了一个判断，如果两个时间段有相同的起始时间，我们按照优先级将它们合并。

希望这个示例代码能够帮助到你！