Print PDF

Using the Yield Keyword for Elegant Code

The yield C# keyword was added in C# 2.0 in order to simplify implementation of the “Iterator Pattern” in Typed C# objects.

The “Gang of Four” in their Design Patterns book in the 90’s defined the Iterator Pattern as:

“Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation”

The Iterator Pattern Demonstration

The Software Entities in the Class Diagram has the following responsibilities:

1. IIterator – The Interface that contracts the Methods for Accessing and Traversing Elements

2. IteratorDemo – The Concrete Iterator that implements the IIterator Interface. The Iterator tracks the current index position in the traversal of the aggregate object

3. IIteration – The interface that defines method: GetIterator.  This implementation creates the Iterator object: IterationDemo

4. IterationDemo – The Concrete object that holds the collection. This class implements the IIteration interface for the GetIterator Method

5. InteratorPatternDemo – The Class that is the implementation of the Iterator Pattern for our Unit Test. Notice I have embedded a “Yield Return” to create the IEnumerable of String. This is actually a C# implementation of the Iteration Pattern within the Iteration Pattern demo

In the Iterator Pattern Unit Test Class we define the validation test method below using the Gherkin Behavior Driven Development (BDD) language abstraction syntax of :
Given | When | Then.

Using Gherkin Syntax defines, as a naming convention abstraction,  the expectation of the concrete test: 

GivenIWantToTestTheIteratorPatternDemoClass

WhenICallTheGetIteratorPatternListOfStringsMethod

ThenIWillValidateTheMethodResult

The Gherkin Naming Convention defines the “What” of the test for the Developer as a road map for the concrete “How“.

The Test Validates Two Actions:

1. A Greedy result – The Yield Return IEnumerable result as a List<string>

2. A Lazy Result – The Yield Return IEnumerable result as a IEnumerable<string>

The images below show the performance improvement of delaying the actual creation of the results until they are actually required.

Greedy Loading using the ToList() Extension Method:

Lazy Loading using the “yield return‘ Iterator Pattern:

The images above show the performance improvement of delaying the actual creation of the results until they are actually required.

The Yield Return Results are Added to the IEnumerable Collection

… But are Not Actually Returned until Queried

…… Using the Results View Expander in Intellisense

The Power of Yield Return

Using “yield return” simplifies your code while creating a more efficient Iterator Pattern “Under the Hood“.

When ever you see code patterns like this:

Replace it with a code pattern using the yield return to loop within the yield and act only when the predicate is true:

You will use a smaller memory footprint with better performance without returning any processed collection.

The “yield return” adds one item to the returned IEnumerable<T> each time it is called.

It does not end the function call like a normal return would. The function ends only when the flow of control reaches the end of the function body.

How is this actually accomplished:

The MSDN Docs Explanation:

“The compiler generates a class to implement the behavior that is expressed in the iterator block”

The “yield return” abstracts away the complexity of the Iterator Pattern demo code, detailed above, for you.

You will be creating more elegant code and delivering a better product to your Client.

Using ‘Yield Return’ for IEnumerable<T>

… Simplifies Code with Improved Performance