Как я могу обнаружить недостающие элементы в IEnumerable‹T›?

Взгляните на этот вопрос для метода расширения, который выбирает последовательные значения . Оттуда вы можете сделать что-то вроде:

// I'd probably rename SelectBetween to SelectConsecutive
list.SelectConsecutive((x, y) => new { Original = x, Interval = y - x})
    .Where(pair => pair.Interval != 5)
    .Select(pair => new Interval(pair.Original + 5));

(Несколько псевдокод, но я надеюсь, вы понимаете, к чему я клоню.)

Однако это сгенерирует только один элемент, когда он отсутствует... если вы перейдете от 0 к 20, он не сгенерирует 5, 10, 15.

Чтобы добавить немного мяса ко второму предложению Хенка:

var missing = Enumerable.Range(0, expectedElementCount)
                        .Select(x => new Interval(baseInterval + 5 * x)
                        .Except(list);

Эффективным и простым способом было бы просто просмотреть этот список с помощью foreach и обнаружить пробелы.
Я полагаю, что 5-минутный такт установлен?

Чтобы использовать LINQ, вы можете создать полный список и найти разницу, но это кажется излишним.

Учитывая 2-ю часть, определяя интервал:

Из вашего примера, вероятно, подойдет образец из 3 или 4 значений. Но вы не можете быть абсолютно уверены даже после проверки всех значений. Данные вашего примера не исключают 1-минутную частоту с большим количеством пропущенных значений.

Так что вам нужны очень хорошие спецификации в отношении этой части.

Это будет работать, если интервал известен, если у вас есть доступ к Zip (поставляется с .NET 4):

list.Zip(list.Skip(1), (x,y) => new { x, delta = y - x })
    .SelectMany(a => Enumerable.Range(1, a.delta/interval - 1)
                               .Select(i => a.x + i*interval));

Обратите внимание, что это повторяет список дважды, поэтому, если источник является ленивым перечислением, вам нужно сначала его буферизовать. Эта конструкция с Zip и Skip — это быстрый и грязный способ спроецировать последовательные элементы вместе. В библиотеке System.Interactive Reactive Extensions есть метод Scan для этого, и Джон показал возможный реализация в другом ответе. Ни один из них не повторяет список дважды, поэтому они были бы гораздо лучшим выбором.

Если интервал должен быть определен, вы можете получить минимальную дельту:

var deltas = list.Zip(list.Skip(1), (x,y) => y - x );
var interval = deltas.Min();
list.Zip(deltas, (x, delta) => new { x, delta })
    .SelectMany(a => Enumerable.Range(1, a.delta/interval - 1)
                               .Select(i => a.x + i*interval));

Однако есть некоторые предположения, которые я сделал:

• все разности между элементами кратны интервалу;
• ввод отсортирован.

Как это работает:

1. Сначала он строит последовательность пар с каждым элементом, кроме последнего, и интервалом до следующего за ним элемента;
2. Затем для каждой из этих пар он создает все недостающие значения в пределах дельты: в каждой дельте есть ровно a.delta/interval - 1 значений, и каждое из них находится на определенном количестве интервалов от хранилища элементов в паре, следовательно, a.x + i*interval.
3. SelectMany заботится о том, чтобы объединить все эти последовательности отсутствующих значений в одно.

Попробуй это:

private static IEnumerable<Interval> CalculateMissingIntervals(IEnumerable<Interval> list, int step) {
  return list.Zip(list.Skip(1), 
    (i1, i2) => IntervalRange(i1.TIME_KEY + step, i2.TIME_KEY, step)).
    SelectMany(x => x);
}
private static IEnumerable<Interval> IntervalRange(int start, int end, int step) {
  for (var i = start; i < end; i += step) {
    yield return new Interval { TIME_KEY = i };
  }
}

Предполагается, что исходный список отсортирован.