More compact way for "yield return"?

Question

I have this method that yields the values yielded by 2 methods:

private IEnumerable<Node> ParseEmptyElement()
{
    foreach (var node in ParseMembersOfObject()) 
    {
        yield return node;
    }

    foreach (var node in ParseNestedProperty()) 
    {
        yield return node;
    }
}

It seems very verbose for me.

Is there a better way express "yield all values from MethodX" and after that, do the same for MethodY?

Example:

private IEnumerable<Node> ParseEmptyElement()
{
    #yield all# items from ParseMembersOfObject();    
    #yield all# items from ParseNestedProperty();
}

I don't want to be force to write the foreach loops into a single line! but I also don't want to write fully-fledged foreach loops with curly braces and all the stuff :)

`return ParseMembersOfObject().Concat(ParseNestedProperty())` ? — Marc Gravell, Apr 22 '15 at 22:26
possible duplicate of [C#: return yield range/collection](http://stackoverflow.com/questions/5415902/c-return-yield-range-collection) — Jeroen Vannevel, Apr 22 '15 at 22:27
Also related: http://stackoverflow.com/questions/1270024/nested-yield-return-with-ienumerable — Jeroen Vannevel, Apr 22 '15 at 22:28
@Marc won't that force evaluation & in-memory copying of the IEnumerable method results?. — jklemmack, Apr 22 '15 at 22:32
Do you even want yield return? It is not simply a tense way to return a collection. Parse sounds like there are exceptions involved and lazy evaluation could bite you — Nathan Cooper, Apr 22 '15 at 22:35
@jklemmack What do you mean by force evalution? You mean eager evaluation of both collections? If so then no, `Concat` uses deferred execution. — Yuval Itzchakov, Apr 22 '15 at 22:35
Here's an [msdn reference](https://msdn.microsoft.com/en-us/library/vstudio/bb302894.aspx) that confirms it's deferred execution. — Blorgbeard, Apr 22 '15 at 22:36

score 2 · Accepted Answer · answered Apr 22 '15 at 22:44

As Marc commented, this is equivalent:

private IEnumerable<Node> ParseEmptyElement()
{
    return ParseMembersOfObject().Concat(ParseNestedProperty());
}

Concat is implemented using deferred execution, so this will not evaluate your enumerables early.

Incidentally, Concat is implemented with the foreach loops on a single line:

static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, 
                                                    IEnumerable<TSource> second) {
    foreach (TSource element in first) yield return element;
    foreach (TSource element in second) yield return element;
}

If you don't like Concat, and you still want braces, you could still keep them and just format your code more concisely:

private IEnumerable<Node> ParseEmptyElement()
{
    foreach (var node in ParseMembersOfObject()) { yield return node; }
    foreach (var node in ParseNestedProperty())  { yield return node; }
}

Unfortunately, Concat doesn't help so much when you have code in-between. Please, take a look to this method: https://github.com/SuperJMN/OmniXAML/blob/master/Source/OmniXaml/Parsers/ProtoParser/XamlProtoInstructionParser.cs#L47 — SuperJMN, Aug 30 '15 at 20:35

More compact way for "yield return"?

1 Answers1