C# 基于子列表LINQ拆分主列表

我的课程列表如下。我需要根据

List

计数滑动

List

。如果“活动”大于8，则将列表与列表0-7和7-forward一起由两个子列表拆分。剩余值在列表中应与员工姓名和活动时数相同

更多细节：我正在添加更多细节。 时间只有一个条目，但内部活动有10个条目。我需要把时间分成两份清单。第一个时间列表消耗0-7个活动，另一个时间列表消耗8个活动。因此，两个子列表中的EmployeeName应该相同。只有活动列表不同。在新列表中，一个列表有8个活动条目，另一个列表有2个活动条目

List<TimeSheet> Time;

сlass TimeSheet
{
    public string employeeName {get;set;}
    public List<Activity> activity {get;set;}
    public List<ActivityHours> ActivityHours{get;set;}
}

class Activity
{
    public string Id {get;set;}
    public string Activity {get;set;}
}

class ActivityHours
{
    public string ActivityId {get;set;}
    public string hours {get;set;}
}

列表时间；
玻璃时间表
{
公共字符串employeeName{get；set；}
公共列表活动{get；set；}
公共列表活动小时数{get；set；}
}
课堂活动
{
公共字符串Id{get；set；}
公共字符串活动{get；set；}
}
课堂活动时间
{
公共字符串ActivityId{get；set；}
公共字符串小时数{get；set；}
}

如果您不关心ActivityHours在不同的活动块中具有相同的引用，您可以使用以下代码：

var newTime = Time
    .SelectMany(t =>
        Enumerable
        .Range(0, (t.activity.Count - 1) / 8)
        .Select(i => new TimeSheet
        {
            employeeName = t.employeeName,
            ActivityHours = t.ActivityHours,
            activity = t.activity.GetRange(i * 8, Math.Min(8, t.activity.Count))
        }))
    .ToList();

请注意，

Enumerable.Range（0，count）

返回类似

[0，1，…，count-1]的
Enumerable

如果计数是8的倍数，则
（t.activity.Count-1）/8
的末尾不包含空活动的时间表

activity.GetRange（i，count）
返回一个
可枚举的
，其计数大小从活动的第i个元素开始

而
Math.Min（8，t.activity.Count）
是为了防止参数超出范围

如果要使它们独立，可以克隆它们：

var newTime = Time
    .SelectMany(t =>
        Enumerable
        .Range(0, (t.activity.Count - 1) / 8)
        .Select(i => new TimeSheet
        {
            employeeName = t.employeeName,
            ActivityHours = 
                (t.activity.Count < 8) ? 
                t.ActivityHours : 
                t.ActivityHours.Select(h => new ActivityHours
                {
                    ActivityId = h.ActivityId,
                    hours = h.hours
                }).ToList(),
            activity = t.activity.GetRange(i * 8, Math.Min(8, t.activity.Count))
        }))
    .ToList();

var newTime=时间
.SelectMany（t=>
可枚举
.范围（0，（t.activity.Count-1）/8）
.选择（i=>新时间表
{
employeeName=t.employeeName，
活动小时=
（t.activity.Count<8）？
t、 活动时间：
t、 ActivityHours.选择（h=>new ActivityHours
{
ActivityId=h.ActivityId，
小时=小时
}).ToList（），
activity=t.activity.GetRange（i*8，Math.Min（8，t.activity.Count））
}))
.ToList（）；
如果您不关心ActivityHours在不同的活动块中具有相同的引用，您可以使用以下代码：

var newTime = Time
    .SelectMany(t =>
        Enumerable
        .Range(0, (t.activity.Count - 1) / 8)
        .Select(i => new TimeSheet
        {
            employeeName = t.employeeName,
            ActivityHours = t.ActivityHours,
            activity = t.activity.GetRange(i * 8, Math.Min(8, t.activity.Count))
        }))
    .ToList();

请注意，
Enumerable.Range（0，count）
返回类似
[0，1，…，count-1]的
Enumerable

如果计数是8的倍数，则
（t.activity.Count-1）/8
的末尾不包含空活动的时间表

activity.GetRange（i，count）
返回一个
可枚举的
，其计数大小从活动的第i个元素开始

而
Math.Min（8，t.activity.Count）
是为了防止参数超出范围

