【问题标题】:How to join Consecutive Date Ranges in linq如何在 linq 中加入连续的日期范围
【发布时间】:2019-07-10 04:54:21
【问题描述】:

所以我有这些数据示例

projects   startdate    enddate
prj A      01 Jan 2019  10 Feb 2019
prj B      29 Jan 2019  15 Mar 2019
prj C      21 Mar 2019  02 May 2019
prj D      07 May 2019  10 Jun 2019
prj E      11 Jun 2019  30 Jul 2019

我想使用 linq lambda 制作每个项目包含连续项目列表的列表对象 分组结果大致是这样的

[
   [prj A, prj B],
   [prj C],
   [prj D, prj E]
]
  • prj A 和 B 被分组,因为 daterange prj A 与 prj 重叠 乙
  • 由于 enddate prj B 和 startdate prj C 之间有空格,所以 prj C 在不同的组中
  • prj D 和 E 被分组,因为 startdate prj E 是 enddate prj D 的第二天

那么如何使用 linq lambda 创建这样的分组? 谢谢

【问题讨论】:

  • 如果 A 重叠 B 并且 B 重叠 C 怎么办?
  • 然后 A、B 和 C 加入 1 个组

标签: c# .net entity-framework linq lambda


【解决方案1】:

您可以编写一个遵循 LINQ 风格的扩展方法。 JoinBy 充当分析 lag 函数。它需要orderBy 和keySelector 来确定要评估的相邻值。 join 用于决定何时可以连接相邻的值。

public static class LinqExtension
{
    public static IEnumerable<IEnumerable<TSource>> JoinBy<TSource, TOrderKey, TKey>(
        this IEnumerable<TSource> source,
        Func<TSource, TOrderKey> orderBy,
        Func<TSource, TKey> keySelector,
        Func<TKey, TKey, bool> join)
    {
        var results = new List<List<TSource>>();
        var orderedSource = new List<TSource>(source).OrderBy(orderBy).ToArray();

        if (orderedSource.Length > 0)
        {
            var group = new List<TSource> { orderedSource[0] };
            results.Add(group);
            if (orderedSource.Length > 1)
            {
                for (int i = 1; i < orderedSource.Length; i++)
                {
                    var lag = orderedSource[i - 1];
                    var current = orderedSource[i];
                    if (join(keySelector(lag), keySelector(current)))
                    {
                        group.Add(current);
                    }
                    else
                    {
                        group = new List<TSource> { current };
                        results.Add(group);
                    }
                }
            }
        }

        return results;
    }
}

..并使用它将相邻的项目组合在一起..

public class Project
{
    public string Name { get; set; }
    public DateTime Begin { get; set; }
    public DateTime End { get; set; }
}

[TestMethod]
public void TestCase1()
{
    var projects = new List<Project>() {
          new Project { Name = "A", Begin = new DateTime(2000, 1, 1), End = new DateTime(2000, 12, 31) }
        , new Project { Name = "B", Begin = new DateTime(2001, 1, 1), End = new DateTime(2001, 12, 31) }
        , new Project { Name = "C", Begin = new DateTime(2010, 1, 1), End = new DateTime(2010, 12, 31) }
        , new Project { Name = "D", Begin = new DateTime(2010, 6, 1), End = new DateTime(2010, 7, 1) }
     };

    var grouped = projects.JoinBy(
        x => x.Begin,
        x => (begin: x.Begin, end: x.End),
        (x1, x2) => x2.begin <= x1.end.AddDays(1) && x1.begin <= x2.end.AddDays(1));

    var builder = new StringBuilder();
    foreach (var grp in grouped)
    {
        builder.AppendLine(string.Join(", ", grp.Select(x => x.Name)));
    }

    var rendered = builder.ToString();

    // rendered =>
    // A, B
    // C, D
}

编辑:来自 cmets 的另一个测试用例

[TestMethod]
public void TestCase2_FromComments()
{
    var projects = new List<Project>() {
          new Project { Name = "A", Begin = new DateTime(2019, 4, 2), End = new DateTime(2019, 8, 17) }
        , new Project { Name = "B", Begin = new DateTime(2019, 6, 1), End = new DateTime(2019, 7, 1) }
     };

    var grouped = projects.JoinBy(
        x => x.Begin,
        x => (begin: x.Begin, end: x.End),
        (x1, x2) => x2.begin <= x1.end.AddDays(1) && x1.begin <= x2.end.AddDays(1));

    var builder = new StringBuilder();
    foreach (var grp in grouped)
    {
        builder.AppendLine(string.Join(", ", grp.Select(x => x.Name)));
    }

    var rendered = builder.ToString();

    // rendered =>
    // A, B
}

【讨论】:

  • 谢谢,迄今为止最优雅的解决方案...我会尝试将其集成到我的代码中(实际代码具有复杂的对象和复杂的 linq)
  • 这适用于大多数情况,但如果项目与另一个项目完全重叠,例如 prj A - 2019 年 4 月 2 日 - 2019 年 8 月 17 日 prj B - 2019 年 6 月 1 日 - 2019 年 7 月 1 日 prj B 将创建另一个组insted 与 prj A 在 1 组中加入
  • @TanggonJodiIsmana 我刚刚测试过,它仍然可以分组(查看我的编辑)
【解决方案2】:

您不能通过 Linq GroupBy 他们,因为组中的每个项目可能在其他项目中没有共同的分组键或无法找到,而是两个邻域之间仅存在一个公共键。 Try another approach:

var result = new List<List<string>>();
var projects = new List<Project>
{
    new Project{ Name = "prj A",
        startdate = new DateTime(2019, 1, 1), enddate = new DateTime(2019, 2, 10) },
    new Project{ Name = "prj B",
        startdate = new DateTime(2019, 1, 29), enddate = new DateTime(2019, 3, 15) },
    new Project{ Name = "prj C",
        startdate = new DateTime(2019, 3, 21), enddate = new DateTime(2019, 5, 2) },
    new Project{ Name = "prj D",
        startdate = new DateTime(2019, 5, 7), enddate = new DateTime(2019, 6, 10) },
    new Project{ Name = "prj E",
        startdate = new DateTime(2019, 6, 11), enddate = new DateTime(2019, 7, 30) }
};
projects = projects.OrderBy(x => x.startdate).ToList();

for (var i = 0; i < projects.Count; i++)
{
    var project = projects[i];
    if (projects[0] != project 
        && 
        (project.startdate - projects[i - 1].enddate).TotalDays < 2)
        result.Last().Add(project.Name);
    else
        result.Add(new List<string> { project.Name });                                    
}

foreach(var gr in result)
    Console.WriteLine(String.Join(", ", gr));
//prj A, prj B
//prj C
//prj D, prj E

【讨论】:

  • 您可以使用 Linq 对它们进行分组。只要有重叠,您只需要制作一个自定义扩展方法,将相邻的行分组。
  • @dfhwze,请告诉我你在哪里使用了GroupBy?
  • 我不使用 GroupBy,因为我是基于 function 而不是 key 进行分组的。您关于我们无法使用 LINQ 进行分组的说法在不能使用 GroupBy 的意义上是正确的,但在更广泛的意义上是不正确的 grouping 是什么。是否需要将密钥称为组?
  • @dfhwze,我想听听你的评论。
  • 由于您现在更新了答案以包含 GroupBy,因此我们的 cmets 是静音的。我们都同意不能使用 GroupBy。
【解决方案3】:

使用 APL 扫描运算符的变体(如 Aggregate,只返回中间结果),它适用于成对的项目,您可以创建一个 GroupBy,它在对上使用谓词 lambda 并创建组,只要它的值为真:

public static class IenumerableExt {
    // TKey combineFn((TKey Key, T Value) prevKeyItem, T curItem)
    //      prevKeyItem.Key = Previous Key (initially, seedKey)
    //      prevKeyItem.Value = Previous Item
    //      curItem = Current Item
    //      returns TKey for Current Item
    public static IEnumerable<(TKey Key, T Value)> ScanToPairs<T, TKey>(this IEnumerable<T> src, TKey seedKey, Func<(TKey Key, T Value), T, TKey> combineFn) {
        using (var srce = src.GetEnumerator())
            if (srce.MoveNext()) {
                var prevkv = (seedKey, srce.Current);

                while (srce.MoveNext()) {
                    yield return prevkv;
                    prevkv = (combineFn(prevkv, srce.Current), srce.Current);
                }
                yield return prevkv;
            }
    }

    // bool testFn(T prevVal, T curVal)
    public static IEnumerable<IGrouping<int, T>> GroupPairsByWhile<T>(this IEnumerable<T> src, Func<T, T, bool> testFn) =>
        src.ScanToPairs(1, (kvp, cur) => testFn(kvp.Value, cur) ? kvp.Key : kvp.Key + 1)
           .GroupBy(kvp => kvp.Key, kvp => kvp.Value);
}

使用此扩展程序,您可以轻松地对项目进行分组:

var ans = projects.GroupPairsByWhile((prev,cur) => cur.startdate <= prev.enddate.AddDays(1));

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2017-02-12
    • 2014-12-16
    • 2013-03-24
    • 1970-01-01
    • 2016-05-22
    • 1970-01-01
    • 2011-08-19
    • 1970-01-01
    相关资源
    最近更新 更多