Two interesting additions to the 2.0 C# language are the Action<> object, and anonymous methods. The Action<> object lets you specify an action to be performed on an object. And the anonymous method lets you specify a method with no body (thus... the anonymity).
The Action Object
|
public delegate void Action<T>(T obj); |
The Action object is used to perform some action on an object and is a perfect place to use an anonymous method.
If we define a method "Write" that writes the value of an integer to the console, and define a delegate with the same signature as the method
|
private delegate void WriteHandler(int value);
public static void Write(int value)
{
Console.WriteLine("value=" + value.ToString());
} |
We can create a method that returns an Action<int> object that fires the delegate.
|
public static Action<int> WriteMessage()
{
WriteHandler whndl = new WriteHandler(Write);
return new Action<int>(whndl);
} |
And we can wire it up like this
|
public static void Run()
{
Action<int> f = WriteMessage();
int x = 0;
while (x++ <= 5)
{
f(x);
}
} |
And we'll get these results
value=1
value=2
value=3
value=4
value=5
value=6 |
Which in itself is pretty cool, but even better...
We can also do the same thing using an anonymous method and drastically reduce the complexity and amount of code required. An anonymous method is a method with no declaration. Basically the functionality is declared along with the delegate. The sample below will return the same results.
|
class Sample
{
public static void Run()
{
Action<int> f = WriteMessage();
int x = 0;
while (x++ <= 5)
{
f(x);
}
}
public static Action<int> WriteMessage()
{
// Anonymous - no method body declared
return delegate(int value)
{
Console.WriteLine("value=" + value.ToString());
};
}
} |
Notice that the compiler can figure out that an Action<int> object needs to be created in order to be returned and takes care of it.
If you would like to see a real-world application of the Action<> object and anonymous methods, check out this great article on the List<> object by Craig Murphy
A Puzzle
Here's a small puzzle for you involving anonymous methods and the Action<> object. Let's say we have a class with an integer member variable.
|
public class MyObject
{
private int m_value = 0;
public int Value
{
get { return m_value; }
set { m_value = value; }
}
} |
We declare some code to increment the value of our member variable using an anonymous method
|
class Sample
{
public static void Run()
{
MyObject myObj = new MyObject();
Action<MyObject> change = Increment();
while (myObj.Value <= 5)
{
change(myObj);
Console.WriteLine("value=" + myObj.Value.ToString());
}
}
public static Action<MyObject> Increment()
{
return delegate(MyObject i) { i.Value++; };
}
} |
And get the following results.
value=1
value=2
value=3
value=4
value=5
value=6 |
So far so good, right?
Now for the brain teaser.
If run the Run() method in the following code
|
class Sample
{
public static void Run()
{
int i = 1;
Action<int> change = Increment();
for (int x = 0; x < 5; x++ )
{
change(i);
Console.WriteLine("value=" + i.ToString());
}
}
public static Action<int> Increment()
{
return delegate(int i) { i++; };
}
} |
Why do we end up with this result
value=1
value=1
value=1
value=1
value=1
value=1 |
Instead of this one?
value=1
value=2
value=3
value=4
value=5
value=6 |
If you give up and want some help figuring it out, check out these articles:
Article 1 | Article 2
Hope you enjoy the puzzle...
Until next time,
Happy coding