Question

我是Stack Overflow的新手，但尝试输入尽可能多的信息

我的班级结构如下

public class ItemEntity
{
    public int ItemId { get; set; }
    public int GroupId { get; set; }
    public string GroupName { get; set; }
    public DateTime ItemDate { get; set; }
    public string Field1 { get; set; }
    public string Filed2 { get; set; }
    public string Field3 { get; set; }
    public string Field4 { get; set; }
    public int Duration { get; set; }        
}

public class MasterEntity
{
    public ItemEntity Item { get; set; }
    public List<int> ItemList { get; set; }
    public List<int> GroupList { get; set; }
}

我正在尝试将ItemEntity的列表分组为MasterEntity。分组文件是Field1，Field2和Field3。

到目前为止，我已经完成了如下分组

var items = new List<ItemEntity>
            {
                new ItemEntity
                {
                    ItemId = 100,
                    GroupId = 1,
                    GroupName= "Group 1",
                    ItemDate = new DateTime(2018,10,17),
                    Duration = 7,
                    Field1 = "Item Name 1",
                    Filed2 = "aaa",
                    Field3= "bbb",
                    Field4= "abc"
                },
                new ItemEntity
                {
                    ItemId = 150,
                    GroupId = 2,
                    GroupName= "Group 2",
                    ItemDate = new DateTime(2018,10,17),
                    Duration = 5,
                    Field1 = "Item Name 1",
                    Filed2 = "aaa",
                    Field3= "bbb",
                    Field4= "efg"
                },
                new ItemEntity
                {
                    ItemId = 250,
                    GroupId = 3,
                    GroupName= "Group 3",
                    ItemDate = new DateTime(2018,10,15),
                    Duration = 7,
                    Field1 = "Item Name 1",
                    Filed2 = "aaa",
                    Field3= "bbb",
                    Field4= "xyz"
                }
            };


            var group = items.GroupBy(g => new
            {
                g.Field1,
                g.Filed2,
                g.Field3
            }).Select(s => new MasterEntity
            {
                Item = new ItemEntity
                {
                    Field1 = s.Key.Field1,
                    Filed2 = s.Key.Filed2,
                    Field3 = s.Key.Field3
                },
                ItemList = s.Select(g => g.ItemId).ToList(),
                GroupList = s.Select(g => g.GroupId).ToList()
            }).ToList();

在该组中，我想按实际的ItemDate和Duration对其进行进一步划分，使其如下所示

基本上，在这种情况下，我想将该组分为三部分。

由于只有第3组的日期为15日至17日，因此它将是一个组。从第17组到第22组，组2和组3相同。这样将成为另一个群体。最后只有Group1的第22至24位，所以它成为另一个组

最终分组的数据要像

G1
{
 ItemEntity :{
 ItemDate : 15/10/2018,
 Duration : 2,
 Field1 : "Item Name 1",
 Filed2 : "aaa",
 Field3 : "bbb",
    },
ItemList: {250},
GroupList:{3}
}

,
G2
{
 ItemEntity :{
 ItemDate : 17/10/2018,
 Duration : 5,
 Field1 : "Item Name 1",
 Filed2 : "aaa",
 Field3 : "bbb",
},
ItemList: {100,150,250},
GroupList:{1,2,3}
}
,
G3
{
 ItemEntity :{
 ItemDate : 22/10/2018,
 Duration : 2,
 Field1 : "Item Name 1",
 Filed2 : "aaa",
 Field3 : "bbb",
},
ItemList: {100},
GroupList:{1}
}

Answer 1

这非常具有挑战性。我使用了一些我已经必须使其变得更容易的便捷扩展方法，并创建了一个HashSet子类，该子类默认使用SetEqual（.Net确实需要内置一些成员相等的集合类）。

首先，类HashSetEq在其成员匹配时实现相等性：

public class HashSetEq<T> : HashSet<T>, IEquatable<HashSetEq<T>> {
    private static readonly IEqualityComparer<HashSet<T>> SetEq = HashSet<T>.CreateSetComparer();

