Continue with the project from the previous exercise. All the functions we want to call need to be static members of a class, so add the following class to your source code file, just above the main function:

ref class Ops
{
public:
    static double Square(double d)
    {
        return d*d;
    }
};

This managed class contains one public static method, which simply takes a number and returns its square.

Create a delegate in the main function of the application, as shown here:

// Declare a delegate
NumericOp ^op = gcnew NumericOp(&Ops::Square);

When you declared the delegate, you created a new type named NumericOp, so you can now create a NumericOp object. The constructor takes one argument: this is the address of the function that is to be associated with the delegate, so you use the & operator to specify the address of Ops::square.

The object pointed to by op is now set up so that it will call the square function when it is invoked, and it will take exactly the same arguments (and return the same type) as Ops::square.

Every delegate has an Invoke method that you can use to call the function that has been bound to the delegate. Invoke will take the same arguments and return the same type as the function being called. Add the following lines to use op to call the square function:

// Call the function through the delegate
double result = op->Invoke(3.0);

Console::WriteLine("Result is {0}", result);

Build and run the application.

You can now easily create another static member, create a delegate, and call the function. Test this out by adding to the Ops class a second public static member called Cube.

static double Cube(double d)
{
    return d*d*d;
}

Create another delegate in the same way as the first; however, this time, pass it the address of the Cube function in the constructor.

// Create a second delegate and use it to call cube
op = gcnew NumericOp(&Ops::Cube);
result = op(3.0);

Console::WriteLine("Result of Cube() is {0}", result);

There are two things that you might notice about this code. The first is that you have reused the op reference to refer to the new delegate object. This means that the original delegate that you used to call Square is no longer referenced; thus, is can be garbage-collected.

The second is that there is no explicit call to Invoke. To mirror how delegates work in C# (and how function pointers work in unmanaged C++), you can actually omit the Invoke keyword, treating the delegate as if it were a function call itself.

Build and run the application and check that it runs as you expect.

Create a new CLR Console Application project named Multicast.

Open the Multicast.cpp source file and add the definition of a delegate to the top of the file, immediately after the using namespace System; line.

delegate void NotifyDelegate(int);

You can bind this delegate, named NotifyDelegate, to any function that takes one int as an argument and doesn’t return anything.

You’re going to call two functions through the multicast delegate. Because all functions called by delegates have to be members of a managed class, define two classes at the start of your project, each of which contains a static member function.

ref class Client1
{
public:
    static void NotifyFunction1(int n)
    {
        Console::WriteLine("Client1: got value {0}", n);
    }
};

ref class Client2
{
public:
    static void NotifyFunction2(int n)
    {
        Console::WriteLine("Client2: got value {0}", n);
    }
};

These two classes are almost identical, both defining a single static member function that has the signature required by the delegate.

You want to call the two static member functions through one delegate, but you can’t create a delegate to bind to two functions directly. Instead, you need to create two normal delegates (as you did in the previous exercise) and combine them into a multicast delegate. So, define two delegates in the main function, each of which binds to one of the static methods.

Console::WriteLine("Multicast Delegates");

// Create two delegates
NotifyDelegate ^del1 = gcnew NotifyDelegate(&Client1::NotifyFunction1);
NotifyDelegate ^del2 = gcnew NotifyDelegate(&Client2::NotifyFunction2);

At this stage, you could invoke both of the delegates, just as you did in the previous exercise.

Build a multicast delegate from del1 and del2 by using the += operator, as shown in the following:

// Create a third delegate from the first two
NotifyDelegate ^del3;
del3 += del1;
del3 += del2;

You can now invoke the multicast delegate as normal.

// Invoke the multicast delegate
Console::WriteLine("Invoking del3");
del3(5);

Remember that you don’t have to call Invoke explicitly. When you build and run the application, you should see two lines of output, as shown in the following screen shot:

Note that the functions are called in the order in which the delegates are combined, so if you want to change the order, you’ll need to change the way you create the multicast.

You can use this delegate as the basis for making up another one.

// Create a second multicast delegate and invoke it
NotifyDelegate ^del4 = del3 + del3;
Console::WriteLine("Invoking del4");
del4(5);

In this case, you’re combining the invocation list of del3 twice, which results in the output shown in the following screen shot when you invoke it. Notice how you can use the + operator to compose delegates at construction time.

As the final part of this exercise, you can use the –= operator to remove an item from a delegate’s invocation list.

// Remove an item
del3 -= del2;
Console::WriteLine("Invoking del3");
del3(5);

You specify the handle of the delegate that you want to remove on the right side of the –= operator. If the delegate to be removed exists in the invocation list of the first delegate, it will be removed. In this example, you have removed del2 from del3; when you invoke del3, only del1 is executed.

Create a new CLR Console Application named EventHandler.

Add a new class called Counter to the source file. This class should have two data members representing the current count and the limit, and they should be initialized in the constructor.

ref class Counter
{
    int count;
    int limit;
public:

    Counter(int lim)
    {
        count = 0;
        limit = lim;
    }
};

Add the declaration of a standard EventHandler event to the class, placing it in the public section.

event EventHandler ^LimitReached;

Implement the Increment function, arranging for it to fire the LimitReached event at the appropriate point.

void Increment()
{
    Console::WriteLine("Count: {0}", ++count);
    if (count == limit)
        LimitReached(this, gcnew EventArgs());
}

Observe how the arguments to the event are a reference to the current object, and an EventArgs object. This default EventArgs object doesn’t pass any extra information to the client but is necessary to conform to the delegate signature.

You now need some code that will be called when the event is fired, so add an Observer class to the source.

ref class Observer
{
public:
    static void CallMe(Object ^src, EventArgs ^args)
    {
        Console::WriteLine("Limit reached");
    }
};

The static CallMe method has the right signature for an event handler; thus, it can be bound to the LimitReached event.

Implement the main function. Start by creating a Counter object with an appropriate limit set and then bind the CallMe method to the Counter’s LimitReached event. Finally, increment the Counter enough times that the limit is reached.

int main(array<System::String ^> ^args)
{
    // Define a counter with a limit of 3
    Counter count(3);

    count.LimitReached += gcnew EventHandler(&Observer::CallMe);

    for (int i=0; i<5; i++)
        count.Increment();

    return 0;
}

When you build and run the application, you should see the event handler being called when the limit is reached, as shown in the following screen shot: