C# Anonymous Methods & The Action Object

Matthew Cochran
10y
131k
0
1

Article

Sample1.zip|Sample4.zip|Sample3.zip|Sample2.zip

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());
         }
     }