    public override int GetHashCode() => SetEq.GetHashCode(this);
    public override bool Equals(object obj) => obj != null && (obj is HashSetEq<T> hs) && this.Equals(hs);
    public bool Equals(HashSetEq<T> other) => SetEq.Equals(this, other);

    public HashSetEq(IEnumerable<T> src) : base(src) {
    }
}

现在，对IEnumerable进行了一些扩展。一个扩展名将IEnumerable转换为HashSetEq，以便于创建密钥集合。另一个扩展名是GroupBy的一种变体，它基于实现APL扫描运算符的成对版本的扩展名ScanPair分组，而谓词为true。

public static class IEnumerableExt {
    public static HashSetEq<T> ToHashSetEq<T>(this IEnumerable<T> src) => new HashSetEq<T>(src);


    // TKey combineFn((TKey Key, T Value) PrevKeyItem, T curItem):
    // PrevKeyItem.Key = Previous Key
    // PrevKeyItem.Value = Previous Item
    // curItem = Current Item
    // returns new Key
    public static IEnumerable<(TKey Key, T Value)> ScanPair<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;
            }
        }
    }

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

为了对日期范围进行分组，我基于GroupBySequential内联扩展了GroupByWhile，以便可以按顺序的日期运行和匹配的GroupId组进行分组。 GroupBySequential取决于整数序列，因此我需要一个基本日期来计算日期序列号，因此我在所有项目中都使用最早的日期：

var baseDate = items.Min(i => i.ItemDate);

现在我可以计算答案了。

对于每组项目，我根据Duration将其扩展到涵盖的所有日期，并将每个日期与原始项目相关联：

var group = items.GroupBy(g => new {
    g.Field1,
    g.Filed2,
    g.Field3
})
.Select(g => g.SelectMany(i => Enumerable.Range(0, i.Duration).Select(d => new { ItemDate = i.ItemDate.AddDays(d), i }))

现在我已经拥有所有单独的日期和项目，我可以为每个日期将它们分组。

              .GroupBy(di => di.ItemDate)

然后将日期上的每个日期和项目分组，并按日期对该日期和顺序进行分组。

              .GroupBy(dig => new { ItemDate = dig.Key, Groups = dig.Select(di => di.i.GroupId).ToHashSetEq() })
              .OrderBy(ig => ig.Key.ItemDate)

通过按日期对它们进行排序，我可以将具有相同baseDate的连续日期（使用Groups中的天数）组合在一起。

              .GroupByWhile((prevg, curg) => (int)(prevg.Key.ItemDate - baseDate).TotalDays + 1 == (int)(curg.Key.ItemDate - baseDate).TotalDays && prevg.Key.Groups.Equals(curg.Key.Groups))

最后，我可以将每个顺序日期组中的信息提取到MasterEntity中，并将其全部答案作为一个List。

              .Select(igg => new MasterEntity {
                  Item = new ItemEntity {
                      ItemDate = igg.First().Key.ItemDate,
                      Duration = igg.Count(),
                      Field1 = g.Key.Field1,
                      Filed2 = g.Key.Filed2,
                      Field3 = g.Key.Field3
                  },
                  ItemList = igg.First().First().Select(di => di.i.ItemId).ToList(),
                  GroupList = igg.First().Key.Groups.ToList()
              })
)
.ToList();

Answer 2

https://dotnetfiddle.net/fFtqgy

好的，因此该示例包含3个参加您所解释的“旅馆”的聚会。团体布置如下，包括团体到达和离开酒店的时间

场景

第1组）15-20

第2组）17日至19日

第3组）17日至22日

结果分组

15日-17日：第1组

17日-19日：第1、2、3组

19日-20日：第1、3组

20至22日：第3组

说明

这描述了每个日期将在酒店中出现的组，每次一个组加入或离开酒店时都会创建一个新组，这就是为什么代码将所有日期的所有开始日期和结束日期都加入的原因分组并遍历它们。

