INDEXERS, ENUMERATORS, AND ITERATORS in Visual C#

Encoding PDF-417 2d barcode in Visual C# INDEXERS, ENUMERATORS, AND ITERATORS

You can also use iterators to implement generic enumeration. The only change required to implement a generic iterator is to change the return type of the function from IEnumerator and IEnumerable to IEnumerator<T> and IEnumerable<T>. The actual iterator code remains unchanged. Converting the earlier IntList class into a generic equivalent, you get the following: // Note: This class is not thread-safe public class GenericList<T> : IEnumerable<T> { T[] values = new T[10]; int allocated = values.Length; int count = 0; int revision = 0; public void Add(T value) { // reallocate if necessary... if (count + 1 == allocated) { T[] newValues = new T[allocated * 2]; for (int index = 0; index < count; index++) { newValues[index] = values[index]; } allocated *= 2; } values[count] = value; count++; revision++; } public int Count { get { return (count); } } void CheckIndex(int index) { if (index >= count) throw new ArgumentOutOfRangeException("Index value out of range"); } public T this[int index] { get { CheckIndex(index); return (values[index]); }

set { CheckIndex(index); values[index] = value; revision++; } } public IEnumerator<T> GetEnumerator() { for (int index = 0; index < count; ++index) { yield return values[index]; } } public IEnumerable<T> BidirectionalSubrange(bool forward, int start, int end) { if (start < 0 || end >= count) { throw new IndexOutOfRangeException("Start must be zero or greater and end must" + " be less than the size of the collection"); } if (forward) { for (int index = start; index < end; ++index) { yield return values[index]; } } else { for (int index = end; index >= start; --index) { yield return values[index]; } } } internal int Revision { get { return (revision); } } }

IEnumerator<T> doesn t contain a Reset method, so the earlier discussion about Reset throwing a NotSupportedException exception doesn t apply.

Iterators make writing enumerators over collection and collection-like classes much easier. By offloading the implementation of the state machine needed to track the position in the collection that a particular enumeration is up to, iterators dramatically simplify the C# code needed to implement even the most complex enumerations. As with all code simplification features, particularly those that are new, there s a tendency to initially overuse the feature. Although this isn t overly harmful in the case of iterators, you should strive to achieve a balance between offering a rich set of enumeration options and avoiding bogging a class down with an excess of enumerators that can make changing the internal implementation of the collection laborious.

numerations are useful when a value in the program can have a specific set of values only. For example, when a control can be only one of four colors, or when a network package can support only two protocols, an enumeration can improve the code.

In the following example, a line-drawing class uses an enumeration to declare the styles of lines it can draw: using System; public class Draw { public enum LineStyle { Solid, Dotted, DotDash, // trailing comma is optional } public void DrawLine(int x1, int y1, int x2, int y2, LineStyle lineStyle) { switch (lineStyle) { case LineStyle.Solid: // draw solid break; case LineStyle.Dotted: // draw dotted break;

case LineStyle.DotDash: // draw dotdash break; default: throw(new ArgumentException("Invalid line style")); } } } class Test { public static void Main() { Draw draw = new Draw(); draw.DrawLine(0, 0, 10, 10, Draw.LineStyle.Solid); draw.DrawLine(5, 6, 23, 3, (Draw.LineStyle) 35); } } The LineStyle enum defines the values that can be specified for the enum, and then that same enum is used in the function call to specify the type of line to draw. Although enums prevent the accidental specification of values outside the enum range, the values that can be specified for an enum aren t limited to the identifiers specified in the enum declaration. The second call to DrawLine() is legal, so an enum value passed into a function must still be validated to ensure it s in the range of valid values. The Draw class throws an invalid argument exception if the argument is invalid.