Day: April 20, 2018

Enumeration and Iterators

Enumeration

Read-only, forward-only cursor over a sequence of values.

Enumerator object implements one of the interfaces:

• System.Collections.IEnumerator
• System.Collections.Generics.IEnumerator<T>

Enumerable object:

• Iterates using foreach statement
• Implements IEnumerable or IEnumerable<T>
• Has a method named GetEnumerator that returns an enumerator

The enumeration pattern:

Implements IEnumerator or IEnumerator<T>

class Enumerator
{
	public IteratorVariableType Current { get { ... }}
	public bool MoveNext() { ... }
}

Implements IEnumerable or IEnumerable<T>

class Enumerable
{
	public Enumerator GetEnumerator() { ... }
}

// High-level way of iterating through the characters in the word “beer”:

foreach (char c in "beer")
	Console.WriteLine (c);

// Low-level way of iterating through the same characters:

using (var enumerator = "beer".GetEnumerator())
	while (enumerator.MoveNext())
	{
		var element = enumerator.Current;
		Console.WriteLine (element);
	}

Collection Initializers

Enumerable object can be instantiated and populated in a single step.

Enumerable object implements the System.Collections.IEnumerable interface and it has Add method with appropriate number of parameters for the call.

List list = new List {1, 2, 3};
// Equivalent to:
{
	List list = new List();
	list.Add (1);
	list.Add (2);
	list.Add (3);
}

With dictionaries

var dict1 = new Dictionary()
{
  { 5, "five" },
  { 10, "ten" }
};
//you can use the indexer
var dict2 = new Dictionary()
{
  [3] = "three",
  [10] = "ten"
};

Iterators

Whereas a foreach statement is a consumer of an enumerator, an iterator is a producer of an enumerator.

static void Main()
{
	foreach (int fib in Fibs(6))
		Console.Write (fib + "  ");
}

static IEnumerable Fibs (int fibCount)
{
	for (int i = 0, prevFib = 1, curFib = 1; i < fibCount; i++)
	{
		yield return prevFib;
		int newFib = prevFib+curFib;
		prevFib = curFib;
		curFib = newFib;
	}
}

Iterator Semantics

An iterator is a method, property or indexer that contains one or more yield statements. It must return one of the following interfaces:

// Enumerable interfaces
System.Collections.IEnumerable
System.Collections.Generic.IEnumerable

// Enumerator interfaces
System.Collections.IEnumerator
System.Collections.Generic.IEnumerator

An iterator has different semantics, depending on whether it returns an enumerable interface or an enumerator interface.

Multiple yield statment example:

static void Main()
{
	foreach (string s in Foo())
		Console.WriteLine(s);         // Prints "One","Two","Three"
}

static IEnumerable Foo()
{
	yield return "One";
	yield return "Two";
	yield return "Three";
}

yield break

The yield break statement indicates that the iterator block should exit early, without returning more elements

static void Main()
{
	foreach (string s in Foo (true))
		Console.WriteLine(s);
}

static IEnumerable Foo (bool breakEarly)
{
	yield return "One";
	yield return "Two";
	
	if (breakEarly)
		yield break;
	
	yield return "Three";
}

Iterators and try/catch/finally blocks

A yield return statement cannot appear in a try block that has a catch clause. It can also not appear in a catch or finally block

static void Main()
{
	foreach (string s in Foo())
		Console.WriteLine(s);
}

static IEnumerable Foo()
{
	try { yield return "One"; }		// Illegal
	catch { /*...*/ }
}

It is possible to yield within a try block that has only a finally block.

static void Main()
{
	foreach (string s in Foo()) s.Dump();
	
	Console.WriteLine();
		
	foreach (string s in Foo())
	{
		("First element is " + s).Dump();
		break;
	}
}

static IEnumerable Foo()
{
	try 
	{
		yield return "One";
		yield return "Two";
		yield return "Three";
	}
	finally { "Finally".Dump(); }
}

The code in the finally block executes when the consuming enumerator reaches the end of the sequence or is disposed.

