Chain of Command VS Event Handlers

 

Differences & Advantages

Chain of Command (COC):

Chain of Command is an extension framework in D365FO that allows developers to customize and extend standard application logic without modifying the original code. It enables you to add new business logic, validations, and modifications to existing methods in base classes. COC works by creating an extension class for the base class you want to modify and then overriding or adding methods within this extension class. COC supports before, after, and around method events.

Advantages of COC:

• Non-intrusive: Original code remains untouched.
• Supports method extensions.
• Facilitates the coexistence of multiple extensions.

Example

class BusinessLogic1 { str doSomething(int arg) { // ... } }

[ExtensionOf(classStr(BusinessLogic1))] final class BusinessLogic1_Extension { str doSomething(int arg) { // Part 1 var s = next doSomething(arg + 4); // Part 2 return s; } }

BusinessLogic1 object = new BusinessLogic1(); info(object.doSomething(33));

Event Handler:

Event handlers are programming constructs that allow you to subscribe to specific events that occur during the execution of application logic. They provide a way to respond to actions or state changes in the system. In D365FO, event handlers are often used to react to events such as record creation, modification, deletion, or specific actions taken by users. Event handlers are decoupled from the base code and are defined in a separate class.

Advantages of Event Handlers:

• Decoupled: Separates customization from core logic.
• Supports centralized event management.
• Allows multiple subscribers to the same event.

In summary, COC and event handlers are both mechanisms to customize and extend Dynamics 365 Finance and Operations without directly modifying the original code. COC focuses on extending methods in base classes, while event handlers focus on reacting to events during application execution. The choice between COC and event handlers depends on the nature of customization required and the specific use case.

Example

class PointWithEvent { // Instance fields. real x; real y; // Constructor to initialize fields x and y. void new(real _x, real _y) { x = _x; y = _y; } void move(real x_offset, real y_offset) { x += x_offset; y += y_offset; this.moved(abs(x_offset) + abs(y_offset)); } delegate void moved(real distance) { } } class PointKeeper { public void createAndMove() { PointWithEvent point = new PointWithEvent(1.0, 2.0); point.moved += eventhandler(this.writeMove); point.move(4.0, 5.0); // Output is "9.0". } public void writeMove(real distance) { info(any2Str(distance)); } }

[PreHandlerFor(classStr(MyClass2), methodstr(MyClass2, publisher))] public static void PreHandler(XppPrePostArgs arguments) { int arg = arguments.getArg("i"); } [PostHandlerFor(classStr(MyClass2), methodstr(MyClass2, publisher))] public static void PostHandler(XppPrePostArgs arguments) { int arg = arguments.getArg("i"); int retvalFromMethod = arguments.getReturnValue(); } public int Publisher(int i) { return 1; }

Support Faryal's Cusine