Microsoft Dynamics AX
2012 Eventing - a look with X++
This will give an overview of eventing with Dynamics AX 2012, further more I
have given some examples with Pre, Post and Custom Raised Events to help
getting more understanding.
For my example, I'm actually doing straight X++, with no relation to any real
world application yet. The idea is to understand what the mechanics are, and
then from there apply those in design and in development as needed.
You will notice, in the above project, I have a few classes, called Books &
BooksPicker. I think that this would make this a little bit more fun, than the
standard hello world!
So let’s take some time, to examine the Books class within my project.
Here we see the class declaration, in which I have two variables I'm making use
of. A Set, called bookCart and an int called book. This is setting up, for
later use, within the business logic of my Books class.
Next we move forward to the New method of the Apples class.
With it, we see that I'm setting the variables that we saw in the class
declaration, to initialize these variables, for the Set and int types.
Moving forward from there, we go to the next method, called addBooktoCart().
This is where some of the fun starts.
Here we see I'm taking the init book, and adding one to it with the ++; call.
Next we move to actually adding an "book" to our bookCart set, with
the int of apple as part of the key.
Moving from there, we see a final, what looks to be a method call, that is the
following.:
"this.bookCollected(book);"
In looking at this, it would seem as if this was a normal method, and it behaves
as such, however this is not a method, but a delegate I created. We can get a
peak, inside the delegate I created, for the Books class, with the following
screen shot.
Notice that it is blank actually and not doing anything. Its truly a delegate,
and looking at this, within the project, we will see that it appears
differently, that the rest of the methods within the class.
You can create delegates within the AOT space of a given element, as we see on
the Books class in the above image. You do this, as if you were creating a new
method.
What you should also notice, is the fact that below it, we have an event
handler subscriber that we have created in the same fashion.
Diving deeper into the event handler subscription element, we can see that it
has a property page, that allows us to take and set the class, type of, being
X++ or Managed, and then the method to call.
Based on this setup for the event handler subscription element, we can then see
it's calling a static method, called pickBook from the BooksPicker
class.
Now it's very important to point out, that all event handler
subscription elements must be static
methods. These are the only types allowed, for create such an event handler
subscriber, or event listener.
So, what this is doing then, is when the Books.addBookToCart() is called,
within it, via X++ code, we call to a delegate, of Books.bookCollected(). This
delegate, has an event handler subscription setup, for the BooksPicker.pickBook()
method.
Let’s now take a look inside that static method, which represents our event
subscriber, called pickBook().
As you can see from the method, we are taking a parameter of int bookId, which
happens to be the exact method signature of the delegate that
is firing this event handler. This method simply takes and calls to the info
log, claiming that whatever the id value, is that book has now been picked!
Seeing this in action, as part of this class, I have a job, with the following
contents.
In here we see a simple job, that takes and creates a new instance of the Books
class, and contains a “for loop” of 10 iterations, of adding books to cart.
Since our delegate will be called, after a book is added to the Set, then we
see a message similar to the one below, which was fired each time, from the
event handler pickBook().
Now moving beyond the mechanics of this process, this can then been applied in
several instances of AX. Typically, in other languages, we see such event
handlers, as when buttons are clicked, or just before or after a method is
fired.
That is actually an option you can do, for any method, you can setup a pre or post event
handler subscription for a given method, which will fire on the pre or post
processing of another given method.
We can also bring this eventing to a functional level, for say when a Sales
Order or greater than $10,000.00 is invoiced, an event is fired that
automatically places an order for a pizza party, for the dept. :-)
A little elementary school humor there, but if you really start to think about
how this can be used, then the power of such abilities with Microsoft Dynamics
AX 2012, comes to life.
Hope this examples will help in understanding the Eventing in AX.
