Performance considerations: event handlers

Lately I’ve been involved quite a bit in performance analysis and tuning on Ax 2012. It’s not only important to solve the customer’s requirements but at the same time the solution must be implemented in a way that its processing ends before the heath death of the universe.

There’s are lot to say about performance but for now I’ll just stick to a quick heads-up about event handlers and delegates. And to boot I can demonstrate it without worrying about customer specific information.

Eventing was added to Ax 2012 but it’s not widely used in the standard code (if at all). Despite the potentially cleaner design, I’ve seen some instances where it caused some issues.

I decided to try to measure the overhead caused by eventing, ignoring whatever business logic they might perform. The results were beyond my expectations.

My test setup is a simple class with empty methods for different scenarios. The test was performed on an Ax 2012 R3 demo VM.


On the method runWithAOTSubscription a post event handler is defined that calls theAOTHandler. Method runWithDelegateSubscription calls theDelegate to which theDelegateMethod is subscribed using the eventHandler function. Lastly, runWithMethod directly calls theMethod without any events in between.

In main() every scenario is executed 100000 times.

public static void main(Args _args)
    EventHandlerTester eht = new EventHandlerTester();
    int i;
    int maxLoops = 100000;
    for(i=1; i<=maxLoops; i++)
    eht.theDelegate += eventhandler(EventHandlerTester::theDelegateMethod);
    for(i=1; i<=maxLoops; i++)
    for(i=1; i<=maxLoops; i++)

Using the trace parser I found some interesting results. I ran it a couple of times and results were consistent.

The event handlers subscribed using eventHandler are by far the worst. When looking at the call tree it’s fairly obvious why: there seems to be a lot of bookkeeping going on internally.

Event handlers defined in the AOT are an improvement, even though it’s the only scenario which uses a parameter (XppPrePostArgs). This could make matters worse but actually it doesn’t.

And as expected it’s still quicker when calling a method directly.

Now why did I bother investigating this? Because I’ve seen the effect of using event handlers on data methods of often used tables. Even ignoring the body of the event handlers, the simple fact of calling the event handler has a noticeable performance cost. I’m not advocating against the use of event handlers but beware of them when they’re part of code involved in a performance problem.

If you’d like to test this yourself you can use the XPO. Let me know if you have other results or if my approach is flawed (it was getting late when I came up with the idea :)).

4 thoughts on “Performance considerations: event handlers”

  1. Nice analysis. Reminds me of a technical conference video where Peter Villadsen says that delegate event handler should be preferred over AOT Event handlers. Unfortunately he does not say why.

    1. I think it was in one of the recordings about the upcoming Ax 7 that Peter Villadsen casually advised not using AOT event handlers. Probably because they won’t make it to the next version. Ax 7 will be a very different beast altogether, so delegates may no longer have this performance penalty.

    1. Actually there is. I just did a quick test and, as expected, IL is a lot faster. So fast that every scenario executes in less than 1 second. When increasing maxLoops to 100,000,000 it becomes measurable. The AOT event handlers took 87 seconds, delegates 7 and the direct method call ended in 4 seconds. I didn’t do a thorough analysis but I think there’s a clear trend: AOT event handlers in IL are even worse, delegates are better but still noticeably slower than direct method calls.

      The upside is that the performance issue is less important for code running in IL (a single call in any scenario is really fast) and the performance of business logic matters more.

Leave a Reply

Your email address will not be published. Required fields are marked *