如果要使它们独立，可以克隆它们：

var newTime = Time
    .SelectMany(t =>
        Enumerable
        .Range(0, (t.activity.Count - 1) / 8)
        .Select(i => new TimeSheet
        {
            employeeName = t.employeeName,
            ActivityHours = 
                (t.activity.Count < 8) ? 
                t.ActivityHours : 
                t.ActivityHours.Select(h => new ActivityHours
                {
                    ActivityId = h.ActivityId,
                    hours = h.hours
                }).ToList(),
            activity = t.activity.GetRange(i * 8, Math.Min(8, t.activity.Count))
        }))
    .ToList();

var newTime=时间
.SelectMany（t=>
可枚举
.范围（0，（t.activity.Count-1）/8）
.选择（i=>新时间表
{
employeeName=t.employeeName，
活动小时=
（t.activity.Count<8）？
t、 活动时间：
t、 ActivityHours.选择（h=>new ActivityHours
{
ActivityId=h.ActivityId，
小时=小时
}).ToList（），
activity=t.activity.GetRange（i*8，Math.Min（8，t.activity.Count））
}))
.ToList（）；
以下内容也起到了作用，但方式与@Bizhan的解决方案不同

     List<TimeSheet> SplitList = 
        TimeList.Aggregate(new List<TimeSheet>(), 
                           (accList, timeSheet) =>
                           {
                              if ((timeSheet.Activities?.Count ?? 0) > 8)
                              {
                                 accList.Add(new TimeSheet 
                                             { 
                                                EmployeeName = timeSheet.EmployeeName, 
                                                ActivityHours = timeSheet.ActivityHours.ToList(), 
                                                Activities = timeSheet.Activities.GetRange(0, 8) 
                                             });
                                 accList.Add(new TimeSheet 
                                             { 
                                                EmployeeName = timeSheet.EmployeeName, 
                                                ActivityHours = timeSheet.ActivityHours, 
                                                Activities = timeSheet.Activities.GetRange(8, timeSheet.Activities.Count - 8) 
                                             });
                              }
                              else
                              {
                                 accList.Add(timeSheet);
                              }
                              return accList;
                           },
                           accList => accList);

列表拆分列表=
TimeList.Aggregate（新列表（），
（会计科目表、时间表）=>
{
如果（（时间表.活动？.Count±0）>8）
{
accList.Add（新时间表
{ 
EmployeeName=时间表。EmployeeName，
ActivityHours=时间表.ActivityHours.ToList（），
Activities=timeSheet.Activities.GetRange（0,8）
});
accList.Add（新时间表
{ 
EmployeeName=时间表。EmployeeName，
ActivityHours=时间表。ActivityHours，
Activities=timeSheet.Activities.GetRange（8，timeSheet.Activities.Count-8）
});
}
其他的
{
accList.Add（时间表）；
}
返回会计科目表；
},
accList=>accList）；
以下内容也起到了作用，但方式与@Bizhan的解决方案不同

     List<TimeSheet> SplitList = 
        TimeList.Aggregate(new List<TimeSheet>(), 
                           (accList, timeSheet) =>
                           {
                              if ((timeSheet.Activities?.Count ?? 0) > 8)
                              {
                                 accList.Add(new TimeSheet 
                                             { 
                                                EmployeeName = timeSheet.EmployeeName, 
                                                ActivityHours = timeSheet.ActivityHours.ToList(), 
                                                Activities = timeSheet.Activities.GetRange(0, 8) 
                                             });
                                 accList.Add(new TimeSheet 
                                             { 
                                                EmployeeName = timeSheet.EmployeeName, 
                                                ActivityHours = timeSheet.ActivityHours, 
                                                Activities = timeSheet.Activities.GetRange(8, timeSheet.Activities.Count - 8) 
                                             });
                              }
                              else
                              {
                                 accList.Add(timeSheet);
                              }
                              return accList;
                           },
                           accList => accList);

列表拆分列表=
TimeList.Aggregate（新列表（），
（会计科目表、时间表）=>
{
如果（（时间表.活动？.Count±0）>8）
{
accList.Add（新时间表
{ 
EmployeeName=时间表。EmployeeName，
ActivityHours=时间表.ActivityHours.ToList（），
表演