Using the LoopThroughFiles program

From the command line, the user specifies the directory to use as an argument to the program. The following command “hex-dumps” each file in the temp directory (including binary files as well as text files):

loopthroughfiles c: emp

If you don't enter a directory name, the program uses the current directory by default. (A hex dump displays the output as numbers in the hexadecimal — base 16 — system. See the nearby sidebar “Getting hexed.”)

If you run this program in a directory with lots of files, the hex dump can take a while. Also, long files take a while to loop through. Either pick a directory with few files or stop a lengthy program run by pressing Ctrl+C. This command interrupts a program running in any console window.

The following example shows what happens when the user specifies the invalid directory x:

Directory "x" invalid
Could not find a part of the path "C:C#ProgramsLoopThroughFilesinDebugx".

No files left

Getting started

As with all examples in this book, you begin with a basic program structure, as shown in the following code. Note that you must include a separate using statement for the System.IO namespace. To this basic structure, you add the individual functions described in the sections that follow.

using System;
using System.IO;

// LoopThroughFiles -- Loop through all files contained in a directory;
// this time perform a hex dump, though it could have been anything.
namespace LoopThroughFiles
{
public class Program
{
}
}

Obtaining the initial input

Every console application begins with a Main() function, as previous chapters indicate. Don't worry for now if you don’t quite understand how the Main() function is supposed to work as part of the console application. For now, just know that the first function that C# calls is the Main() function of your console application, as shown in the following code:

public static void Main(string[] args)
{
// If no directory name provided…
string directoryName;
if (args.Length == 0)
{
// …get the name of the current directory…
directoryName = Directory.GetCurrentDirectory();
}
else
{
// …otherwise, assume that the first argument
// is the name of the directory to use.
directoryName = args[0];
}
Console.WriteLine(directoryName);

// Get a list of all files in that directory.
FileInfo[] files = GetFileList(directoryName);

// Now iterate through the files in that list,
// performing a hex dump of each file.
foreach (FileInfo file in files)
{
// Write the name of the file.
Console.WriteLine(" hex dump of file {0}:", file.FullName);

// Now "dump" the file to the console.
DumpHex(file);

// Wait before outputting next file.
Console.WriteLine(" Press Enter to continue to next file");
Console.ReadLine();
}

// That's it!
Console.WriteLine(" No files left");
Console.Read();
}

The first line in LoopThroughFiles looks for a program argument. If the argument list is empty (args.Length is zero), the program calls Directory.GetCurrentDirectory(). If you run inside Visual Studio rather than from the command line, that value defaults to the binDebug subdirectory of your LoopThroughFiles project directory.

The Directory class gives the user a set of methods for manipulating directories. The FileInfo class provides methods for moving, copying, and deleting files, among other tasks.

The program then creates a list of all files in the specified directory by calling GetFileList(). This method returns an array of FileInfo objects. Each FileInfo object contains information about a file — for example, the filename (with the full path to the file, FullName, or without the path, Name), the creation date, and the last modified date. Main() iterates through the list of files using your old friend, the foreach statement. It displays the name of each file and then passes off the file to the DumpHex() method for display to the console. At the end of the loop, it pauses to allow the programmer a chance to gaze on the output from DumpHex().

Creating a list of files

Before you can process a list of files, you need to create one. The GetFileList() method begins by creating an empty FileInfo array and then filling it with a list of files. Here's the required code.

// GetFileList -- Get a list of all files in a specified directory.
public static FileInfo[] GetFileList(string directoryName)
{
// Start with an empty list.
FileInfo[] files = new FileInfo[0];
try
{
// Get directory information.
DirectoryInfo di = new DirectoryInfo(directoryName);

// That information object has a list of the contents.
files = di.GetFiles();
}
catch(Exception e)
{
Console.WriteLine("Directory "{0}" invalid", directoryName);
Console.WriteLine(e.Message);
}
return files;
}

GetFileList() then creates a DirectoryInfo object. Just as its name implies, a DirectoryInfo object contains the same type of information about a directory that a FileInfo object does about a file: name, rank, and serial-number-type stuff. However, the DirectoryInfo object has access to one thing that a FileInfo doesn't: a list of the files in the directory, in the form of a FileInfo array.

