pull things from lazy source till timeout is reached
A better name for times would be count.
Your two Pull methods are inconsistent:


The first one actually returns a copy of the entire input sequence (ToArray()) while the second one doesn't.
To keep it consistent with the standard LINQ methods the first method should also just enumerate the input sequence rather than making a copy.


The first method can then be rewritten as:

public static IEnumerable&lt;T&gt; Pull&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, int? count = null)
{
    return (times == null) ? enumerable : enumerable.Take(count.Value);
}


Or if you prefer to create a new enumerator:

public static IEnumerable&lt;T&gt; Pull&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, int? count = null)
{
    var items = (times == null) ? enumerable : enumerable.Take(count);
    foreach (var item in items)
    {
        yield return item;
    }
}

When i first read this question I assumed the intend was to only wait a maximum time for an item to arrive (i.e. input sequence is possibly blocking). Reading the code however seems that you just want to consume as many items as you can in a given time span (specifically it doesn't deal with blocking input sequences). Assuming the latter is what you wanted then I'd change the code to not use the enumerator interface but stick on a slightly higher level:

public static IEnumerable&lt;T&gt; Pull&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, TimeSpan timeout, int? count = null)
{
    var stopwatch = new Stopwatch();
    stopwatch.Start();

    var items = (times == null) ? enumerable : enumerable.Take(count.Value);

    foreach (var item in items)
    {
        if (stopwatch.Elapsed &gt;= timeout) { yield break; }
        yield return item;
    }
}