Question

What would be the most readable way to apply the following to a sequence using linq:

TakeWhile elements are valid but always at least the first element

EDIT: I have updated the title, to be more precise. I’m sorry for any confusion, the answers below have definitely taught me something!

The expected behavior is this: Take while element are valid. If the result is an empty sequence, take the first element anyway.

Answer 1

It would be most efficiently implemented manually as far as I can tell to ensure that it isn’t enumerated over more than necessary.

public static IEnumerable<TSource> TakeWhileOrFirst<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    using (var enumerator = source.GetEnumerator())
    {
        if (!enumerator.MoveNext())
            yield break;
        TSource current = enumerator.Current;
        yield return current;
        if (predicate(current))
        {
            while (enumerator.MoveNext() && predicate(current = enumerator.Current))
                yield return current;
        }
    }
}

And for the sake of completion, an overload that includes the index:

public static IEnumerable<TSource> TakeWhileOrFirst<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
{
    using (var enumerator = source.GetEnumerator())
    {
        if (!enumerator.MoveNext())
            yield break;
        TSource current = enumerator.Current;
        int index = 0;
        yield return current;
        if (predicate(current, index++))
        {
            while (enumerator.MoveNext() && predicate(current = enumerator.Current, index++))
                yield return current;
        }
    }
}