Closing the Gap Between IEnumerator and IEnumerable - Revision history

Zelenka at 09:35, 22 February 2009

2009-02-22T09:35:33Z

← Older revision		Revision as of 09:35, 22 February 2009
Line 1:		Line 1:
		+	[[Category:CSharp]]
	== ==		== ==
	Ever found yourself writing a custom collection in C# just to be able to pass an IEnumerator into a method that expects IEnumerable? Writing such boilerplate code is never a good idea. The classes [[#class Iterator\|Iterator]] and [[#class Iterator<T>\|Iterator<T>]] presented in this article fill in the missing link from IEnumerator to IEnumerable allowing you to be more productive with iterators.		Ever found yourself writing a custom collection in C# just to be able to pass an IEnumerator into a method that expects IEnumerable? Writing such boilerplate code is never a good idea. The classes [[#class Iterator\|Iterator]] and [[#class Iterator<T>\|Iterator<T>]] presented in this article fill in the missing link from IEnumerator to IEnumerable allowing you to be more productive with iterators.

Henon: /* IEnumerator and Iteration Blocks */

2008-04-21T10:30:32Z

IEnumerator and Iteration Blocks

← Older revision		Revision as of 10:30, 21 April 2008
Line 23:		Line 23:
	:}		:}

-	Obviously IEnumerator is the typical interface of an '''iterator'''. To create a custom iterator (an object exposing interface IEnumerator) there are two major approaches. Your class can "manually" implement the IEnumerator interface. The second and much more interesting one ~~is to~~ use ~~another magic syntax~~ of C# ~~which~~ is called '''iterator block''':	+	Obviously IEnumerator is the typical interface of an '''iterator'''. To create a custom iterator (an object exposing interface IEnumerator) there are two major approaches. Your class can "manually" implement the IEnumerator interface. The second and much more interesting one makes use of C# compiler magic and is called '''iterator block''':

	;Example iterator block which generates the first 7 elements of the Fibonacci sequence		;Example iterator block which generates the first 7 elements of the Fibonacci sequence
Line 51:		Line 51:
	:}		:}

-	The iterator block is a ~~simple~~ method, indexer or property getter which returns IEnumerator or IEnumerator<T>. This is an incredibly useful and even more convenient way to write custom iterators. Moreover iterator blocks are evaluated on demand only so they are the most efficient way to handle large sequences, transformation pipelines or sequences which are created by a mathematical function without consuming memory unnecessarily. If one chains together a number of iterators each iteration block pulls objects from ~~the next~~ iterator ~~for~~ each iteration ~~on demand~~.	+	The '''iterator block''' is a method, indexer or property-getter which returns IEnumerator or IEnumerator<T>. This is an incredibly useful and even more convenient way to write custom iterators. Moreover iterator blocks are evaluated on demand only so they are the most efficient way to handle large sequences, transformation pipelines or sequences which are created by a mathematical function without consuming memory unnecessarily. If one chains together a number of iterators each iteration block pulls objects from its underlying iterator on each iteration step.

	== Chaining Iterators to Processing Pipelines ==		== Chaining Iterators to Processing Pipelines ==

Henon: /* Chaining Iterators to form Processing Pipelines */

2008-04-21T10:25:00Z

Chaining Iterators to form Processing Pipelines

← Older revision		Revision as of 10:25, 21 April 2008
Line 53:		Line 53:
	The iterator block is a simple method, indexer or property getter which returns IEnumerator or IEnumerator<T>. This is an incredibly useful and even more convenient way to write custom iterators. Moreover iterator blocks are evaluated on demand only so they are the most efficient way to handle large sequences, transformation pipelines or sequences which are created by a mathematical function without consuming memory unnecessarily. If one chains together a number of iterators each iteration block pulls objects from the next iterator for each iteration on demand.		The iterator block is a simple method, indexer or property getter which returns IEnumerator or IEnumerator<T>. This is an incredibly useful and even more convenient way to write custom iterators. Moreover iterator blocks are evaluated on demand only so they are the most efficient way to handle large sequences, transformation pipelines or sequences which are created by a mathematical function without consuming memory unnecessarily. If one chains together a number of iterators each iteration block pulls objects from the next iterator for each iteration on demand.

