C# 提取列表中相同编号的前10个条目<；类别>；使用foreach循环

我有一个类型

NumberList

的集合

public class NumberList
{
    public int Number { get; set; }
    public double Profit { get; set; }
    public DateTime CloseTime { get; set; }
}

所有记录都存储在NumberList中，并按数字和日期降序排列

现在我需要在整个列表中循环搜索有10个条目的数字，并将它们存储在新列表中

26724, -6.55, 18-Jul-19 08:32:30
26724, 12.21, 20-Jun-19 03:54:56
26724, -6.53, 14-Jun-19 20:09:28
26724, 12.15, 31-May-19 17:13:25
26724, 0.98, 21-May-19 09:00:01
26724, 4.21, 15-May-19 07:02:02
26724, -6.56, 08-May-19 18:00:43
26724, -7.35, 24-Apr-19 18:40:25
26724, -6.59, 04-Apr-19 21:08:40
18450, 6.79, 18-Jul-19 22:16:26
18450, 6.69, 20-Jun-19 03:31:27
18450, 6.82, 14-Jun-19 09:57:16
18450, 6.66, 31-May-19 20:27:05
18450, -0.28, 13-May-19 15:59:08
18450, -5.95, 08-May-19 18:00:01
18450, -3.53, 24-Apr-19 12:00:42
18450, -6.05, 04-Apr-19 21:00:03
16822, 10.38, 11-Jul-19 04:56:27
16822, 9.88, 27-Jun-19 09:00:00
16822, 0.43, 17-Jun-19 16:00:02
16822, -2.36, 11-Jun-19 04:00:00
16822, -9.82, 05-Jun-19 20:08:02
16822, 13.31, 31-May-19 21:06:21
16822, 1.49, 22-May-19 10:00:02
16822, -2.8, 17-May-19 12:00:01
16822, -8.8, 13-May-19 15:07:46
16822, -8.43, 10-May-19 21:49:31
16822, -5.84, 03-May-19 16:45:26
16822, -4.91, 01-May-19 21:38:06
16822, -0.58, 01-May-19 06:00:03
16822, -1.43, 26-Apr-19 13:00:01
16822, -4.4, 25-Apr-19 10:11:29
16822, -3.58, 23-Apr-19 16:26:34
16822, -0.97, 18-Apr-19 00:01:36
16822, -2.8, 11-Apr-19 14:00:31
16822, 2.48, 05-Apr-19 13:00:15
16822, 0.2, 04-Apr-19 00:01:44
...... etc

我的问题是，我得到的是10个值，但不是同一个数字，比如26724有9个条目，他取下一个18450，并将其添加到列表中，因为它缺少1。它需要重置

模板列表

并继续下一个数字，而不是添加其他数字，因为它只有9个条目

如何提取相同编号的前10个条目并将其添加到新列表中

以下是代码：

var tempList = new List<NumberList>(); // temporary list
var finalList = new List<NumberList>(); // new list where we store final results

foreach (var item in NumberList)
{
    tempList.Add(item); // add numbers to temp list

    // if temlist contains Number and number of items in list is less then 10
    if (tempList.Contains(item) && tempList.Count() < 10)
    {
        finalList.Add(item);
    }
    else
    {
        if (tempList.Count() == 10) // check for number of items in list
        {
            tempList.Clear(); // reset tempList
        }
    }
}

因此，我们的新列表应该如下所示：

16822, 10.38, 11-Jul-19 04:56:27
16822, 9.88, 27-Jun-19 09:00:00
16822, 0.43, 17-Jun-19 16:00:02
16822, -2.36, 11-Jun-19 04:00:00
16822, -9.82, 05-Jun-19 20:08:02
16822, 13.31, 31-May-19 21:06:21
16822, 1.49, 22-May-19 10:00:02
16822, -2.8, 17-May-19 12:00:01
16822, -8.8, 13-May-19 15:07:46
16822, -8.43, 10-May-19 21:49:31

