Extension of classes, tables and forms in D365FO/AX 7.0

First method is of course the legacy method of creating a derived class which we want to extend, adding or overriding base methods in it and use this class in our new model instead of the base class. This solves many of the customization work we need but there might be cases this method is not desirable or we cannot modify the code of existing tables and forms like that.

Second option is to create something new called an ‘extension class’ to extend the program code of an existing object. This is simply done by creating an extension class with the template shown below using the ‘ExtensionOf’ attribute:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

[ExtensionOf(classStr(MyClass))] final class MyClass_Extension { private int myParm; private void new() { } public int parmMyParm(int _myParm = myParm) { myparm = _myParm; return myParm; } public static MyClass constructFromMyParm(int _myParm) { MyClass myClass; myClass = new MyClass(); myClass.parmMyParm(_myParm); return myClass; } }

This way you can add new methods, variables, constructors and static methods directly added to the base class instead of using a derived class. After this, you can call the new methods and constructors you have added in your extension class directly from the base class itself, such as:

MyClass::constructFromMyParm(24).

The suffix of the extension class you have created must be ‘_Extension’ and you can name the MyClass part with anything you want, it does not have to be the base class name. Same way you can create code extensions for tables and forms (as of version update2) as well, later we will try an example with each.

Although this looks like a derived class construction, the extension class is not a derived class from the base and you cannot access private and protected methods and variables, nor override existing methods of the base class here. But it is possible to access public methods and variables of the base class as well as using ‘this’ keyword in your method declarations to access those. It is also possible to access the methods of other extensions on the same base object if you have added the model that includes the other extension class in your model definition’s referenced packages.

I also want to mention the extension class template below. Before the “Update1” version of AX7, the template for creating the extension class for tables and classes was like below :

1 2 3 4 5 6 7 8

public static class MyClass_Extension { public static int parmMyParm(MyClass _this, int _myParm = myParm) { myparm = _myParm; return myParm; } }

Here you declare your class and all the class methods as static (class with _Extension suffix) and add the object you want to extend as the first parameter of your method. I do not recommend using this template in your new program code because the new one is more readable and useful, but be aware: On runtime your new notation extension class works exactly the same way using static method calls, just like the old notation did. This is why you cannot access class private and protected variables nor override existing methods in it. Also for the same reason you should not create a direct instance of the extension class in your program code, nor create another class derived from your extension class (it also receives a “sealed” attribute when built into CIL, like other static classes in .net). You can confirm it for yourself using visual studio debugger:

Creating table methods is pretty the same, you can even create new display and edit methods as shown below, to be used in a form (or form extension) in the same model :

1 2 3 4 5 6 7 8 9 10 11 12 13

[ExtensionOf(tableStr(InventTable))] final class ExtensionDemo_Extension { private void new() {} [SysClientCacheDataMethodAttribute(true)] public display Description dispExtendedDesc() { return this.Description5+this.Description6; } }

To be able to use this display method in your form, you need to define the “Data method” property of your data field like this, using static method operator and name of your extension class (“ExtensionDemo_Extension::dispExtendedDesc”). Directly writing the method name will not work :

Form extensions are created pretty much the same way. The newly added methods are accessible from the form and its extensions. The ‘this’ object in your extension contains the element object (FormRun) of the extended form, so you can query for elements and data sources easily from here. Here is an example how to use element variables in a form extension class in various different ways :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

[ExtensionOf( formstr( ExtensionDemoForm ))] final class ExtensionDemoForm_Extension {  private boolean hasArgs;  private void new()  {}  public boolean parmHasArgs(boolean _hasArgs = hasArgs)  {  hasArgs = _hasArgs;  return hasArgs;  }  public boolean hasArgsRecord()  {  return (this.args().record()!=null);  }  [FormEventHandler(formStr(ExtensionDemoForm), FormEventType::Initialized)]  public void ExtensionDemoForm_OnInitialized(xFormRun sender, FormEventArgs e)  {  this.parmHasArgs((this.args()!=null));  } }

Note that the event handler here does not have the ‘static’ keyword, but instead declared as a class instance method intentionally removing the static keyword from the definition. It is possible to declare some of the event handlers like that then you can use ‘this’ keyword to access methods and variables defined in the same class from a eventhandler (more on eventhandlers on Part3).

You can add a simple click method and test our extension method inside the form :

public void clicked() { super(); info(strFmt("Has args?: %1", element.parmHasArgs())); info(strFmt("Has args record?: %1", element.hasArgsRecord())); }

Eventually it is also possible to override form control and data field methods from the form extension class, which gives you much more flexibility in creating extensions for forms:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

[ExtensionOf( formstr( ExtensionDemoForm ))] public final class ExtensionDemoForm_Extension { public void clickedOverride() { info(strFmt("Name : %1", this.name())); } [FormEventHandler(formStr(ExtensionDemoForm), FormEventType::Initialized)] public void ExtensionDemoForm_OnInitialized(xFormRun sender, FormEventArgs e) { FormButtonControl button = this.design().controlName(formControlStr(ExtensionDemoForm,FormButtonControl1)); button.registerOverrideMethod(methodStr(FormButtonControl,clicked),'clickedOverride', this); } }

A note on form class extensions: In this time of writing (Update 3 version), not everything with form class extensions work all right, it has some bugs which are already reported to Microsoft. For example the code above compiles ok but on runtime the method above is not accesible from the Formrun class, although the previous example compiles and runs just fine (just using ‘this’ keyword in the same class). I will post an update if things change in the future on that part.

Plugins

Plugins are yet another way to extend code in new AX7 besides the extension methods we mentioned above. Plugins use attributes to create new subclasses and subclass methods which can be used as alternatives to existing classes and methods belonging to same plugin base and can be initialized using a string type of key from the SysPluginFactory class. This way you can also choose which plugin to use by selecting it with a string parameter. I will not get into the details of using plugins and the attributes used in plugin framework but perhaps I might write another blog about them in the future.