Lazy Evaluation

suggest change

Only when the foreach statement moves to the next item does the iterator block evaluate up to the next yield statement.

Consider the following example:

private IEnumerable<int> Integers()
{
    var i = 0;
    while(true)
    {
        Console.WriteLine("Inside iterator: " + i);
        yield return i;
        i++;
    }
}

private void PrintNumbers()
{
    var numbers = Integers().Take(3);
    Console.WriteLine("Starting iteration");

    foreach(var number in numbers)
    {
        Console.WriteLine("Inside foreach: " + number);
    }
}

This will output:

Starting iteration Inside iterator: 0 Inside foreach: 0 Inside iterator: 1 Inside foreach: 1 Inside iterator: 2 Inside foreach: 2

View Demo

As a consequence:

“Starting iteration” is printed first even though the iterator method was called before the line printing it because the line Integers().Take(3); does not actually starts iteration (no call to IEnumerator.MoveNext() was made)
The lines printing to console alternate between the one inside the iterator method and the one inside the foreach, rather than all the ones inside the iterator method evaluating first
This program terminates due to the .Take() method, even though the iterator method has a while true which it never breaks out of.

Found a mistake? Have a question or improvement idea? Let me know.

Yield Keyword:

* Yield Keyword

* Simple Usage

* Correctly checking arguments

* Early Termination

* More Pertinent Usage

* Lazy Evaluation

* Try...finally

* Using yield to create an IEnumeratorT when implementing IEnumerableT

* Eager evaluation

* Return another Enumerable within a method returning Enumerable

* Lazy Evaluation Example Fibonacci Numbers

* The difference between break and yield break

Table Of Contents

0 Getting Started With C#

1 Literals

2 Operators

3 Conditional Statements

4 Equality Operator

5 Equals and GetHashCode

6 Null-Coalescing Operator

7 Null-Conditional Operators

8 nameof Operator

9 Verbatim String

10 Common String Operations

11 String Format

12 String Concatenate

13 String Manipulation

14 String Interpolation

15 String Escape Sequences

16 StringBuilder

17 Regex

18 DateTime

19 Arrays

20 On Algorithm for circular rotation of an array

21 Enum

22 Tuples

23 Overview of C# collections

24 GUID

25 BigInteger

26 Collection Initializers

27 Looping

28 Iterators

29 IEnumerable

30 Value type vs Reference type

31 Built-in Types

32 Aliases of built-in types

33 Anonymous types

34 Dynamic type

35 Type Conversion

36 Casting

37 Nullable types

38 Constructors and Finalizers

39 Access Modifiers

40 Interfaces

41 Static Classes

42 Singleton Implementation

43 Dependency Injection

44 Partial class and methods

45 Object Initializers

46 Methods

47 Extension Methods

48 Named Arguments

49 Named And Optional Arguments

50 Data Annotation

51 Keywords

52 Recursion

53 Naming Conventions

54 XML Documentation Comments

55 Comments and regions

56 Inheritance

57 Generics

58 Using Statement

59 Using Directive

60 IDisposable interface

61 Reflection

62 IQueryable interface

63 LINQ to Objects

64 LINQ Queries

65 LINQ to XML

66 Parallel LINQ PLINQ

67 XmlDocument

68 XDocument

69 C# 7.0 Features

70 C# 6.0 Features

71 C# 5.0 Features

72 C# 4.0 Features

73 C# 3.0 Features

74 Exception Handling

75 NullReferenceException

76 Handling FormatException

77 Read and Understand Stack trackes

78 Diagnostics

79 Overflow

80 JSON handling

81 Using json.net

82 Lambda Expressions

83 Lambda expressions

84 Generic Lambda Query Builder

85 Properties

86 Initializing Properties

87 INotifyPropertyChanged interface

88 Events

89 Expression Trees

90 Overload Resolution

91 Preprocessor directives

92 Structs

93 Attributes

94 Delegates

95 File and Stream IO

96 Networking

97 Performing HTTP requests

98 Reading and writing .zip files

99 FileSystemWatcher

100 Asynchronous Socket

101 Action Filters

102 Polymorphism

103 Immutability

104 Indexer

105 Checked and Unchecked

106 Stream

107 Timers

108 Stopwatches

109 Threading

110 Async/Await, BackgroundWorker, Task and Thread examples

111 Async Await

112 Synchronization Context in Async/Await

113 BackgroundWorker

114 Task Parallel Library

115 Making a variable thread safe

116 Lock Statement

117 Yield Keyword

118 Task Parallel Library TPL Dataflow Constructs

119 Functional Programming

120 Func delegates

121 Function with multiple return values

122 Binary Serialization

123 ICloneable

124 IComparable

125 Accessing Databases

126 Using SQLite

127 Caching

128 Code Contracts

129 Code Contracts and Assertions

130 Structural Design Patterns

131 Creational Design Patterns

132 Implementing Decorating Design Pattern

133 Implementing Flyweight Design Pattern

134 System.Management.Automation

135 Pointers

136 Pointers and Unsafe Code

137 Simulating C Unions with C# Structs

138 Reactive Extensions Rx

139 AsseblyInfo.cs examples

140 Creating Console Application

141 CLSCompliantAttribute

142 ObservableCollection

143 Hash Functions

144 Generating Random Numbers

145 Cryptography

146 Unsafe Code in .NET

147 C# Script

148 Runtime Compile

149 Interoperability

150 .NET Compiler Platform Roslyn

151 Creating Own MessageBox in Windows Form Application

152 Including Font Resources

153 Garbage Collector

154 Windows Communication Foundation

155 Contributors