LINQ + Найти количество ненулевых значений

Question

У меня есть таблица со следующей структурой.

ID VALUE
1 3.2
2 NULL
4 NULL
5 NULL
7 NULL
10 1,8
11 NULL
12 3.2
15 4.7
17 NULL
22 NULL
24 NULL
25 NULL
27 NULL
28 7

Я хотел бы получить максимальное количество последовательных нулевых значений в таблице.

Любая помощь будет принята с благодарностью.

БЛАГОДАРЯ Ashutosh

Answer 1

Вы всегда можете сделать это трудным путем и просто перебрать коллекцию, как только она будет возвращена.

Простой алгоритм

for each item in collection
   if element null
      increment counter
   if element not null
      compare counter to existing max, update as necessary
      reset counter

display or otherwise use max

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

Answer 2

Как насчет (C # я боюсь):

var count = data.Aggregate(new { tmp = 0, max = 0 }, (current, item) => 
     item.Value == null ? new { tmp = current.tmp + 1, 
                                max = Math.Max(current.tmp + 1, current.max) }
                        : new { tmp = 0, current.max }).max;

Другими словами, мы всегда сохраняем текущий счетчик и максимальное значение по мере продвижения. Заметьте, это довольно ужасно. Похоже, что он работает с примерами данных, которые вы дали ...

Я не уверен, будет ли это работать с LINQ to SQL, заметьте. Обратите внимание, что вам нужно указать порядок еще до того, как он станет понятен - таблицы базы данных являются «наборами» без понятия последовательных значений.

Answer 3

Действительно ли таблица упорядочена осмысленно?

Я думаю, чтобы сделать это аккуратно, вам нужен оператор группировки, который работает не так, как GroupBy, что-то вроде GroupConsecutive, поэтому все отдельные группы хранятся отдельно, а не объединяются, если у них одинаковый ключ.

К сожалению, мой VB ржавый или вообще не существует, но вы можете мысленно преобразовать это:

public static class X
{
    private class Grouping<K, V> : List<V>
    {
        public K Key { get; set; }
    }

    public static IEnumerable<IGrouping<TKey, TValue>> GroupConsecutive(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector)
    {
        Grouping current = null;

        foreach (var elem in source)
        {
            var key = keySelector(elem);
            if (current == null || !current.Key.Equals(key))
            {
                if (current != null)
                    yield return current;
                current = new Grouping { Key = key };
            }

            current.Add(elem);
        }

        if (current != null)
            yield return current;

    }
}

Теперь вы можете сказать:

table.GroupConsecutive(r => r.Value).Where(g => g.Key == null).Max(g => g.Count);

Здесь таблица обрабатывается как IEnumerable, так что все это происходит в памяти.

Возможно, вам лучше сделать это в сыром SQL, если это так.