---

您可以使用Linq来实现这一点。比如说,

var finalList = numberList
    .GroupBy(a => a.Number)
    .Where(a => a.Count() >= 10)
    .SelectMany(a => a.OrderBy(b => b.CloseTime).Take(10))
    .ToList();

---

因此，首先我们使用

GroupBy

按数字分组。然后，我们使用

限制仅包含10个或更多条目的分组，其中（a=>a.Count（）>=10）

。然后我们使用

SelectMany

来展平分组，并使用

Take

选择每个分组的前10个元素，使用

OrderBy

来确保它们的顺序一致。

您可以使用Linq来做到这一点。比如说,

var finalList = numberList
    .GroupBy(a => a.Number)
    .Where(a => a.Count() >= 10)
    .SelectMany(a => a.OrderBy(b => b.CloseTime).Take(10))
    .ToList();

因此，首先我们使用

GroupBy

按数字分组。然后，我们使用

限制仅包含10个或更多条目的分组，其中（a=>a.Count（）>=10）

。然后我们使用

SelectMany

来展平分组，并使用

Take

选择每个分组的前10个元素，使用

OrderBy

确保它们的顺序一致

现在我需要在整个列表中循环搜索有10个条目的数字，并将它们存储在新列表中

26724, -6.55, 18-Jul-19 08:32:30
26724, 12.21, 20-Jun-19 03:54:56
26724, -6.53, 14-Jun-19 20:09:28
26724, 12.15, 31-May-19 17:13:25
26724, 0.98, 21-May-19 09:00:01
26724, 4.21, 15-May-19 07:02:02
26724, -6.56, 08-May-19 18:00:43
26724, -7.35, 24-Apr-19 18:40:25
26724, -6.59, 04-Apr-19 21:08:40
18450, 6.79, 18-Jul-19 22:16:26
18450, 6.69, 20-Jun-19 03:31:27
18450, 6.82, 14-Jun-19 09:57:16
18450, 6.66, 31-May-19 20:27:05
18450, -0.28, 13-May-19 15:59:08
18450, -5.95, 08-May-19 18:00:01
18450, -3.53, 24-Apr-19 12:00:42
18450, -6.05, 04-Apr-19 21:00:03
16822, 10.38, 11-Jul-19 04:56:27
16822, 9.88, 27-Jun-19 09:00:00
16822, 0.43, 17-Jun-19 16:00:02
16822, -2.36, 11-Jun-19 04:00:00
16822, -9.82, 05-Jun-19 20:08:02
16822, 13.31, 31-May-19 21:06:21
16822, 1.49, 22-May-19 10:00:02
16822, -2.8, 17-May-19 12:00:01
16822, -8.8, 13-May-19 15:07:46
16822, -8.43, 10-May-19 21:49:31
16822, -5.84, 03-May-19 16:45:26
16822, -4.91, 01-May-19 21:38:06
16822, -0.58, 01-May-19 06:00:03
16822, -1.43, 26-Apr-19 13:00:01
16822, -4.4, 25-Apr-19 10:11:29
16822, -3.58, 23-Apr-19 16:26:34
16822, -0.97, 18-Apr-19 00:01:36
16822, -2.8, 11-Apr-19 14:00:31
16822, 2.48, 05-Apr-19 13:00:15
16822, 0.2, 04-Apr-19 00:01:44
...... etc

Foeach不太适合做这项工作。 你需要2个循环。每个（不同）项目编号一个，一个用于比较。因为您的集合是有序的，所以可以使用它来避免对基本集合进行多次迭代。每次新系列开始时，您都可以记住索引结束内部循环，并在外部循环中跳转到记住的位置：

for (int i = 0; i < NumberList.Count; i++)
{
    tempList.Clear();
    for (int j = i+1; j < NumberList.Count; j++)
    {
        if (NumberList[i].Number == NumberList[j].Number)
        {
            tempList.Add(NumberList[i]);                
        }
        else
        {
            // Note that a new series of numbers has began and jump to this position
            i = j;
            break; // end this counting procedure
        }
    }

    // at this point evalueate the counter
    if (tempList.Count >= 10)
    {
        finalList.AddRange(tempList.Take(10));
    }       
}

只需将具有相同值的所有数字收集到分组集合中
然后在它上面应用一个过滤器，检查哪一个符合你的标准10次或更多
然后只选择那些项目/将其解组，只取前10个

var tempList = new List<NumberList>(); // temporary list

var finalList = tempList.GroupBy(t => t.Number)
            .Where(t => t.Count() >= 10)
            .SelectMany(t => t.Take(10)) //take 10 elements from filtered data
            .ToList();

现在我需要在整个列表中循环搜索有10个条目的数字，并将它们存储在新列表中

26724, -6.55, 18-Jul-19 08:32:30
26724, 12.21, 20-Jun-19 03:54:56
26724, -6.53, 14-Jun-19 20:09:28
26724, 12.15, 31-May-19 17:13:25
26724, 0.98, 21-May-19 09:00:01
26724, 4.21, 15-May-19 07:02:02
26724, -6.56, 08-May-19 18:00:43
26724, -7.35, 24-Apr-19 18:40:25
26724, -6.59, 04-Apr-19 21:08:40
18450, 6.79, 18-Jul-19 22:16:26
18450, 6.69, 20-Jun-19 03:31:27
18450, 6.82, 14-Jun-19 09:57:16
18450, 6.66, 31-May-19 20:27:05
18450, -0.28, 13-May-19 15:59:08
18450, -5.95, 08-May-19 18:00:01
18450, -3.53, 24-Apr-19 12:00:42
18450, -6.05, 04-Apr-19 21:00:03
16822, 10.38, 11-Jul-19 04:56:27
16822, 9.88, 27-Jun-19 09:00:00
16822, 0.43, 17-Jun-19 16:00:02
16822, -2.36, 11-Jun-19 04:00:00
16822, -9.82, 05-Jun-19 20:08:02
16822, 13.31, 31-May-19 21:06:21
16822, 1.49, 22-May-19 10:00:02
16822, -2.8, 17-May-19 12:00:01
16822, -8.8, 13-May-19 15:07:46
16822, -8.43, 10-May-19 21:49:31
16822, -5.84, 03-May-19 16:45:26
16822, -4.91, 01-May-19 21:38:06
16822, -0.58, 01-May-19 06:00:03
16822, -1.43, 26-Apr-19 13:00:01
16822, -4.4, 25-Apr-19 10:11:29
16822, -3.58, 23-Apr-19 16:26:34
16822, -0.97, 18-Apr-19 00:01:36
16822, -2.8, 11-Apr-19 14:00:31
16822, 2.48, 05-Apr-19 13:00:15
16822, 0.2, 04-Apr-19 00:01:44
...... etc

Foeach不太适合做这项工作。 你需要2个循环。每个（不同）项目编号一个，一个用于比较。因为您的集合是有序的，所以可以使用它来避免对基本集合进行多次迭代。每次新系列开始时，您都可以记住索引结束内部循环，并在外部循环中跳转到记住的位置：

for (int i = 0; i < NumberList.Count; i++)
{
    tempList.Clear();
    for (int j = i+1; j < NumberList.Count; j++)
    {
        if (NumberList[i].Number == NumberList[j].Number)
        {
            tempList.Add(NumberList[i]);                
        }
        else
        {
            // Note that a new series of numbers has began and jump to this position
            i = j;
            break; // end this counting procedure
        }
    }

    // at this point evalueate the counter
    if (tempList.Count >= 10)
    {
        finalList.AddRange(tempList.Take(10));
    }       
}

