<p>When ever I think I can use the yield keyword, I take a step back and look at how it will impact my project. I always end up returning a collection instead of yeilding because I feel the overhead of maintaining the state of the yeilding method doesn't buy me much. In almost all cases where I am returning a collection I feel that 90% of the time, the calling method will be iterating over all elements in the collection, or will be seeking a series of elements throughout the entire collection. </p>

<p>I do understand its usefulness in linq, but I feel that only the linq team is writing such complex queriable objects that yield is useful.</p>

<p>Has anyone written anything like or not like linq where yield was useful?</p>

Note that with yield, you are iterating over the collection once, but when you build a list, you'll be iterating over it twice.
Take, for example, a filter iterator:
```
```
IEnumerator<T>  Filter(this IEnumerator<T> coll, Func<T, bool> func)
{
     foreach(T t in coll)
        if (func(t))  yield return t;
}
```
```
Now, you can chain this:
```
```
MyColl.Filter(x=> x.id > 100).Filter(x => x.val < 200).Filter (etc)
```
```
You method would be creating (and tossing) three lists.  My method iterates over it just once.
Also, when you return a collection, you are forcing a particular implementation on you users. An iterator is more generic.