To help trap errors, GetFileList() wraps the directory- and file-related code in a big try block. (For an explanation of try and catch, see Chapter 9 in this minibook.) The catch at the end traps any errors that are generated. Just to embarrass you further, the catch block flaunts the name of the directory (which probably doesn't exist, because you entered it incorrectly).

The final step is to return files, which contains the list of files in the code collection. Be careful about returning a reference to an object. For instance, don’t return a reference to one of the underlying queues wrapped up in the PriorityQueue class, described in Chapter 8 of this minibook — unless you want to invite folks to mess with those queues through the reference instead of through your class methods, that is. That's a sure ticket to a corrupt, unpredictable queue. But GetFileList() doesn’t expose the innards of one of your classes here, so it’s okay.

Formatting the output lines

You can do anything you want with the list of files you collect. This example displays the content of each file in hexadecimal format, which can be useful in certain circumstances, such as when you need to know how files are actually put together. Before you can create a line of hexadecimal output, however, you need to create individual output lines. The DumpHex() method, shown here, is a little tricky only because of the difficulties in formatting the output just right.

// DumpHex -- Given a file, dump the file contents to the console.
public static void DumpHex(FileInfo file)
{
// Open the file.
FileStream fs;
BinaryReader reader;
try
{
fs = file.OpenRead();
// Wrap the file stream in a BinaryReader.
reader = new BinaryReader(fs);
}
catch (Exception e)
{
Console.WriteLine(" can't read from "{0}"", file.FullName);
Console.WriteLine(e.Message);
return;
}

// Iterate through the contents of the file one line at a time.
for (int line = 1; true; line++)
{
// Read another 10 bytes across (all that will fit on a single
// line) -- return when no data remains.
byte[] buffer = new byte[10];
// Use the BinaryReader to read bytes.
// Note: Using FileStream is just as easy in this case.
int numBytes = reader.Read(buffer, 0, buffer.Length);
if (numBytes == 0)
{
return;
}

// Write the data in a single line preceded by line number.
Console.Write("{0:D3} - ", line);
DumpBuffer(buffer, numBytes);

// Stop every 20 lines so that the data doesn't scroll
// off the top of the Console screen.
if ((line % 20) == 0)
{
Console.WriteLine("Press Enter to continue another 20 lines" +
" or type Q to go to the next file.");
string Input = Console.ReadLine();
if (Input.ToUpper() == "Q")
break;
}
}
}

DumpHex() starts by opening file. A FileInfo object contains information about the file — it doesn't open the file. DumpHex() gets the full name of the file, including the path, and then opens a FileStream in read-only mode using that name. The catch block throws an exception if FileStream can't read the file for some reason.

DumpHex() then reads through the file, 10 bytes at a time. It displays every 10 bytes in hexadecimal format as a single line. Every 20 lines, it pauses until the user presses Enter. The code uses the modulo operator, %, to accomplish that task.

Vertically, a console window has room for 25 lines by default. (The user can change the window's size, of course, allowing more or fewer lines.) That means you have to pause every 20 lines or so. Otherwise, the data just streams off the top of the screen before the user can read it.

The modulo operator (%) returns the remainder after division. Thus (line % 20) == 0 is true when line equals 20, 40, 60, 80 — you get the idea. This trick is valuable, useful in all sorts of looping situations where you want to perform an operation only so often.

Displaying the hexadecimal output

After you have a single line of output to display, you can output it in hexadecimal form. DumpBuffer() writes each member of a byte array using the X2 format control. Although X2 sounds like the name of a secret military experiment, it simply means “display a number as two hexadecimal digits.”

// DumpBuffer -- Write a buffer of characters as a single line in
// hex format.
public static void DumpBuffer(byte[] buffer, int numBytes)
{
for(int index = 0; index < numBytes; index++)
{
byte b = buffer[index];
Console.Write("{0:X2}, ", b);
}
Console.WriteLine();
}

The range of a byte is 0 to 255, or 0xFF — two hex digits per byte. Here are the first 20 lines of an example file:

Hex dump of file C:Tempoutput.txt:
001 - 53, 74, 72, 65, 61, 6D, 20, 28, 70, 72,
002 - 6F, 74, 65, 63, 74, 65, 64, 29, 0D, 0A,
003 - 20, 20, 46, 69, 6C, 65, 53, 74, 72, 65,
004 - 61, 6D, 28, 73, 74, 72, 69, 6E, 67, 2C,
005 - 20, 46, 69, 6C, 65, 4D, 6F, 64, 65, 2C,
006 - 20, 46, 69, 6C, 65, 41, 63, 63, 65, 73,
007 - 73, 29, 0D, 0A, 20, 20, 4D, 65, 6D, 6F,
008 - 72, 79, 53, 74, 72, 65, 61, 6D, 28, 29,
009 - 3B, 0D, 0A, 20, 20, 4E, 65, 74, 77, 6F,
010 - 72, 6B, 53, 74, 72, 65, 61, 6D, 0D, 0A,
011 - 20, 20, 42, 75, 66, 66, 65, 72, 53, 74,
012 - 72, 65, 61, 6D, 20, 2D, 20, 62, 75, 66,
013 - 66, 65, 72, 73, 20, 61, 6E, 20, 65, 78,
014 - 69, 73, 74, 69, 6E, 67, 20, 73, 74, 72,
015 - 65, 61, 6D, 20, 6F, 62, 6A, 65, 63, 74,
016 - 0D, 0A, 0D, 0A, 42, 69, 6E, 61, 72, 79,
017 - 52, 65, 61, 64, 65, 72, 20, 2D, 20, 72,
018 - 65, 61, 64, 20, 69, 6E, 20, 76, 61, 72,
019 - 69, 6F, 75, 73, 20, 74, 79, 70, 65, 73,
020 - 20, 28, 43, 68, 61, 72, 2C, 20, 49, 6E,
Enter return to continue another 20 lines

You could reconstruct the file as a string from the hex display. The 0x61 value is the numeric equivalent of the character a. The letters of the alphabet are arranged in order, so 0x65 should be the character e; 0x20 is a space. The first line in this example (after the line number) is s) Nemo, where is a newline and is a carriage return. Intriguing, eh? You can find a complete ASCII table at https://www.asciitable.com/.

The output codes are also valid for the lower part of the much vaster Unicode character set, which C# uses by default. (The site at http://www.i18nguy.com/unicode/codepages.html provides you with listings of character sets of all kinds and is very useful if you have to deal with input from devices like mainframes.)

Running from inside Visual Studio

To run LoopThroughFiles, you need to do one of the following:

• Start it from the command line by opening a Developer Command Prompt for VS 2022 found in the Start⇒  Visual Studio 2022 folder
• Supply command-line arguments in Visual Studio
• Execute it without command-line arguments at the command line or within Visual Studio

The second option in the preceding list, that of supplying a command-line argument in Visual Studio, requires a little special setting up on your part by following these steps:

1. Choose Project⇒  LoopThroughFiles Properties.

   You see a Properties dialog box for the application.

2. Select Debug in the left pane.

   You see the debug options shown in Figure 7-1.

3. Type the path you want to use, such as C:Temp, in the Command Line Arguments field.

   The path you type will work within Visual Studio whether you're in debug mode or not.

4. Choose File⇒  Save All.

   Visual Studio saves the new path to disk.

5. Choose Debug⇒  Start Debugging or Debug⇒  Start Without Debugging.

   You see the program execute in the path that you chose.

Accessing a collection: The general problem

Different collection types may have different accessing schemes. Not all types of collections can be accessed efficiently with an index like an array’s — the linked list, for example. A linked list just contains a reference to the next item in the list and is made to be consecutively — not randomly — accessed. Differences between collection types make it impossible to write a method such as the following without special provisions:

// Pass in any kind of collection:
void MyClearMethod(Collection aColl, int index)
{
aColl[index] = 0; // Indexing doesn't work for all types of collections.
// …continues…
}

Each collection type can (and does) define its own access methods. You decide on which access method to use based on the task requirements. The CollectionMoveNext example, shown here, demonstrates three access methods for a List<string> object, Colors:

static void Main(string[] args)
{
List<string> Colors = new List<string> {
"Red", "Yellow", "Green", "Blue" };

Console.WriteLine("Using a delegate.");
Colors.ForEach(delegate (string value)
{
Console.WriteLine(value);
});

Console.WriteLine(" Using a foreach.");
foreach (string col in Colors)
Console.WriteLine(col);

Console.WriteLine(" Using an enumerator.");
var colEnum = Colors.GetEnumerator();
while (colEnum.MoveNext())
Console.WriteLine(colEnum.Current);
Console.ReadLine();
}

This example shows how to use a delegate (described in detail in Book 2 Chapter 8 of this minibook), a foreach loop (described in Chapter 6 of this minibook), and an enumerator (which Microsoft tends to confuse with iterators). The Colors.ForEach() approach has an advantage in that you can use lambda expressions with it and it's extremely flexible, but sometimes it’s hard to read. The foreach loop method is easy to read and quite common, but it lacks flexibility. The call to GetEnumerator() obtains a special object that knows how to move between entries in a List<string>. This is the best approach when you need to perform additional levels of processing and want strict control over when the Current property value changes. The iterator (enumerator) approach offers these advantages:

• Each collection class can define its own iteration class. Because the iteration class implements the standard IEnumerator interface, it's usually straightforward to code.
• The application code doesn’t need to know how the collection code works. As long as the programmer understands how to use the iterator, the iteration class can handle the details. That’s good encapsulation.
• The application code can create multiple independent iterator objects for the same collection. Because the iterator contains its own state information (“knows where it is,” in the iteration), each iterator can navigate through the collection independently. You can have several iterations going at one time, each one at a different location in the collection.

To make the foreach loop possible, the IEnumerator interface must support all different types of collections, from arrays to linked lists. Consequently, its methods must be as general as possible. For example, you can't use the iterator to access locations within the collection class randomly because most collections don’t provide random access. (You’d need to invent a different enumeration interface with that capability, but it wouldn’t work with foreach.) IEnumerator provides these three features:

• Reset(): Sets the enumerator to point to the beginning of the collection. Note: The generic version of IEnumerator, IEnumerator<T>, doesn't provide a Reset() method. With .NET’s generic LinkedList, for example, just begin with a call to MoveNext(). That generic LinkedList is found in System.Collections.Generic.
• MoveNext(): Moves the enumerator from the current object in the collection to the next one.
• Current: A property, rather than a method, that retrieves the data object stored at the current position of the enumerator.

The following method demonstrates this principle. The programmer of the MyCollection class (not shown) creates a corresponding iterator class — say, IteratorMyCollection. The application programmer stores ContainedDataObjects in MyCollection. The following code segment uses the three standard IEnumerator methods to read these objects:

// The MyCollection class holds ContainedDataObject type objects as data.
void MyMethod(MyCollection myColl)
{
// The programmer who created the MyCollection class also
// creates an iterator class IteratorMyCollection;
// the application program creates an iterator object
// in order to navigate through the myColl object.
IEnumerator iterator = new IteratorMyCollection(myColl);

// Move the enumerator to the "next location" within the collection.
while (iterator.MoveNext())
{
// Fetch a reference to the data object at the current location
// in the collection.
ContainedDataObject contained; // Data
contained = (ContainedDataObject)iterator.Current;

// …use the contained data object…
}
}

The method MyMethod() accepts as its argument the collection of ContainedDataObjects. It begins by creating an iterator of class IteratorMyCollection. The method starts a loop by calling MoveNext(). On this first call, MoveNext() moves the iterator to the first element in the collection. On each subsequent call, MoveNext() moves the pointer to the next position. MoveNext() returns false when the collection is exhausted and the iterator cannot be moved any farther.

The Current property returns a reference to the data object at the current location of the iterator. The program converts the object returned into a ContainedDataObject before assigning it to contained. Calls to Current are invalid if the MoveNext() method didn't return true on the previous call or if MoveNext() hasn't yet been called.

Letting C# access data foreach container

The IEnumerator methods are standard enough that C# uses them automatically to implement the foreach statement. The foreach statement can access any class that implements IEnumerable or IEnumerable<T>. This section discusses foreach in terms of IEnumerable<T> as shown in this general method that is capable of processing any such class, from arrays to linked lists to stacks and queues:

void MyMethod(IEnumerable<T> containerOfThings)
{
foreach (string s in containerOfThings)
{
Console.WriteLine("The next thing is {0}", s);
}
}

A class implements IEnumerable<T> by defining the method GetEnumerator(), which returns an instance of IEnumerator<T>. Under the hood, foreach invokes the GetEnumerator() method to retrieve an iterator. It uses this iterator to make its way through the collection. Each element it retrieves has been cast appropriately before continuing into the block of code contained within the braces. Note that IEnumerable<T> and IEnumerator<T> are different, but related, interfaces. C# provides nongeneric versions of both as well, but you should prefer the generic versions for their increased type safety. IEnumerable<T> looks like this:

interface IEnumerable<T>
{
IEnumerator<T> GetEnumerator();
}

while IEnumerator<T> looks like this:

interface IEnumerator<T>
{
bool MoveNext();
T Current { get; }
}

The nongeneric IEnumerator interface adds a Reset() method that moves the iterator back to the beginning of the collection, and its Current property returns type Object. Note that IEnumerator<T> inherits from IEnumerator (Interface inheritance, covered in Book 2, Chapter 7, is different from normal object inheritance).

C# arrays (embodied in the Array class they're based on) and all the .NET collection classes already implement both interfaces. So it’s only when you’re writing your own custom collection class that you need to take care of implementing these interfaces. For built-in collections, you can just use them. See the System.Collections.Generic namespace topic at https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic?view=net-5.0 for details. Thus you can write the foreach loop this way:

foreach(int nValue in myCollection)
{
// …
}

Indexer format

The indexer looks much like an ordinary get/set property (Book 2 Chapter 3 describes accessors in more detail), except for the appearance of the keyword this and the subscript operator [] instead of the property name, as shown in this bit of code:

class MyArray
{
public string this[int index] // Notice the "this" keyword.
{
get => MyArray[index];
set => MyArray[index] = value;
}
}

The example shows a short form of an indexer that you use when you don't need to do anything except get and set values. The “Working with indexers” section, later in this chapter, shows a longer version. Under the hood, the expression s = myArray[i]; invokes the get accessor method, passing it the value of i as the index. In addition, the expression myArray[i] = "some string"; invokes the set accessor method, passing it the same index i and "some string" as value.

An indexer program example

The index type isn't limited to int. You may choose to index a collection of houses by their owners’ names, by house address, or by any number of other indices. In addition, the indexer property can be overloaded with multiple index types, so you can index on a variety of elements in the same collection. The following sections discuss the Indexer program, which generates the virtual array class KeyedArray. This virtual array looks and acts like an array except that it uses a string value as the index. (Note that you could replicate the functionality found in this example by using a C# Dictionary, as described at https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2.)

Creating the required iterator block framework

The best approach to iteration uses iterator blocks. When you write a collection class — and the need still exists for custom collection classes such as KeyedList and PriorityQueue — you implement an iterator block in its code rather than implement the IEnumerator interface. Then users of that class can simply iterate the collection with foreach. Here is the basic framework used for this example, which contains the functions that follow in the upcoming sections:

static void Main(string[] args)
{
// Instantiate a MonthDays "collection" class.
MonthDays md = new MonthDays();

// Iterate it.
Console.WriteLine("Stream of months: ");
foreach (string month in md)
{
Console.WriteLine(month);
}

// Instantiate a StringChunks "collection" class.
StringChunks sc = new StringChunks();

// Iterate it: prints pieces of text.
// This iteration puts each chunk on its own line.
Console.WriteLine(" stream of string chunks: ");
foreach (string chunk in sc)
{
Console.WriteLine(chunk);
}

// And this iteration puts it all on one line.
Console.WriteLine(" stream of string chunks on one line: ");
foreach (string chunk in sc)
{
Console.Write(chunk);
}
Console.WriteLine();

// Instantiate a YieldBreakEx "collection" class.
YieldBreakEx yb = new YieldBreakEx();

// Iterate it, but stop after 13.
Console.WriteLine(" stream of primes: ");
foreach (int prime in yb)
{
Console.WriteLine(prime);
}

// Instantiate an EvenNumbers "collection" class.
EvenNumbers en = new EvenNumbers();

// Iterate it: prints even numbers from 10 down to 4.
Console.WriteLine(" stream of descending evens : ");
foreach (int even in en.DescendingEvens(11, 3))
{
Console.WriteLine(even);
}

// Instantiate a PropertyIterator "collection" class.
PropertyIterator prop = new PropertyIterator();

// Iterate it: produces one double at a time.
Console.WriteLine(" stream of double values: ");
foreach (double db in prop.DoubleProp)
{
Console.WriteLine(db);
}
Console.Read();
}

The Main() method shown provides basic testing functions for the iterator block code. Each of the sections that follow tell you how the code in the Main() method interacts with the iterator block. In other words, the example won't compile until you add the code from the upcoming sections. For now, just know that the Main() method is just one function, and the following sections break it apart so that you can understand it better.

Iterating days of the month: A first example

The following class provides an iterator (shown in bold) that steps through the months of the year:

//MonthDays -- Define an iterator that returns the months
// and their lengths in days -- sort of a "collection" class.
class MonthDays
{
// Here's the "collection."
string[] months =
{ "January 31", "February 28", "March 31",
"April 30", "May 31", "June 30", "July 31",
"August 31", "September 30", "October 31",
"November 30", "December 31" };

//GetEnumerator -- Here's the iterator. See how it's invoked
// in Main() with foreach.
public System.Collections.IEnumerator GetEnumerator()
{
foreach (string month in months)
{
// Return one month per iteration.
yield return month;
}
}
}

Here’s part of a Main() method that iterates this collection using a foreach loop:

// Instantiate a MonthDays "collection" class.
MonthDays md = new MonthDays();

// Iterate it.
foreach (string month in md)
{
Console.WriteLine(month);
}

This collection class is based on an array, as KeyedArray is. The class contains an array whose items are string types. When a client iterates this collection, the collection's iterator block delivers string types one by one. Each string contains the name of a month (in sequence), with the number of days in the month tacked on to the string.

The class defines its own iterator block, in this case as a method named GetEnumerator(), which returns an object of type System.Collections.IEnumerator. Now, it's true that you had to write such a method before, but you also had to write your own enumerator class to support your custom collection class. Here, you just write a fairly simple method to return an enumerator based on the new yield return keywords. C# does the rest for you: It creates the underlying enumerator class and takes care of calling MoveNext() to iterate the array. You get away with much less work and much simpler code.

Your class containing the GetEnumerator() method no longer needs to implement the IEnumerator interface. In fact, you don't want it to. In the following sections, you discover several varieties of iterator blocks:

• Ordinary iterators
• Named iterators
• Class properties implemented as iterators

Note that class MonthDays' GetEnumerator() method contains a foreach loop to yield the string types in its inner array. Iterator blocks often use a loop of some kind to do this, as you can see in several later examples. In effect, you have in your own calling code an inner foreach loop serving up item after item that can be iterated in another foreach loop outside GetEnumerator().

What a collection is, really

Take a moment to compare the little collection in this example with an elaborate LinkedList collection. Whereas LinkedList has a complex structure of nodes connected by pointers, this little months collection is based on a simple array — with canned content, at that. The example expands the collection notion a bit and then develops it even more before this chapter concludes.

Your collection class may not contain canned content — most collections are designed to hold things you put into them via Add() methods and the like. The KeyedArray class in the earlier section “Accessing Collections the Array Way: Indexers,” for example, uses the [] subscript operator to add items. Your collection could also provide an Add() method as well as add an iterator block so that it can work with foreach.

The point of a collection, in the most general sense, is to store multiple objects and to allow you to iterate those objects, retrieving them one at a time sequentially — and sometimes randomly, or apparently randomly, as well, as in the Indexer example. (Of course, an array can do that, even without the extra apparatus of a class such as MonthDays, but iterators go well beyond the MonthDays example.)

More generally, regardless of what an iterable collection does under the hood, it produces a “stream” of values, which you get at with foreach. To drive home the point, here's another simple collection class from IteratorBlocks, one that stretches the idea of a collection about as far as possible (you may think):

//StringChunks -- Define an iterator that returns chunks of text,
// one per iteration -- another oddball "collection" class.
class StringChunks
{
//GetEnumerator -- This is an iterator; see how it's invoked
// (twice) in Main.
public System.Collections.IEnumerator GetEnumerator()
{
// Return a different chunk of text on each iteration.
yield return "Using iterator ";
yield return "blocks ";
yield return "isn't all ";
yield return "that hard";
yield return ".";
}
}

Oddly, the StringChunks collection stores nothing in the usual sense. It doesn't even contain an array. So where’s the collection? It’s in that sequence of yield return calls, which use a special syntax to return one item at a time until all have been returned. The collection “contains” five objects, each a simple string much like the ones stored in an array in the previous MonthDays example. And, from outside the class, in Main(), you can iterate those objects with a simple foreach loop because the yield return statements deliver one string at a time, in sequence. Here's part of a simple Main() method that iterates a StringChunks collection:

// Instantiate a StringChunks "collection" class.
StringChunks sc = new StringChunks();

// Iterate it: prints pieces of text.
foreach (string chunk in sc)
{
Console.WriteLine(chunk);
}

Iterator syntax gives up so easily

The sections that follow focus on two useful statements: yield return and yield break. The yield return statement resembles the combination of MoveNext() and Current for retrieving the next item in a collection. The yield break statement resembles the C# break statement, which lets you break out of a loop or switch statement.

Iterator blocks of all shapes and sizes

In earlier examples in this chapter, iterator blocks have looked like this:

public System.Collections.IEnumerator GetEnumerator()
{
yield return something;
}

But iterator blocks can also take a couple of other forms:

• Named iterators
• Class properties