List <>上的递归循环导致计算器溢出

Question

我有一个包含两个字符串和一个DateTime的对象的List<>。我想创建另一个只包含最后一个唯一项目的对象列表，使用两个字符串作为键和最后一个DateTime值。在SQL中，请考虑以下内容：

SELECT col1, col2, MAX(datetime) FROM table GROUP BY col1, col2 

这给出了col1，col2和最后一个datetime的唯一列表。所以..我试图用两个列表的代码来做到这一点。其中有一个重复项，它解析并抓取最后一个唯一项目以填充第二个列表。

我拥有的数据集非常庞大，只需通过重复列表，然后检查项目是否在唯一列表中，如果它没有添加它，如果是，比较日期等。所以我想我可以通过递归遍历重复列表并获取唯一项目，找到它们的最大日期时间，并在我循环时删除非最大值列表，从而使我的重复列表变得越来越小，从而加快速度。 （我希望你仍然跟着我..）

所以无论如何。我写了一个带有两个列表的递归循环，但是当我循环时，我在第3000次迭代中得到了一个System.StackOverflowException。

这是我的代码。想象一下ListWithDuplicates充满了数据。实际的ListDataItem有更多我遗漏的属性。但我的主要问题是为什么我不能通过这种方式循环通过public list而不会导致StackOverflowException？

using System; 
using System.Net; 
using System.IO; 
using System.Collections.Generic; 
using System.Linq; 

public class RecursionTest 
{ 
    public List<listDataItem> ListWithDuplicates { get; set; } 
    public List<listDataItem> ListWithUniques { get; set; } 

    public RecursionTest() 
    { 
     Process(); 
    } 

    public void Process() 
    { 
     int rowcount = 0; 
     int duplicates = 0; 
     int total = 0; 
     RecursiveLoopForUnique(ref rowcount, ref duplicates, ref total, "", ""); 
    } 

    private void RecursiveLoopForUnique(ref int rowcount, ref int duplicates, ref int total, string col1, string col2) 
    { 
     if (rowcount > 0) 
      duplicates += ListWithDuplicates.RemoveAll(z => z.COL1 == col1 && z.COL2 == col2); 
     if (ListWithDuplicates.Count > 0) 
     { 
      foreach (listDataItem item in ListWithDuplicates) 
      { 
       rowcount++; 
       if (ListWithUniques.FindAll(z => z.COL1 == item.COL1 && z.COL2 == item.COL2).Count < 1) 
       { 
        ListWithUniques.Add(ListWithDuplicates.FindAll(z => z.COL1 == item.COL1 && z.COL2 == item.COL2).OrderByDescending(z => z.DATETIME).First()); 
        col1 = item.COL1; 
        col2 = item.COL2; 
        break; 
       } 
      } 
      RecursiveLoopForUnique(ref rowcount, ref duplicates, ref total, col1, col2); 
     } 
     else 
      return; 
    } 

    public class listDataItem 
    { 
     public string COL1 { get; set; } 
     public string COL2 { get; set; } 
     public DateTime DATETIME { get; set; }    

     public listDataItem(string col1, string col2, DateTime datetime) 
     { 
      COL1 = col1; 
      COL2 = col2; 
      DATETIME = datetime; 
     } 
    } 
} 

Answer 1

这样如何：

Dictionary<string, item> destDict = new Dictionary<string, item>(); 

foreach (item curr in items) 
{ 
    string key = curr.col1 + curr.col2; 
    if (!destDict.Keys.Contains(key)) 
    { 
     destDict.Add(key, curr); 
    } 
    else 
    { 
     if (destDict[key].date < curr.date) 
     { 
      destDict[key].date = curr.date; 
     } 
    } 
} 

我测试该含1000每个的两个独特的COL1/COL2对列表上。工作得很好，比LINQ groupby/select更快。

Answer 2

LINQ，yay。

listDataItem latestListDataItem = 
    ListWithDuplicates.Where(item => item.COL1 == yourCol1Param && item.COL2 == yourCol2Param) 
         .Max(item => item.DATETIME); 

MSDN便签..

其中：http://msdn.microsoft.com/en-us/library/bb534803.aspx

最大：http://msdn.microsoft.com/en-us/library/bb347632.aspx

排序依据：http://msdn.microsoft.com/en-us/library/bb534966.aspx

末：http://msdn.microsoft.com/en-us/library/bb358775.aspx

Answer 3

我不是苏关于语法，但它应该接近。

from d in DupsList 
group d.DATETIME on d.col1, d.col2 in grp 
select new listDataItem (grp.Key.col1, grp.Key.col2, grp.Max()}; 

Answer 4

好吧，如果你有超过几千个唯一对C1，C2的越多，那么你会遇到这样的，因为你的每一个独特的群体递归一次。

有很多方法可以解决这个问题;一个会更清晰更快的结果是按C1和C2对列表进行排序，然后精确地查找一次，以找出每个组中的最近日期。如果你不执着于自己的重新实现它，最好的办法是这样的：

ListWithUniques = ListWithDuplicates 
    .GroupBy(x => new { COL1, COL2 }) 
    .Select(g => g.OrderByDescending(x => x.DATETIME).First()) 

Answer 5

SELECT col1, col2, MAX(datetime) FROM table GROUP BY col1, col2 

在LINQ：

var query = from row in table 
      group row into g 
      select new 
      { 
       Col1 = g.Key.Col1, 
       Col2 = g.Key.Col2, 
       Date = g.Max(b => b.Date) 
      }; 

而且在可能更有用的形式：

var dict = query.ToDictionary(a => new { a.Col1, a.Col2 }, a => a.Date); 

然后你可以这样引用它：

DateTime specificMaxDate = dict[new { Col1 = 2, Col2 = 3 }];