Для гуру производительности LINQ — поиск в неуниверсальной коллекции ICollection

ИЗМЕНИТЬ

На утверждение, что ответ dasblinkenlight в целом правильный, я написал быструю общую вспомогательную функцию.

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];
        });

Ваш "запрос" неверен. На самом деле вы выбираете кучу логических значений, но не фильтруете. Вы хотите:

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);

Как и Крис, я потрясен тем, что на любую реализацию потребуется больше минуты...

Это первое утверждение:

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);
}