Is the IEnumerable<T> function with a yield more efficient than the List<T> function?

Question

I am coding a C# forms application, and would like to know if the following two functions achieve the same result:

public List<object> Method1(int parentId)
{
    List<object> allChildren = new List<object>();
    foreach (var item in list.Where(c => c.parentHtmlNodeForeignKey == parentId))
    {
        allChildren.Add(item);
        allChildren.AddRange(Method1(item.id));
    }
    return allChildren;
}
public IEnumerable<object> Method2(int parentId)
{
    foreach (var item in list.Where(c => c.parentHtmlNodeForeignKey == parentId))
    {
        yield return item;
        foreach (var itemy in Method2(item.id))
        {
            yield return itemy;
        }
    }
}

Am I correct in saying that the Method1 function is more efficient than the Method2?

Also, can either of the above functions be coded to be more efficient?

EDIT

I am using the function to return some objects that are then displayed in a ListView. I am then looping through these same objects to check if a string occurs.

Thanks.

Hard to read with all those long names. What's wrong with Method1 , Method2 ? — Royi Namir
– Royi Namir, Commented Jul 19, 2015 at 8:32
How are they being used? Are you iterating over the resluts multiple times? Are you iterating through all of the results? — Jon Skeet
– Jon Skeet, Commented Jul 19, 2015 at 8:32
It depends on how you use the function. The Yield function is executed on demand, hence a single call to the function requires less runtime than the List function (but you won't get the result). The Yield function requires the overhead of constructing an iterator object. So if you call ToList() on the result of the Yield method, this is probably slower than the pure List function. — Nico Schertler
– Nico Schertler, Commented Jul 19, 2015 at 8:34
Exposing List vs IEnumerable isn't really ever a question of efficiency, more intent. If you intend someone to take your items and add or remove from them, List is the way to go. If all you intend is for someone to iterate them, IEnumerable is the contract for that. — Adam Houldsworth
– Adam Houldsworth, Commented Jul 19, 2015 at 8:35

Felix K. · Accepted Answer · 2015-07-19 08:35:14Z

3

This highly depends on what you want to do. For example if you use FirstOrDefault(p => ....) the yield method can be faster because it's not required to store all the stuff into a list and if the first element is the right one the list method has some overhead ( Of course the yield method has also overhead but as i said it depends ).

If you want to iterate over and over again over the data then you should go with the list.

answered Jul 19, 2015 at 8:35

Felix K.

6,3012 gold badges41 silver badges71 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Royi Namir Over a year ago

Not to mention the capacity resize each time when it reaches the boundry

Amir Popovich · Accepted Answer · 2015-07-19 08:41:20Z

1

It depends on lot's of things.

Here are some reasons to use IEnumerable<T> over List<T>:

When you are iterating a part of a collection (e.g. using FirstOrDefault, Any, Take etc.).
When you have an large collection and you can ToList() it (e.g. Fibonacci Series).

When you shouldn't use IEnumerable<T> over List<T>:

When you are enumerating a DB query multiple times with different conditions (You may want the results in memory).
When you want to iterate the whole collection more than once - There is no need to create iterators each time.

answered Jul 19, 2015 at 8:41

Amir Popovich

30.1k9 gold badges58 silver badges102 bronze badges

Collectives™ on Stack Overflow

Is the IEnumerable<T> function with a yield more efficient than the List<T> function?

2 Answers 2

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related