Eu escrevi um método de extensão LINQSplitBetween semelhante aString.Split.

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

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

Fonte:

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

No espírito do LINQ, acho que esse método deveria fazer uma avaliação preguiçosa. Contudo,minha implementação faz avaliação preguiçosa sobre o IEnumerable externo, masnão sobre o IEnumerable interno. Como posso consertar isso?

Uma demonstração de como o comportamento externo é preguiçoso. AssumirThrowingEnumerable<int> é umIEnumerable<int> que explode quando alguém tenta iterar sobre ele (veja Edulinq do Skeet).

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

[1,2,3]

mas o comportamento internonão é preguiçoso

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

BOOM

Nós esperamos 1 aqui.