我不确定要在生成的MasterEntity上为GroupId和ItemID加上什么，因为它包含项和组的列表，因此在示例中，我将其设置为负1。

小提琴的代码

public static class Utilities
{

    public static bool DatesOverlap(DateTime aStart, DateTime aEnd, DateTime bStart, DateTime bEnd)
    {
        return aStart < bEnd && bStart < aEnd;
    }

    public static IList<MasterEntity> GroupFunky(IList<ItemEntity> list)
    {

        var result = new List<MasterEntity>();
        var ordered = list.OrderBy(x => x.ItemDate).ToArray();

        var startDates = list.Select(x => x.ItemDate);
        var endDates = list.Select(x => x.ItemDate.AddDays(x.Duration));

        var allDates = startDates.Concat(endDates).OrderBy(x => x).ToArray();

        for (var index = 0; index < allDates.Length - 1; index++)
        {
            var group = ordered.Where(x => DatesOverlap(allDates[index], allDates[index + 1], x.ItemDate,
                                                        x.ItemDate.AddDays(x.Duration)));


            var item = new ItemEntity
            {
                Duration = (allDates[index + 1] - allDates[index]).Days,
                ItemDate = allDates[index],
                Field1 = group.First().Field1,
                Field2 = group.First().Field2,
                Field3 = group.First().Field3,
                Field4 = group.First().Field4,
                GroupName = group.First().GroupName,
                ItemId = -1,
                GroupId = -1
            };
            item.ItemDate = allDates[index];
            item.Duration = (allDates[index + 1] - allDates[index]).Days;
            result.Add(new MasterEntity
            {
                Item = item,
                GroupList = group.Select(x => x.GroupId).ToList(),
                ItemList = group.Select(x => x.ItemId).ToList()
            });
        }

        return result.Where(x => x.Item.Duration > 0).ToList();
    }
}

public class ItemEntity
{
    public int ItemId { get; set; }
    public int GroupId { get; set; }
    public string GroupName { get; set; }
    public DateTime ItemDate { get; set; }
    public string Field1 { get; set; }
    public string Field2 { get; set; }
    public string Field3 { get; set; }
    public string Field4 { get; set; }
    public int Duration { get; set; }
}

public class MasterEntity
{
    public ItemEntity Item { get; set; }
    public List<int> ItemList { get; set; }
    public List<int> GroupList { get; set; }
}

public class TestClass
{

    public static void Main()
    {
        var items = new List<ItemEntity>
        {
            new ItemEntity
            {
                ItemId = 100,
                GroupId = 1,
                GroupName = "Group 1",
                ItemDate = new DateTime(2018, 10, 15),
                Duration = 5,
                Field1 = "Item Name 1",
                Field2 = "aaa",
                Field3 = "bbb",
                Field4 = "abc"
            },
            new ItemEntity
            {
                ItemId = 150,
                GroupId = 2,
                GroupName = "Group 2",
                ItemDate = new DateTime(2018, 10, 17),
                Duration = 2,
                Field1 = "Item Name 1",
                Field2 = "aaa",
                Field3 = "bbb",
                Field4 = "efg"
            },
            new ItemEntity
            {
                ItemId = 250,
                GroupId = 3,
                GroupName = "Group 3",
                ItemDate = new DateTime(2018, 10, 17),
                Duration = 5,
                Field1 = "Item Name 1",
                Field2 = "aaa",
                Field3 = "bbb",
                Field4 = "xyz"
            }
        };


        var group = items.GroupBy(g => new
        {
            g.Field1,
            g.Field2,
            g.Field3
        })
            .Select(x => x.AsQueryable().ToList())
            .ToList();

        var result = group.Select(x => Utilities.GroupFunky(x));

        foreach (var item in result)
        {
            Console.WriteLine(JsonConvert.SerializeObject(item, Formatting.Indented));
        }

    }
}

复杂的Linq分组

2 个答案:

场景

结果分组

说明

小提琴的代码