只需将具有相同值的所有数字收集到分组集合中
然后在它上面应用一个过滤器，检查哪一个符合你的标准10次或更多
然后只选择那些项目/将其解组，只取前10个

var templast=new List（）；//临时名单
var tempList = new List<NumberList>(); // temporary list

var finalList = tempList.GroupBy(t => t.Number)
            .Where(t => t.Count() >= 10)
            .SelectMany(t => t.Take(10)) //take 10 elements from filtered data
            .ToList();

var finalList=templast.GroupBy（t=>t.Number）
.Where（t=>t.Count（）>=10）
.SelectMany（t=>t.Take（10））//从过滤后的数据中提取10个元素
.ToList（）；

var templast=new List（）；//临时名单
var finalList=templast.GroupBy（t=>t.Number）
.Where（t=>t.Count（）>=10）
.SelectMany（t=>t.Take（10））//从过滤后的数据中提取10个元素
.ToList（）；

您可以在字段编号上进行distinct，并使用distinct的结果循环对象

 foreach (var item in numList.Select(x=> x.Number).Distinct())
        {
             int counter = 0;
              if(numList.Where(x=> x.Number.Equals(item)).Count() >= 10 )
              { 
                  foreach( var item2 in numList.Where(x=> x.Number.Equals(item)) ){
                      if(counter <10 ) {
                          finalList.Add(item2);
                          counter ++;
                      }
                  }
              }
        }
        foreach(var test in finalList)
            Console.WriteLine(string.Format("{0}, {1}", test.Number, test.Profit));

foreach（numList.Select（x=>x.Number）.Distinct（）中的变量项）
{
int计数器=0；
if（numList.Where（x=>x.Number.Equals（item））.Count（）>=10）
{ 
foreach（numList.Where（x=>x.Number.Equals（item））中的var item2）{
如果（计数器您可以对字段编号进行distinct，并使用distinct的结果循环对象

 foreach (var item in numList.Select(x=> x.Number).Distinct())
        {
             int counter = 0;
              if(numList.Where(x=> x.Number.Equals(item)).Count() >= 10 )
              { 
                  foreach( var item2 in numList.Where(x=> x.Number.Equals(item)) ){
                      if(counter <10 ) {
                          finalList.Add(item2);
                          counter ++;
                      }
                  }
              }
        }
        foreach(var test in finalList)
            Console.WriteLine(string.Format("{0}, {1}", test.Number, test.Profit));

foreach（numList.Select（x=>x.Number）.Distinct（）中的变量项）
{
int计数器=0；
if（numList.Where（x=>x.Number.Equals（item））.Count（）>=10）
{ 
foreach（numList.Where（x=>x.Number.Equals（item））中的var item2）{
如果（计数器是否也需要linw解决方案，或者是否要修复循环？如果10次以上存在多个范围，输出应该是什么样的？我愿意接受任何解决方案。这个问题需要澄清一下-
搜索有10个条目的数字的意思是什么。
Number
是一个int，它怎么可能有多个条目？你是说列表中的条目的数值=10吗？还有，什么是圣殿骑士？@aelagawy有一个包含20000个条目的列表，在这个列表中有一个包含10个条目或更多条目的20个数字。你是否也想要一个linw解决方案，或者你想修复你的循环？如果有呢如果超过10次存在多个范围，那么输出应该是什么样的？我愿意接受任何解决方案。这个问题需要澄清一下-
搜索有10个条目的数字是什么意思。
数字是一个整数，它怎么可能有多个条目？您是指列表中有数字va的条目吗lue=10？还有，什么是圣殿骑士？@aelagawy有一个包含20000个条目的列表，在这个列表中有一个包含10个条目或更多条目的20个数字。谢谢，这是我需要的，这很有效，很好的解释。@Mario我编辑了我的回答，并发布了一个只包含10个条目的完整循环解决方案。linq解决方案也被编辑了只带10件，谢谢