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 data entity 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>_Extenson
  • 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 Data Entity methods

If you need this code on a base Microsoft form, you need to use Chain Of Command to add this functionality to the method. Do you have a button on a form and you want to run additional code when it is clicked? Below is an example of how you would do this using Chain of Command.

[ExtensionOf(tableStr(SalesOrderLineVEntity))]
final class SalesOrderLineV2Entity_Extension
{
    public boolean validateWrite()
    {
        boolean ret = next validateWrite();

        if (this.DeliveryAddressCountryRegionID != "US")
        {
            ret = checkFailed("Sales order cannot be created with a country other than US.");
        }
        return ret;
    }

}

Conclusion

Anytime you have code in a base Microsoft Data Entity, 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.