C# 列表列表中的LINQ开始和停止段<；T>；元素

给定一个类的对象列表（

list

）

我想获取tuplet组（大小可变）中的开始值和停止值，以添加到第二个类的列表中（

list.add（）

）

元素的顺序确实很重要。MoreLinq作为一个选项，但不确定获取这些值所需执行的操作类型。它可以是一个分区或某种GroupBy，但这似乎不起作用

我最终需要的结果是

List2.Add(new Object() {Tuplet = TupletType.Start});
List2.Add(new Object() {Tuplet = TupletType.None});
List2.Add(new Object() {Tuplet = TupletType.Stop});
List2.Add(new Object() {Tuplet = TupletType.None});
List2.Add(new Object() {Tuplet = TupletType.None});
List2.Add(new Object() {Tuplet = TupletType.None});
List2.Add(new Object() {Tuplet = TupletType.None});
List2.Add(new Object() {Tuplet = TupletType.Start});
List2.Add(new Object() {Tuplet = TupletType.Stop});

---

下面是一个示例，其中一个用于循环

Type1 start;
Type1 stop;

for (int i=0; i<list.Length; i++)
{
  if(start == null && list[i].isbool)
    start = item[i];
  if(start != null && (i+1 == list.Length) || !list[i+1].isbool)
  //no next item or next item is false? Found the stop.
  {
    stop = item[i];//Found a start & stop, add them to a list
    start = null;
  }
}

Type1启动；
类型1停止；
for（int i=0；i这里有一个示例，其中一个for循环

Type1 start;
Type1 stop;

for (int i=0; i<list.Length; i++)
{
  if(start == null && list[i].isbool)
    start = item[i];
  if(start != null && (i+1 == list.Length) || !list[i+1].isbool)
  //no next item or next item is false? Found the stop.
  {
    stop = item[i];//Found a start & stop, add them to a list
    start = null;
  }
}

Type1启动；
类型1停止；
对于（int i=0；i可以使用扩展方法进行分组，然后可以使用：

List<Type1> runs = ...

List<Type2> grouped = new List<Type2>();
grouped.AddRange(runs.GroupByRuns());

列表运行=。。。
列表分组=新列表（）；
grouped.AddRange（runs.GroupByRuns（））；

以下是扩展方法的可能解决方案：

public static class GroupType
{
    public static IEnumerable<Type2> GroupByRuns(this IEnumerable<Type1> sequence)
    {
        if (sequence.Count() == 0)
            yield break;

        List<bool> next_items = sequence.Select(s => s.isbool).ToList();
        next_items.Add(false);

        bool previous_item = false;
        int idx = 1;
        foreach (var item in sequence)
        {
            if (item.isbool)
            {
                if (previous_item == false)
                {
                    yield return new Type2 { Tuple = Type2.TupletType.Start };
                }
                else if (next_items.ElementAt(idx) == true)
                {
                    yield return new Type2 { Tuple = Type2.TupletType.None };
                }
                else
                {
                    yield return new Type2 { Tuple = Type2.TupletType.Stop };
                }
            }
            else
            {
                yield return new Type2 { Tuple = Type2.TupletType.None };
            }
            previous_item = item.isbool;
            idx++;
        }
    }
}

公共静态类GroupType
{
公共静态IEnumerable GroupByRuns（此IEnumerable序列）
{
if（sequence.Count（）==0）
屈服断裂；
List next_items=sequence.Select（s=>s.isbool.ToList（）；
下一个项目。添加（false）；
bool上一项=false；
int-idx=1；
foreach（序列中的var项目）
{
if（项目isbool）
{
如果（上一项==false）
{
返回新的Type2{Tuple=Type2.tupletype.Start}；
}
else if（next_items.ElementAt（idx）=true）
{
返回新的Type2{Tuple=Type2.tupletype.None}；
}
其他的
{
返回新的Type2{Tuple=Type2.tupletype.Stop}；
}
}
其他的
{
返回新的Type2{Tuple=Type2.tupletype.None}；
}
上一项=item.isbool；
idx++；
}
}
}
您可以使用扩展方法进行分组，然后可以使用：