A foreach statement implcitly disposes the enumerator if you break early.

For explicit enumerators, a trap is to abandon enumeration early without disposing it. This can be avoided with the using statement.

string firstElement = null;
var sequence = Foo();
using (var enumerator = sequence.GetEnumerator())
	if (enumerator.MoveNext())
		firstElement = enumerator.Current;

Composing Sequences

Iterators are highly composable.

static void Main()
{
	foreach (int fib in EvenNumbersOnly (Fibs(6)))
		Console.WriteLine (fib);
}

static IEnumerable Fibs (int fibCount)
{
	for (int i = 0, prevFib = 1, curFib = 1; i < fibCount; i++)
	{
		yield return prevFib;
		int newFib = prevFib+curFib;
		prevFib = curFib;
		curFib = newFib;
	}
}

static IEnumerable EvenNumbersOnly (IEnumerable sequence)
{
	foreach (int x in sequence)
		if ((x % 2) == 0)
			yield return x;
}

try Statements and Exceptions

Try statement specifies a code block subject to error-handling. Try block must be followed by a catch block , finally block or both.

catch block

Executes when an error occurs in the try block, access an Exception object that contains information about the error, however you can use to compensate the error or rethrow the exception.

finally block

Executes after execution leaves the try block and if present the catch block, useful for cleanup tasks such as closing network connections.,/p>

Try statement code block:

try
{
   ... // exception may get thrown within execution of this block
}
catch (ExceptionA ex)
{
   ... // handle exception of type ExceptionA 
}
catch (ExceptionB ex)
{
   ... // handle exception of type ExceptionB 
}
finally
{
   ... // cleanup code
}

DivideByZeroException

// Because Calc is called with x==0, the runtime throws a DivideByZeroException: 

static int Calc (int x) { return 10 / x; }

static void Main()
{
	int y = Calc (0);
	Console.WriteLine (y);
}

Catching the Exception

static int Calc (int x) { return 10 / x; }

static void Main()
{
	try
	{
		int y = Calc (0);
		Console.WriteLine (y);
	}
	catch (DivideByZeroException ex)
	{
		Console.WriteLine ("x cannot be zero");
	}
	Console.WriteLine ("program completed");
}

The catch Clause

Specifies what type of exception to catch, can be from System.Exception or subclass of System.Exception. You can handle multiple exception types with multiple catch clauses.

static void Main() { Main ("one"); }

static void Main (params string[] args)
{
	try
	{
		byte b = byte.Parse (args[0]);
		Console.WriteLine (b);
	}
	catch (IndexOutOfRangeException ex)
	{
		Console.WriteLine ("Please provide at least one argument");
	}
	catch (FormatException ex)
	{
		Console.WriteLine ("That's not a number!");
	}
	catch (OverflowException ex)
	{
		Console.WriteLine ("You've given me more than a byte!");
	}
}

static int Calc (int x) { return 10 / x; }

Exception Filters

You can specify an exception filter in a catch clause by adding a when clause.

try
{
	new WebClient().DownloadString ("http://thisDoesNotExist");
}
catch (WebException ex) when (ex.Status == WebExceptionStatus.Timeout)
{
	"Timeout!".Dump();
}
catch (WebException ex) when (ex.Status == WebExceptionStatus.NameResolutionFailure)
{
	"Name resolution failure!".Dump();
}
catch (WebException ex) 
{
	$"Some other failure: {ex.Status}".Dump();
}

The finally Block

Used for code cleanup, executes after a catch block finishes or after control leaves the try block because of a jump statement or after the try block ends. The only things that can defeat a finally block are infinite loop or process ending abruptly.

The using statement

Implements System.IDisposable which defines a single parameterless method named Dispose to clean up the resources.

The using statement provides an elegant syntax for calling Dispose on an IDisposable object with in finally block.

using (StreamReader reader = File.OpenText("file.txt"))
{ ... }

is equivalent to:

{
  StreamReader reader = File.OpenText("file.txt");
  try
  {
    ...
  }
  finally
  {
     if(reader != null)
       ((IDisposable)reader).Dispose();
  }
}

Throwing Exceptions

Exceptions can be thrown either by the runtime or in user code.

static void Display (string name)
{
	if (name == null)
		throw new ArgumentNullException (nameof (name));

	Console.WriteLine (name);
}

static void Main()
{
	try
	{
		Display (null);
	}
	catch (ArgumentNullException ex)
	{
		Console.WriteLine ("Caught the exception");
	}
}

Rethrowing an exception

Rethrowing lets you back out of handling an exception should circumstances turn out to be outside what you expected.

string s = null;

using (WebClient wc = new WebClient())
	try { s = wc.DownloadString ("http://www.albahari.com/nutshell/");  }
	catch (WebException ex)
	{
		if (ex.Status == WebExceptionStatus.NameResolutionFailure)
			Console.WriteLine ("Bad domain name");
		else
			throw;     // Can’t handle other sorts of WebException, so rethrow
	}

s.Dump();

Using exception filter:

catch (WebException ex) when (ex.Status == WebExceptionStatus.Timeout)
{
  Console.WriteLine("Timeout");
}

Throwing more specific exception type:

try
{
  ... // Parse a DateTime from XML element data
}
catch (FormatException ex)
{
   throw new XmlException ("Invalid DateTime", ex);
}

Key Properties of System.Exception

StackTrace

A string representing all the methods that are called from the origin of the exception to the catch block.

Message

A string with a description of the error.

InnerException

The inner exception that caused the outer exception.

Common Exception Types

System.ArgumentException

Thrown when a function is called with a bogus argument. This generally indicates a program bug.

System.ArgumentNullException

Subclass of ArgumentException that’s thrown when a function argument is (unexpectedly) null.

System.ArgumentOutOfRangeException

Subclass of ArgumentException that’s thrown when a argument is too big or too small. Eg passing a negative number into a function that accepts only positive values.

System.InvalidOperationException

Thrown when the state of an object is unsuitable for a method to sucessfully execute regardless of any particular argument values.

System.NotSupportedException

Thrown to indicate that a particular function is not supported. Eg calling Add method on a collectionwhich is IsReadOnly.

System.NotImplementedException

Thrown to indicate that a function has not yet been implemented

System.ObjectDisposedException

Thrown when the object upon which the function is called has been disposed.

System.NullReferenceException

Thrown when you attempt to access a member of an object whose value is null.

The TryXXX Method Pattern

Offers both for exception: Parse and TryParse.

static void Main()
{
	bool result;
	TryToBoolean ("Bad", out result).Dump ("Successful");
	result = ToBoolean ("Bad");		// throws Exception
}

public static bool ToBoolean (string text)
{
	bool returnValue;
	if (!TryToBoolean (text, out returnValue))
		throw new FormatException ("Cannot parse to Boolean");
	return returnValue;
}

public static bool TryToBoolean (string text, out bool result)
{
	text = text.Trim().ToUpperInvariant();	
	if (text == "TRUE" || text == "YES" || text == "Y")
	{
		result = true;
		return true;
	}
	if (text == "FALSE" || text == "NO" || text == "N")
	{
		result = false;
		return true;
	}
	result = false;
	return false;
}

The Atomicity Pattern

static void Main()
{
	Accumulator a = new Accumulator();
	try
	{
		a.Add (4, 5);             // a.Total is now 9
		a.Add (1, int.MaxValue);  // Will cause OverflowException
	}
	catch (OverflowException)
	{
		Console.WriteLine (a.Total);  // a.Total is still 9
	}
}

public class Accumulator
{
	public int Total { get; private set; }
	
	public void Add (params int[] ints)
	{
		bool success = false;
		int totalSnapshot = Total;
		try
		{
			foreach (int i in ints)
			{
				checked { Total += i; }
			}
			success = true;
		}
		finally
		{
			if (! success)
				Total = totalSnapshot;
		}
	}
}