But the sad part is that there is no walk extension method. Walk is a functional programming staple that iterates over a collection of stuff and applies a callback to each one. In PHP, there is array_walk, in JavaScript there is each.

You might be thinking, “but there is a ForEach() extension method on List!”. And you would be wrong, because there is a subtle, yet important difference between IEnumerable and IList.

IEnumerable is late-binding. That means you can do whatever you want to it, but execution is deferred until you actually enumerate the enumeration, i.e. using a foreach construct. In a list, there is no deferred execution. This deferred execution is accomplished through the magic of closures and expression trees. Read up on them.

In the meantime, here is a fluent implementation of walk:

public static class LinqExtensions {
	public static IEnumerable<T> Walk<T>(this IEnumerable<T> source, Action<T> action) {
		foreach (var t in source) {
			action(t);
			yield return t;
		}
	}
}

You can prove that this is in fact using deferred execution with a simple test:

class Program {

	class Foo {
		public int Bar { get; set; }

		public override string ToString() {
			return string.Format("Foo(Bar={0})", Bar);
		}
	}

	static void Main() {
		IEnumerable<Foo> foos = new[] { new Foo { Bar = 2 }, new Foo { Bar = 1 }, new Foo { Bar = 3 } };

		Console.WriteLine("IEnumerable.Walk():");
		foos.Walk(Console.WriteLine);
		Console.WriteLine();

		Console.WriteLine("List.ForEach():");
		foos.ToList().ForEach(Console.WriteLine);
		Console.WriteLine();

		Console.ReadLine();
	}

}

The output looks like this:

Notice that nothing got printed the first time through, using the Walk() extension method. There’s your deferred execution. That means our extension method did not enumerate the enumeration, so it’s safe and efficient to use walk in a normal linq expression where you are depending on deferred execution, like this:

IEnumerable<Foo> foos = new[] { new Foo { Bar = 2 }, new Foo { Bar = 1 }, new Foo { Bar = 3 } };

Console.WriteLine("Doing more stuff:");
var listOStuff = foos
	.Where(foo => foo.Bar >= 2)
	.Walk(foo => foo.Bar += 10)
	.Select(foo => new Baz { Foofy = foo })
	.Walk(baz => baz.Foofy.Bar--)
	.OrderBy(baz => baz.Foofy.Bar);

foreach (var stuff in listOStuff) {
	Console.WriteLine(stuff);
}

Console.ReadLine();

Well, maybe that’s not “normal.” Whatever.

It is a compile-time error for an expression in an anonymous object initializer to be of the null type.

And you can’t. Directly.

var obj = new {
  Value = null //syntax error: "cannot assign null to anonymous type property"
};

var obj = new {
  Value = (object)null //full of win
};

//seriously, it works
Console.WriteLine(obj.Value == null); //True

Somebody please explain to me why this works.

var s = string.Format("My name is {1}, {0}", "Tommy", "Montgomery");
//s = "My name is Montgomery, Tommy"

var s = string.Format("My name is {{{0}}}", "Tommy");
//s = "My name is {Tommy}"

I needed that. Here it is, PHPified:

function format($format) {
	$args = func_get_args();
	$format = array_shift($args);

	preg_match_all('/(?=\{)\{(\d+)\}(?!\})/', $format, $matches, PREG_OFFSET_CAPTURE);
	$offset = 0;
	foreach ($matches[1] as $data) {
		$i = $data[0];
		$format = substr_replace($format, @$args[$i], $offset + $data[1] - 1, 2 + strlen($i));
		$offset += strlen(@$args[$i]) - 2 - strlen($i);
	}

	return $format;
}

There’s a lot going on in here that isn’t used very often in PHP. Here is a terse explanation of the not-so-obvious features:

• The PREG_OFFSET_CAPTURE constant tells the regex engine to capture the string index offset of each match.
• (?=\{) and (?!\}) in the regular expression are positive and negative lookarounds, respectively. The nice thing about that is they’re also zero-width matching, which means they won’t be returned as part of the match result. These are needed because to output a literal { in a C# string you precede it with another { (a little know fact about C#).
• substr_replace is an infrequently used, extremely useful function, that replaces a substring within a string, expanding to the given width.
• The $offset variable tracks the string length delta. Since we’re modifying the string, the offsets captured in the regex match becomes out of date.

Mmmmm… smells like win.