yield (C# Reference)

Option Strict On
Option Explicit On
Option Infer Off

Public Class Form1

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim results As System.Collections.Generic.IEnumerable(Of Integer)
        results = Power(2, 8)

        Dim sb As New System.Text.StringBuilder
        For Each num As Integer In results
            sb.Append(num.ToString & " ")
        Next

        MessageBox.Show(sb.ToString)

    End Sub

    Public Function Power(ByVal number As Integer, ByVal exponent As Integer) As System.Collections.Generic.IEnumerable(Of Integer)

        Dim result As New List(Of Integer)

        For index As Integer = 1 To exponent
            result.Add(Convert.ToInt32(Math.Pow(number, index)))
        Next
        Return result.AsEnumerable

    End Function

End Class

The above article states:
"The yield statement can only appear inside an iterator block..."
Correct me if I'm wrong, but in actuality, the yield break; statement does appear outside an iterator block. Perhaps slightly better wording would be:
"The yield return statement can only appear inside an iterator block..."

Aaron

CS Team: Hi Aaron. Thanks for your comment. The C# 4.0 Language Spec (http://www.microsoft.com/downloads/details.aspx?FamilyID=dfbf523c-f98c-4804-afbd-459e846b268e&displaylang=en#filelist) says the following:

8.14 The yield statement

The yield statement is used in an iterator block (§8.2) to yield a value to the enumerator object (§10.14.4) or enumerable object (§10.14.5) of an iterator or to signal the end of the iteration.

yield-statement:
yieldreturn expression ;
yieldbreak;

Here is a blog that explains the usage of yield return and yield break in a simple example

http://iserialized.com/a-quick-start-guide-to-yield-return-and-yield-break/

Does it have any difference between 'yield return' and 'return yield' ??

Some examples about the use of 'yield' at: http://www.codeproject.com/KB/collections/Enumerators.aspx

David, Thanks, your note:

"The yield keyword uses what's known as lazy evaluation. What this means practically is that anything following a "yield return" will not be evaluated until it is requested from the enumerator."

should have been at the very beginning of this article. Because it explains everything in several words. Very clear and concise.
It is sooo true about many articles on MSDN, they start explaning from the middle.

The yield keyword uses what's known as lazy evaluation. What this means practically is that anything following a "yield return" will not be evaluated until it is requested from the enumerator. Take the following class for example:

public class ExampleClass{

    public List<string> OriginalStrings { get; set; }

    /// <summary>
    /// Returns an enumerated list of reversed strings from OriginalStrings.  
    /// Causes side effects due to the call to "reverseString". 
    /// </summary>
    /// <returns></returns>
    public IEnumerable<string> GetReversedStrings()
    {
        for (int i = 0; i < OriginalStrings.Count; i++)
            yield return reverseString(i);
    }

    /// <summary>
    /// Replaces the string at the specified index with a reversed version of itself.
    /// </summary>
    /// <param name="index">The index of the string in OriginalStrings to reverse. </param>
    /// <returns>The newly reversed string</returns>
    private string reverseString(int index)
    {
        string value = OriginalStrings[index];
        char[] chars = value.ToCharArray();
        Array.Reverse(chars);
        string[] letters = new string[chars.Length];
        for (int i = 0; i < chars.Length; i++)
            letters[i] = chars[i].ToString();
        string returnValue = string.Join("", letters);
        OriginalStrings[index] = returnValue;
        return OriginalStrings[index];
    }
}

The GetReversedStrings method will yield the result of the call to reverseString, which will set the values of the OriginalStrings to their reversed equivalent, and return the newly reversed string.

Now, let's call this from the main method:

static void Main(string[] args)
{
    ExampleClass exampleClass = new ExampleClass();
    exampleClass.OriginalStrings = new List<string>() { "Bob", "David", "Jimenez", "Franz" };
    exampleClass.GetReversedStrings();
    foreach (string s in exampleClass.OriginalStrings)
        Console.WriteLine(s);
    Console.ReadLine();
}

Notice the output. The strings are not reversed. This is because the result of GetReversedStrings() is never iterated through.

Let's alter the code just a bit.

static void Main(string[] args)
{
    ExampleClass exampleClass = new ExampleClass();
    exampleClass.OriginalStrings = new List<string>() { "Bob", "David", "Jimenez", "Franz" };
    foreach (string value in exampleClass.GetReversedStrings())
    {
        // do nothing of consequence. This is here simply to iterate through the values. 
    }
    foreach (string s in exampleClass.OriginalStrings)
        Console.WriteLine(s);
    Console.ReadLine();
}

Now, you'll see a different result when you run this. All of the values will print out reversed. This is because the call to the statement returned in the yield return statement is evaluated only when iterated through.

This can certainly be an advantage, as it is in Linq, but use the keyword improperly, and you might get unexpected results.