Question

我需要搜索包含时间属性的“Item”对象集合。我有一个快速的解决方案，但它非常凌乱（如果没有更好的事情会发布）。以下是我尝试使用LINQ和诸如此类的方法进行搜索。

在我的特定情况下，我知道项目根据时间从低到高排序。当我遍历它们时，它是9 / 12,9 / 13,9 / 14。我想找到一个快速的解决方案，即使这不是有序的，但现在也不重要。

//ICollection c = GetCollection(); //25,000+ items
DateTime TIME = DateTime.Now.AddDays(-1);

EventLog scan = new EventLog("Application", "Server", "N/A");
EventLogCollection c = scan.Entries;
Console.WriteLine(logs.Count); // All entries already in list here

// 64 sec - SLOW
List<Item> l1 = new List<Item>();
foreach (Item i in c) { 
  if (i.time > TIME) { 
    l1.Add(i); }
}

// 93 sec - SLOWER
var l2 = c.Cast<Item>().AsParallel().Select(n => n.time > TIME);
var i = l2.Count();

// 98 sec - EVEN SLOWER!
List<Item> l3 = new List<Item>();
Parallel.ForEach(c.Cast<Item>(), n => {
    if (n.time > TIME) {
        l3.add(n);
    }
});

我目前的解决方案是为开始和结束时间做一个BinarySearch，并根据这些索引循环ICollection。它非常快（1-2秒）但非常凌乱。我不需要一个不同的解决方案，但我想我会把这个解决方案告诉你的性能专家。

有没有更快，更优雅的方式来搜索ICollection？ BTW我无法控制我给出的集合，也无法改变它的结构。 .NET 4.0

不，我不能使用System.Diagnostics.Eventing.Reader，因为我坚持使用Windows XP

Answer 1

您的“查询”不正确。你实际上是在选择一堆布尔值，而不是过滤。你想要：

var l2 = c.Cast<EventLogEntry>().AsParallel().Where(n => n.time > TIME);

此可能不会更快，但值得检查。哎呀，我甚至不会同时开始这样做。

实际上，Count有一个带谓词的重载，所以你可以使用它：

var count = c.Cast<EventLogEntry>().Count(n => n.time > TIME);

或并行版本：

var count = c.Cast<EventLogEntry>().AsParallel().Count(n => n.time > TIME);

像克里斯一样，我很震惊，任何实施都会花费一分钟......

Answer 2

修改

关于dasblinkenlight's answer一般是正确的断言，我写了一个快速的通用辅助函数。

public static int BinaryFirstIndexOf<T>( Func<int, T> indexer, Func<T, boo> predicate, int count) { var low = 0; var high = count - 1; while (low < (high - 1)) { var mid = low + ((high - low) / 2); if (predicate(indexer(mid)) { high = mid; } else { low = mid; } } if (predicate(indexer(low))) { return low; } if (low != high && predicate(indexer(high))) { return high; } return -1; }

我会像这样使用，

var time = DateTime.Now.AddDays(-1); var c = scan.Entries; var first = BinaryFirstIndexOf( i => c[i], e => e.TimeGenerated > time, c.Count); if (first >= 0) { var result = new List<Item>(c.Count - first); Enumerable.Range(first, c.Count - first).AsParallel() .ForAll(i => { var j = i - first; result[j] = (Item)c[i]; }); }

你不想做这样的事吗

var time = DateTime.Now.AddDays(-1); var c = scan.Entries; var cutOff = 0; for (var i = c.Count - 1; i > - 1; i--) { if (c[i].TimeGenerated < time) { cutOff = i; break; } } var result = new List<Item>(c.Count - cutOff - 1); var j = 0; for (var i = cutOff + 1; i < c.Count; i ++) { result[j] = (Item)c[i]; j++; }

我假设您想要的数据在最后，占用的数量少于收集的一半。

或者也许使用linq并行进行投射，

var time = DateTime.Now.AddDays(-1); var c = scan.Entries; var cutOff = 0; for (var i = c.Count - 1; i > - 1; i--) { if (c[i].TimeGenerated < time) { cutOff = i; break; } } var result = new List<Item>(c.Count - cutOff - 1); Enumerable.Range(cutOff + 1, c.Count - cutOff - 1).AsParallel() .ForAll(i => { var j = i - cutOff - 1; result[j] = (Item)c[i]; });

Answer 3

这是第一个声明：

List<Item> l1 = new List<Item>();
foreach (Item i in c) { 
  if (i.time > TIME) { 
    l1.Add(i); }
}

它是否会改善性能改变为（将在运行foreach之前过滤列表）：

List<Item> l1 = new List<Item>();
foreach (Item i in c.Where(a => a.time > TIME)) { 
    l1.Add(i);
}

对于LINQ Performance Gurus-通过非通用ICollection进行搜索

3 个答案: