In the next example, I rename CEE to CEA:

There is an article on Axaptapedia that covers this, that includes a sample xml snippet you can use.

For some reason though, when you google “x++ notepad++”, the Axaptapedia page is nowhere to be found.

I’ve also created a custom language based on the one on wikipedia, that uses colors that resemble the ones in the X++ editor a bit more:

This is how it looks in Notepad++:

Syntax coloring X++ in Notepad++

Links:
Notepad++ homepage
Notepad++ on Axaptapedia

Now let’s see how it helps you maintain you code better when extending classes.

In the previous example, we printed some general information about a record to the screen.
Let’s say that, in case of CustTable we want to have information printed to to screen that is specific to this record, like the AccountNum or Name field.

We will need to create a new class that extends the class we created earlier.

1. ClassDeclaration KLFShowRecordInfo_CustTable
In the ClassDeclaration, we include the keyword ‘extends’ to specify that our new class extends the functionality of the class KLFShowRecordInfo.

2. Construct method KLFShowRecordInfo_CustTable
We will also add a construct method to this class. This will create an instance of this class for us, and set the parm method.
Because we extend a class that contains this parm method, we don’t need to add it to this class again.

3. Run method KLFShowRecordInfo_CustTable
In the run method, we print data from the CustTable record to screen.

You could call the super() method if you want the general information to be printed as well.

4. Construct method KLFShowRecordInfo
The only thing we need to change to the existing class is the construct method.
Modify it like this:

The switch will check which table is being processed, and will create an instance of KLFShowRecordInfo_CustTable in case of CustTable. For all other tables, it will construct an instance of KLFShowRecordInfo.

5. TestJob
Let’s test it:

Output:

00000001
IKEA
—-
VendTable

Conclusion
This concludes my articles about the protected new and construct methods. I realise that the examples are very simple, but the principle will remain the same, even in more complex scenarios.

To sum up:
My basic recommendations when creating classes are:
- Use a protected new method
- Use a construct method
- Use parm methods
- Create a run method that contains your business logic
- Instead of modifying existing classes, create new ones that extend existing

If you disagree, be sure to leave a comment .

Here are two jobs to run inbound and outbound messages manually, so you don’t have to wait for the batches to pick them up.

Inbound:

Outbound:

Ofcourse, you can put this code in classes, or combine them so they are executed together. Because inbound messages can trigger outbound messages, it’s better to process the inbound messages before the outbound messages.

It is best practice to set the new method as protected (MSDN), and it is also best practice to have a construct method in your class (MSDN). So let’s see how we should implement these best practices.

Like a good recipe, a good class has a few important ingredients:
- Parm methods for variables
- A protected new method
- A static contructor
- A run method

1. ClassDeclaration

As an example, we will create a new class: KLFShowRecordInfo
The function of the class will be to display some information about a record.

This class has one variable, a record. The type is Common so we can store any record in this variable.

2. Parm method

First thing is to create a parm-method for this variable (created using parmFromCD editorscript):

Your code will be much cleaner and easier to debug when you use parameter methods.

3. New Method

Next, we will override the new method and make it protected:

Methods that are declared as protected can only be called from methods in the class and in subclasses of the class where the protected method is declared. When we want to create an instance of this class from an other class, we’ll have to call the construct method.
When calling the new() method in any other class, we would get the following compiler error:

The method is declared protected and may only be called from methods in classes derived from KLFShowRecordInfo.

4. Construct method

When using the editorscript to create a construct() method (Right click – Scripts – template – method – construct), it will look like this:

However, I always rewrite it like like this because it is easier to extend afterwards:

Now we’ll have to modify the construct method to receive a parameter, and use the parm method to set the variable in our class:

5. Run method
All we need now is some logic to add to this class. Most of the time, I name the method ‘run’, but you can give it any name you like. The method will display the name of the table of the record you pass to it.

6. Test job
Next, a job to test it:

You can see that we only need one line of code to call our class, and we don’t need a variable, which makes the code cleaner.

Output:

CustTable

Conclusion
When creating a class, start with declaring the new method as protected. This will force you to use a static construct() method. This in turn will force you to think twice about the structure of your class, and will result in cleaner/better code with a more ‘AX-y’ feel.

In part 2 (coming soon), I will demonstrate how this design principle helps you to maintain your code when extending functionality.

With over 80 sessions from international speakers to choose from, it will be difficult to pick the most interesting ones.

See you at TechDays.

Link: Microsoft TechDays 2010

The function str2int() that converts a string to an integer will return ‘0′ if the input string is not an integer, so it is necessary to check if the string is an integer before casting it.

The function that does this is not IsNumeric() like in SQL or VB, but IsInteger().
Alternatively, you can also use str2IntOk(). Both are found in the global class.

I’ve seen people searching for this method (including me), so I just thought I’d share.

Here’s some sample code:

Certainly fast(er than AX) and gets the job done.
Use at your own risk

Update:
You’ll want do do some cleaning up to:
delete the company id from the DataArea table and from the CompanyDomainList table

Then you might feel totally nostalgic when you see the Axapta 3 menu appearing after you run the following job in AX 2009.

The book contains step-by-step instructions along with screenshots and aims at Dynamics AX developers of beginner and intermediate level.

To give you an idea, here are the chapters:
Chapter 1: Processing Data
Chapter 2: Working with Forms
Chapter 3: Working with Data in Forms
Chapter 4: Building Lookups
Chapter 5: Processing Business Tasks
Chapter 6: Integration with Microsoft Ofice

You can buy the book, eg on Amazon.com or at Packt Publishing.

You can also download the sample code used in the book.