Ich habe eine LINQ-Erweiterungsmethode geschriebenSplitBetween analog zuString.Split.

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

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

Quelle:

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

Im Geiste von LINQ sollte diese Methode meiner Meinung nach eine verzögerte Evaluierung durchführen. Jedoch,Meine Implementierung führt eine verzögerte Auswertung über den äußeren IEnumerable durch, abernicht über den inneren IEnumerable. Wie kann ich das beheben?

Eine Demonstration, wie faul das äußere Verhalten ist. AnnehmenThrowingEnumerable<int> ist einIEnumerable<int> das explodiert, wenn jemand versucht, darüber zu iterieren (siehe Skeets Edulinq).

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

[1,2,3]

aber das innere Verhaltenist nicht faul

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

BOOM

Wir erwarten 1 hier.