Creating Code at Runtime (Part 3)

See Creating Code At Runtime - Part 1
See Creating Code At Runtime - Part 2

I want to change our previous delegate for one more standard, like EventHandler. The new class must looks like:

public delegate void BeforeBuildFullNameHandler(object sender, EventArgs e);

public class Person
{
    private string _firstname;
    private string _lastname;

    public event BeforeBuildFullNameHandler BeforeBuildFullName;

    public string FirstName
    {
        get { return _firstname; }
        set { _firstname = value; }
    }

    public string LastName
    {
        get { return _lastname; }
        set { _lastname = value; }
    }

    public Person()
    {
        _firstname = "";
        _lastname = "";
    }

    public Person(string firstname, string lastname)
    {
        FirstName = firstname;
        LastName = lastname;
    }

    public string GetFullName()
    {
        DispatchBeforeBuildFullName();

        return FirstName + " " + LastName;
    }

    public void DispatchBeforeBuildFullName()
    {
        if (BeforeBuildFullName != null)
            BeforeBuildFullName(this, new EventArgs());
    }
}

Steps: 1. We need to change the Invoke, BeginInvoke and EndInvoke methods:

// Now, we need to implement three methods:
// Invoke, BeginInvoke and EndInvoke
MethodBuilder methodBuilder;

// Because we are using a delegate with parameters,
// then, we need to declare four parameters for 
// asynchronous operations: AsyncCallback and object (any)
Type[] beginParameters = new Type[4];

beginParameters[0] = typeof(object);
beginParameters[1] = typeof(EventArgs);
beginParameters[2] = typeof(AsyncCallback);
beginParameters[3] = typeof(object);

// BeginInvoke for Asynchronous call
methodBuilder = delegateBuilder.DefineMethod("BeginInvoke", maDelegate, typeof(IAsyncResult), beginParameters);
methodBuilder.SetImplementationFlags(mia);

// EndInvoke for Asynchronous call
methodBuilder = delegateBuilder.DefineMethod("EndInvoke", maDelegate, typeof(void), new Type[] { typeof(IAsyncResult) });
methodBuilder.SetImplementationFlags(mia);

// Invoke for Synchronous call
methodBuilder = delegateBuilder.DefineMethod("Invoke", maDelegate, typeof(void), new Type[] { typeof(object), typeof(EventArgs) });
methodBuilder.DefineParameter(1, ParameterAttributes.In, "sender");
methodBuilder.DefineParameter(2, ParameterAttributes.In, "e");
methodBuilder.SetImplementationFlags(mia);

2. Also, we need to change the Dispath method:

// And here, the code for the dispatchMethod
ilgen = dispatchMethodBuilder.GetILGenerator();

LocalBuilder local = ilgen.DeclareLocal(typeof(bool));
System.Reflection.Emit.Label label = ilgen.DefineLabel();

ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // Asking for the event field
ilgen.Emit(OpCodes.Ldnull);                        // is null ?
ilgen.Emit(OpCodes.Ceq);
ilgen.Emit(OpCodes.Stloc_0);
ilgen.Emit(OpCodes.Ldloc_0);
ilgen.Emit(OpCodes.Brtrue_S, label);            // if null, return

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // call the event

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Newobj, typeof(EventArgs).GetConstructor(Type.EmptyTypes)); // Now, we include a new empty EventArgs object

ilgen.Emit(OpCodes.Callvirt, delegateType.GetMethod("Invoke"));

ilgen.Emit(OpCodes.Nop);
ilgen.MarkLabel(label);
ilgen.Emit(OpCodes.Ret);