Есть ли лучший способ получить подпоследовательности, в которых каждый элемент соответствует предикату?

Насколько я знаю, нет встроенного метода. Однако вызов метода расширения Count для IEnumerable не очень эффективен, поскольку он должен перечислять список, чтобы получить количество. Поэтому я придумал это, которое имеет тот же эффект.

public static IEnumerable<IEnumerable<T>> 
    GetSequences<T>(this IEnumerable<T> source, Func<T, bool> selector)
{
    // omitted null checks for brevity
    var list = new List<T>();

    foreach(var item in source)
    {
        if (selector.Invoke(item))
        {
            list.Add(item);
        }
        else if (list.Count > 0)
        {
            yield return list;
            list = new List<T>();
        }
    }

    if (list.Count > 0)
        yield return list;
}

Как упомянул Джон Скит, использование SkipWhile и TakeWhile также кажется довольно неэффективным в этом случае, поскольку они будут создавать итератор за итератором за итератором. Вы можете проверить это, так как при отладке вашего примера он немного сходит с ума, когда вы проходите через него, пытаясь найти следующую последовательность и так далее, хотя пример простой.

Я подозреваю, что ваш код не будет работать во всех случаях. В частности, SkipWhile и TakeWhile оцениваются лениво — если вызывающий код на самом деле не считывает все выданные IEnumerable<T>s (или, что еще хуже, буферизует их и читает в другом порядке!), я сильно подозреваю, что вы ошибетесь. полученные результаты.

Я подозреваю, что вам действительно нужно сделать что-то вроде:

public static IEnumerable<IEnumerable<T>> GetSequences<T>(
    this IEnumerable<T> source,
    Func<T, bool> selector)
{
    List<T> current = new List<T>();
    foreach (T element in source)
    {
        if (selector(element))
        {
            current.Add(element);
        }
        else if (current.Count > 0)
        {
            yield return current;
            current = new List<T>();
        }           
    }
    if (current.Count > 0)
    {
        yield return current;
    }
}

(При этом игнорируется проверка ошибок — из-за отложенного выполнения блоков итераторов вы захотите сделать это в отдельном методе, который затем вызывает этот метод как частный — это очень распространенный шаблон при написании блоков итераторов производственного качества.)

Кстати, выбор List<T> несколько произволен - например, вместо него вы могли бы использовать LinkedList<T>. Или, если вы выбираете список, вы можете вернуть IEnumerable<IList<T>> вместо IEnumerable<IEnumerable<T>>, что может облегчить вызывающим сторонам обработку результатов.

Не уверен, что знаю, о чем говорю, но это не помешает мне говорить...

Имеет ли смысл определять новый тип итератора, который может переходить к следующей подпоследовательности, когда текущая завершена?

Используя примеры синтаксиса Java и Integer, клиентский код выглядит следующим образом:

Iterator2<Integer> iter = getSequencences(someCollection, someCriteria)
while (iter.hasNextSequence())
{
  iter.nextSequence();
  while (iter.hasNext())
  {
    Integer i = iter.next();
  }
}

*утки*

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

Я бы, вероятно, использовал версию, представленную Гарри и Джоном, поскольку она проще и выполняет свою работу, но писать ее было весело.

public static class Program
{
    static IEnumerable<IEnumerable<T>>
        GetSequences<T>(this IEnumerable<T> source, Func<T, bool> selector)
    {
        var enumerator = source.GetEnumerator();
        while (enumerator.MoveNext())
            if (selector(enumerator.Current))
                yield return TakeWhile(enumerator, selector);
        yield break;
    }

    static IEnumerable<T> 
        TakeWhile<T>(IEnumerator<T> enumerator, Func<T, bool> selector)
    {
        do
        {
            yield return enumerator.Current;
        } while (enumerator.MoveNext() && selector(enumerator.Current));
        yield break;
    }

    static void Main()
    {
        var nums = new[] { 2, 1, 42, 0, 9, 6, 5, 3, 8 };
        var seqs = nums.GetSequences(i => i < 6);

        Console.WriteLine(string.Join(",", seqs.Select(s =>
            string.Format("{{{0}}}",
                string.Join(",", s.Select(i => i.ToString()).ToArray())
            )).ToArray()));
    }
}

Вы можете использовать тот факт, что GroupBy будет обрабатывать элементы последовательно.

    public static IEnumerable<IEnumerable<T>> GetSequences<T>
      (this IEnumerable<T> source, Func<T, bool> predicate)
    {
        bool flag = false;
        int id = 0;
        return source.GroupBy(x =>
            {
                bool match = predicate(x);
                if (match != flag)
                {
                    id += 1;
                    flag = match;
                }
                return new { keep = match, id = id };
            })
            .Where(g => g.Key.keep)
            .Select(g => g.AsEnumerable());
    }

Вот тестовый метод:

    public static void Test1()
    {
        List<int> myList = new List<int>() {2,1,42,0,9,6,5,3,8};

        foreach (var g in myList.GetSequences(i => i < 6))
        {
            Console.WriteLine("g");
            foreach (int i in g)
            {
                Console.WriteLine(i);
            }
        }
    }