-	== Chaining Iterators to ~~form~~ Processing Pipelines ==	+	== Chaining Iterators to Processing Pipelines ==
	;Example of chaining iteration blocks		;Example of chaining iteration blocks
	:IEnumerator<int> FibonacciSquared(int count)		:IEnumerator<int> FibonacciSquared(int count)

Henon: /* IEnumerator and Iteration Blocks */

2008-04-21T10:23:53Z

IEnumerator and Iteration Blocks

← Older revision		Revision as of 10:23, 21 April 2008
Line 21:		Line 21:
	::bool MoveNext();		::bool MoveNext();
	::object Current{ get; }		::object Current{ get; }
-	.}	+	:}

	Obviously IEnumerator is the typical interface of an '''iterator'''. To create a custom iterator (an object exposing interface IEnumerator) there are two major approaches. Your class can "manually" implement the IEnumerator interface. The second and much more interesting one is to use another magic syntax of C# which is called '''iterator block''':		Obviously IEnumerator is the typical interface of an '''iterator'''. To create a custom iterator (an object exposing interface IEnumerator) there are two major approaches. Your class can "manually" implement the IEnumerator interface. The second and much more interesting one is to use another magic syntax of C# which is called '''iterator block''':

Henon: /* */

2008-04-21T10:23:06Z

← Older revision		Revision as of 10:23, 21 April 2008
Line 1:		Line 1:
	== ==		== ==
-	Ever found yourself writing a custom collection in C# just to be able to pass an IEnumerator into a method that expects IEnumerable? Writing such boilerplate code is never a good idea. The classes ~~'''~~Iterator~~'''~~ and ~~'''~~Iterator<T>~~'''~~ presented in this article fill in the missing link from IEnumerator to IEnumerable allowing you to be more productive with iterators.	+	Ever found yourself writing a custom collection in C# just to be able to pass an IEnumerator into a method that expects IEnumerable? Writing such boilerplate code is never a good idea. The classes [[#class Iterator\|Iterator]] and [[#class Iterator<T>\|Iterator<T>]] presented in this article fill in the missing link from IEnumerator to IEnumerable allowing you to be more productive with iterators.

	== Introduction ==		== Introduction ==

Henon: /* */

2008-04-21T10:21:27Z

← Older revision		Revision as of 10:21, 21 April 2008
Line 1:		Line 1:
	== ==		== ==
-	Ever found yourself writing a custom collection in C# just to be able to ~~fill in~~ an IEnumerator into ~~an interface~~ that expects IEnumerable? Writing boilerplate code ~~like such~~ is never a good idea. The classes '''Iterator''' and '''Iterator<T>''' presented in this article fill in the missing link from IEnumerator to IEnumerable allowing you to be more productive with iterators.	+	Ever found yourself writing a custom collection in C# just to be able to pass an IEnumerator into a method that expects IEnumerable? Writing such boilerplate code is never a good idea. The classes '''Iterator''' and '''Iterator<T>''' presented in this article fill in the missing link from IEnumerator to IEnumerable allowing you to be more productive with iterators.

	== Introduction ==		== Introduction ==

Henon at 10:20, 21 April 2008

2008-04-21T10:20:13Z

← Older revision		Revision as of 10:20, 21 April 2008
Line 1:		Line 1:
-	Ever found yourself writing a custom collection in C# just to be able to fill in an IEnumerator into an interface that expects IEnumerable? ~~Boilerplate~~ code like such is never a good idea. The ~~class~~ Iterator<T> presented in this article ~~fills~~ the missing link ~~between~~ IEnumerator ~~and~~ IEnumerable.	+	== ==
		+	Ever found yourself writing a custom collection in C# just to be able to fill in an IEnumerator into an interface that expects IEnumerable? Writing boilerplate code like such is never a good idea. The classes '''Iterator''' and '''Iterator<T>''' presented in this article fill in the missing link from IEnumerator to IEnumerable allowing you to be more productive with iterators.

	== Introduction ==		== Introduction ==

Henon: /* Chaining Iterators to form Processing Pipelines */

2008-04-21T09:55:57Z

Chaining Iterators to form Processing Pipelines