List<Type1> runs = ...

List<Type2> grouped = new List<Type2>();
grouped.AddRange(runs.GroupByRuns());

列表运行=。。。
列表分组=新列表（）；
grouped.AddRange（runs.GroupByRuns（））；

以下是扩展方法的可能解决方案：

public static class GroupType
{
    public static IEnumerable<Type2> GroupByRuns(this IEnumerable<Type1> sequence)
    {
        if (sequence.Count() == 0)
            yield break;

        List<bool> next_items = sequence.Select(s => s.isbool).ToList();
        next_items.Add(false);

        bool previous_item = false;
        int idx = 1;
        foreach (var item in sequence)
        {
            if (item.isbool)
            {
                if (previous_item == false)
                {
                    yield return new Type2 { Tuple = Type2.TupletType.Start };
                }
                else if (next_items.ElementAt(idx) == true)
                {
                    yield return new Type2 { Tuple = Type2.TupletType.None };
                }
                else
                {
                    yield return new Type2 { Tuple = Type2.TupletType.Stop };
                }
            }
            else
            {
                yield return new Type2 { Tuple = Type2.TupletType.None };
            }
            previous_item = item.isbool;
            idx++;
        }
    }
}

公共静态类GroupType
{
公共静态IEnumerable GroupByRuns（此IEnumerable序列）
{
if（sequence.Count（）==0）
屈服断裂；
List next_items=sequence.Select（s=>s.isbool.ToList（）；
下一个项目。添加（false）；
bool上一项=false；
int-idx=1；
foreach（序列中的var项目）
{
if（项目isbool）
{
如果（上一项==false）
{
返回新的Type2{Tuple=Type2.tupletype.Start}；
}
else if（next_items.ElementAt（idx）=true）
{
返回新的Type2{Tuple=Type2.tupletype.None}；
}
其他的
{
返回新的Type2{Tuple=Type2.tupletype.Stop}；
}
}
其他的
{
返回新的Type2{Tuple=Type2.tupletype.None}；
}
上一项=item.isbool；
idx++；
}
}
}
我不完全清楚您想做什么。如果您能发布能够实际编译的代码，或者您在解决问题时所做的任何尝试，这将是非常有帮助的。我必须获得的工作代码有点相互关联，无法达到目的。我将添加一点来显示我的期望。我只是使用for循环迭代列表，不需要linq。如果找到“true”，则将其另存为start。运行直到下一个为false。如果是，则将其设置为stop。因此，给定一个具有
bool
属性的对象列表，您希望返回一个包含对象的
Tuple
和一个
bool
，其中对象是start和e属性列表中的nd次运行为
true
和
Tuple
中相应的
bool
值将告诉您该对象是所述运行的开始还是结束？@juharr我需要添加第一个序列的所有元素，并标记启动和停止子序列的某些元素。我不完全清楚是什么至少，您正在尝试这样做。如果您可以发布能够实际编译的代码，或者您在解决问题时所做的任何尝试，这将是非常有帮助的。我必须到达该序列的工作代码有点相互关联，无法到达该序列。我将添加一点来显示我所期望的内容。我只需使用for l遍历列表oop，不需要linq。如果找到“true”，则将其另存为start。运行直到下一个为false。如果是，则将其设置为stop。因此，给定一个具有
bool
属性的对象列表，您希望返回一个
Tuple
，其中包含对象和
bool
，其中对象是pro列表中运行的开始和结束perty为
true
和
元组中相应的
bool
值将告诉您该对象是所述运行的开始还是结束？@juharr我需要添加第一个序列的所有元素，并标记启动和停止子序列的某些元素。如果我在
//找到启动和停止，将它们添加到在
stop=item[i]
和
start=null
之间的一个列表
，这些项将是无序的。另外，常规的非元组项是否超出了两个
if
语句的范围？如果我在
//找到一个start&stop=item[i]处添加它们，则将它们添加到列表中
和
start=null
，项将无序。此外，常规非元组项是否超出两个
if
语句？