Escribí un método de extensión LINQSplitBetween análogo aString.Split.

> new List<int>(){3,4,2,21,3,2,17,16,1}
> .SplitBetween(x=>x>=10)

[3,4,2], [3,2], [], [1]

Fuente:

// partition sequence into sequence of contiguous subsequences
// behaves like String.Split
public static IEnumerable<IEnumerable<T>> SplitBetween<T>(this IEnumerable<T> source, 
                                                          Func<T, bool> separatorSelector, 
                                                          bool includeSeparator = false)
{
    var l = new List<T>();
    foreach (var x in source)
    {
        if (separatorSelector(x))
        {
            if (includeSeparator)
            {
                l.Add(x);
            }
            yield return l;
            l = new List<T>();
        }
        else
        {
            l.Add(x);
        }
    }
    yield return l;
}

En el espíritu de LINQ, creo que este método debería hacer una evaluación perezosa. Sin embargo,mi implementación hace una evaluación perezosa sobre el IEnumerable externo, perono sobre el IEnumerable interno. ¿Cómo puedo arreglar esto?

Una demostración de cómo el comportamiento externo es perezoso. AsumirThrowingEnumerable<int> es unIEnumerable<int> eso explota cuando alguien intenta iterar sobre él (ver Edulinq de Skeet).

(new List<int>(){1,2,3,10,1})
.Concat(Extensions.ThrowingEnumerable<int>())
.SplitBetween(x=>x>=10)
.First().ToList();

[1,2,3]

pero el comportamiento interiorno es perezoso

(new List<int>(){1,2,3,10,1})
.Concat(Extensions.ThrowingEnumerable<int>())
.SplitBetween(x=>x>=10)
.ElementAt(2).First();

BOOM

Esperamos 1 aquí.