← Older revision		Revision as of 09:55, 21 April 2008
Line 76:		Line 76:

	;Example of using LINQ with an iteration block called Traverse which enumerates all nodes in a tree.		;Example of using LINQ with an iteration block called Traverse which enumerates all nodes in a tree.
-	var nodes = new Iterator( tree.Traverse()); // <--- Traverse is an iteration block and returns an IEnumerator which cannot directly be fed into a LINQ query.	+	:var nodes = new Iterator( tree.Traverse()); // <--- Traverse is an iteration block and returns an IEnumerator which cannot directly be fed into a LINQ query.
-	var leaves = from n in nodes where n.IsLeaf() select n;	+	:var leaves = from n in nodes where n.IsLeaf() select n;

	== class Iterator ==		== class Iterator ==

Henon: /* interface IEnumerator */

2008-04-21T09:53:51Z

interface IEnumerator

← Older revision		Revision as of 09:53, 21 April 2008
Line 14:		Line 14:
	Strictly speaking IEnumerable is just a wrapper for IEnumerator which enables foreach magic for any type which implements it. So let's have a look at IEnumerator:		Strictly speaking IEnumerable is just a wrapper for IEnumerator which enables foreach magic for any type which implements it. So let's have a look at IEnumerator:

-	== ~~interface~~ IEnumerator ==	+	== IEnumerator and Iteration Blocks ==
-	;interface IEnumerator	+	:interface IEnumerator
-	:void Reset();	+	:{
-	:bool MoveNext();	+	::void Reset();
-	:object Current{ get; }	+	::bool MoveNext();
		+	::object Current{ get; }
		+	.}

	Obviously IEnumerator is the typical interface of an '''iterator'''. To create a custom iterator (an object exposing interface IEnumerator) there are two major approaches. Your class can "manually" implement the IEnumerator interface. The second and much more interesting one is to use another magic syntax of C# which is called '''iterator block''':		Obviously IEnumerator is the typical interface of an '''iterator'''. To create a custom iterator (an object exposing interface IEnumerator) there are two major approaches. Your class can "manually" implement the IEnumerator interface. The second and much more interesting one is to use another magic syntax of C# which is called '''iterator block''':

Henon: /* interface IEnumerable */

2008-04-21T09:53:08Z

interface IEnumerable

← Older revision		Revision as of 09:53, 21 April 2008
Line 4:		Line 4:
	C# defines two interfaces for convenient iteration over a sequence of values or objects. '''IEnumerable''' which allows to "foreach" over a collection and is implemented basically by every collection of the .NET framework and '''IEnumerator''' which is exposed by an iterator which is the return value of an iteration function. Both interfaces exist in generic and non-generic versions but for simplicity we only talk about the non-generic versions without loss of generality. The definition of IEnumerable is as simple as this:		C# defines two interfaces for convenient iteration over a sequence of values or objects. '''IEnumerable''' which allows to "foreach" over a collection and is implemented basically by every collection of the .NET framework and '''IEnumerator''' which is exposed by an iterator which is the return value of an iteration function. Both interfaces exist in generic and non-generic versions but for simplicity we only talk about the non-generic versions without loss of generality. The definition of IEnumerable is as simple as this:

-	== ~~interface~~ IEnumerable ==	+	== IEnumerable ==
-	;interface IEnumerable	+	:interface IEnumerable
-	:IEnumerator GetEnumerator();	+	:{
		+	::IEnumerator GetEnumerator();
		+	:}

	The main purpose of this interface is to allow a syntactically uncomplicated and hence convenient way to iterate over a collection by using the '''foreach''' statement. This convenience and the fact, that it is exposed by every standard collection makes IEnumerable the perfect parameter type for methods that accept any kind of collection. A prominent example use case is LINQ which allows to pipeline IEnumerables through a number of cascaded transformation functions.		The main purpose of this interface is to allow a syntactically uncomplicated and hence convenient way to iterate over a collection by using the '''foreach''' statement. This convenience and the fact, that it is exposed by every standard collection makes IEnumerable the perfect parameter type for methods that accept any kind of collection. A prominent example use case is LINQ which allows to pipeline IEnumerables through a number of cascaded transformation functions.