In the previous article, I explained what Chain Of Command is, and how to use it in Microsoft Dynamics 365. I provided a basic example of Chain of Command, and explained what pieces are required. In this article we will look at an example of how to implement Chain Of Command for Form DataSource methods.
Objects That Can Use Chain Of Command
As a review, there are several different objects in Microsoft Dynamics 365 that can use Chain Of Command. I will list the most common here.
- Classes
- Tables
- Forms
- Datasource on a form.
- Data field on a form.
- Control of a form.
- Data entities
Chain of Command Rules
Before providing an example of using Chain of Command for form datasource methods, I wanted to first review the requirements that all Chain Of Command classes must follow. If you do not follow these rules, the compiler will not recognize your new class as a Chain of Command class.
- The name of the new class you create must end with the text ‘_Extension’.
Pro Tip: Because classes and forms and tables are often named the same thing, and each can be modified using Chain of Command, I have found it helpful to put the object type in the name of the Chain of Command class. This is not required, however, it will make your code more readable. I recommend using a format like this: <BaseObjectName>_<ObjectType>_Extension - The keyword ‘final’ must be used in the class definition line.
- The class needs to have the attribute
[ExtensionOf(classStr(<NameOfBaseObject>))]
The “classStr” text above will change depending on the type of base objecting you are extending. I will explain more later. - Add the method definition the exact same way it appears in the base class.
- Your code must call the base class’s method inside your extension method using the ‘next’ keyword. Using the above example you need to have this line.
var s = next doSomething(arg);
Using The Right Global Function
All of the rules above apply for all uses of Chain Of Command. However, the function you use within the ‘ExtensionOf’ method above will be different based on the type of object you are extending.
While you could enter a string inside the ExtensionOf function, this would not be following best practice. The reason why we want to use a global function is because if the name of the base object ever changes name, using a global functional will cause a compile error to return. This will inform the developer that they need to make a change. Whereas if you use a string directly, you will not get a compile error, and your Chain of Command class will no longer work.
Let’s go through each type of global function we can use inside of the ExtensionOf function.
- When extending a class, use classStr(<NameofBaseClass>)
- When extending a table, use tableStr(<NameOfBaseTable>)
- In the case of a form, use formStr(<NameOfBaseForm>)
- When extending a form Datasource use formDataSourceStr(<NameOfBaseForm>,<NameOfDataSource>)
- When extending a form Data field, use formDataFieldStr(<NameOfBaseForm>,<NameOfDataSource>,<NameOfField>)
- For a form control, use formControlStr(<NameOfBaseForm>,<NameOfControl>)
- When extending a data entity, use tableStr(<NameOfBaseDataEntity>)
Extend Form DataSource methods
Do you have a button or field that you need to hide or show based on the which record in a grid is selected? The ‘active’ method of a Datasource is the best place to put this code. If this method is on a base form, you need to use Chain of Command to add this functionality to the method.
[ExtensionOf(formDataSourceStr(SalesTable, SalesLine))]
final class rsmSalesTable_SalesLine_Extension
{
public int active()
{
int ret;
ret = next active();
SalesLine salesLineLocal = this.cursor();
//Based on the currently selected record,
//enable/disable or show/hide your button or control here.
return ret;
}
}Conclusion
Anytime you have code in a base Microsoft form DataSource, you can use Chain Of Command to add additional code before or after the call to the base method. You still always have to call the base method. But you can change how the method works.
- When you put code before calling the base method, you can change the values that are sent in as parameters to the base method. This can cause different branches inside the base method to be run or not run.
- After receiving the response value from the base method you can change this value before returning it to the calling method. This can allow you to change what code paths the calling method takes.
- By adding code after the call to the base method, you can add additional validation, functionality, and actions that should occur anytime the method is called.
