Classes, Events, and Extensions

Classes in D365 F&O

Creating a class

In Visual Studio: right-click your project → Add New Item → Code → Class.

Class structure

/// <summary>
/// Handles inspection validation logic for Axion Dynamics.
/// </summary>
class AxionInspectionValidator
{
    // Member variables (state)
    AxionInspectionTable inspection;
    boolean isValid;

    // Constructor — protected so callers use construct() or newFrom()
    protected void new()
    {
    }

    // Static construct method — standard factory pattern
    public static AxionInspectionValidator construct()
    {
        return new AxionInspectionValidator();
    }

    // Initialise from an inspection record
    public AxionInspectionValidator initFromInspection(AxionInspectionTable _inspection)
    {
        inspection = _inspection;
        return this;   // fluent pattern — allows method chaining
    }

    // Business logic method
    public boolean validate()
    {
        isValid = true;

        if (!inspection.InspectionId)
        {
            isValid = checkFailed("@AxionLabels:InspectionIdRequired");
        }

        if (inspection.InspectionDate > today())
        {
            isValid = checkFailed("@AxionLabels:FutureDateNotAllowed");
        }

        if (!HcmWorker::exist(inspection.InspectorWorker))
        {
            isValid = checkFailed("@AxionLabels:InspectorNotFound");
        }

        return isValid;
    }
}

Calling the class

// Usage pattern
AxionInspectionValidator validator = AxionInspectionValidator::construct()
    .initFromInspection(inspectionRecord);

if (validator.validate())
{
    // proceed with posting
}

💡 Exam tip: construct() vs new()

The standard pattern in D365 F&O is:

• new() — protected, never called directly from outside the class
• construct() — public static, the factory method callers use

Why? This pattern allows Microsoft (or you) to introduce subclasses later without breaking callers. The construct method can return a subclass based on parameters.

The exam may ask: “A developer calls new AxionInspectionValidator() directly. What is wrong?” Answer: the new() method is protected — use the static construct() method instead.

Access modifiers

Modifier	Visibility	Use Case
public	Accessible from anywhere	API methods, static helpers
protected	Accessible from this class and subclasses	Internal state management, overridable logic
private	Accessible from this class only	Implementation details, helper methods
internal	Accessible from the same model only	Cross-class helpers within your model, not exposed to other models

Question

What does the 'internal' access modifier do in D365 F&O X++?

Click or press Enter to reveal answer

Answer

Internal restricts visibility to the same model. Other models cannot see or call internal methods. Use it for helper classes and methods that should be available across your model but not exposed as a public API to other ISV solutions or Microsoft updates.

Click to flip back

Extending standard classes

Since Microsoft’s classes are sealed (no inheritance), you use two patterns to add or modify behaviour:

Pattern 1: Class extensions (augmentation)

A class extension adds new methods to an existing class without modifying the original:

// Adds a new method to InventTable (Microsoft's class)
[ExtensionOf(tableStr(InventTable))]
final class AxionInventTable_Extension
{
    // New method — callable as inventTable.axionGetInspectionRequired()
    public boolean axionGetInspectionRequired()
    {
        // Access the current record via 'this'
        return this.AxionInspectionRequired == NoYes::Yes;
    }
}

Pattern 2: Event handlers (subscribe to events)

Event handlers run before, after, or around a standard method:

// Subscribes to the validateWrite event on CustTable
class AxionCustTable_EventHandler
{
    // Runs after CustTable.validateWrite() — adds extra validation
    [DataEventHandler(tableStr(CustTable), DataEventType::ValidatingWrite)]
    public static void CustTable_onValidatingWrite(
        Common _sender,
        DataEventArgs _eventArgs)
    {
        ValidateEventArgs validateArgs = _eventArgs as ValidateEventArgs;
        CustTable custTable = _sender as CustTable;

        if (!custTable.AxionPreferredInspectorWorker)
        {
            validateArgs.parmValidateResult(false);
            checkFailed("@AxionLabels:InspectorRequired");
        }
    }
}

Class extension vs event handler

Extensions add new methods; event handlers modify existing behaviour

Feature	Class Extension	Event Handler
What it does	Adds NEW methods to an existing class/table	Subscribes to EXISTING events on a class/table
Can modify existing logic?	No — only adds new methods	Yes — can run before/after existing methods and modify results
Access to private members?	No — only public/protected members	No — receives event args and sender object
Syntax	[ExtensionOf(classStr(...))] final class	[PostHandlerFor(...)] or [DataEventHandler(...)] static void
Use case	Adding helper methods, computed values	Validation, logging, notifications, modifying standard behaviour
Naming convention	AxionClassName_Extension	AxionClassName_EventHandler

Question

What is the key difference between a class extension and an event handler in D365 F&O?

Click or press Enter to reveal answer

Answer

A class extension adds NEW methods to an existing class — it cannot modify existing methods. An event handler subscribes to events on existing methods (pre/post) and can modify their behaviour — validate results, add logging, change parameters. Use extensions for new functionality, event handlers for modifying existing behaviour.

Click to flip back

Event types

Pre and post event handlers on methods

class AxionSalesConfirm_EventHandler
{
    // Runs BEFORE SalesConfirmJournalPost.validate()
    [PreHandlerFor(classStr(SalesConfirmJournalPost), methodStr(SalesConfirmJournalPost, validate))]
    public static void preValidate(XppPrePostArgs _args)
    {
        // Access the instance that called validate()
        SalesConfirmJournalPost instance = _args.getThis() as SalesConfirmJournalPost;

        info("Pre-validation: checking Axion quality requirements...");
    }

    // Runs AFTER SalesConfirmJournalPost.validate()
    [PostHandlerFor(classStr(SalesConfirmJournalPost), methodStr(SalesConfirmJournalPost, validate))]
    public static void postValidate(XppPrePostArgs _args)
    {
        boolean originalResult = _args.getReturnValue();

        if (originalResult)
        {
            // Additional validation — can override the return value
            // _args.setReturnValue(false); // to fail validation
        }
    }
}

Data events on tables

Event	When It Fires
onInserting / onInserted	Before / after a record is inserted
onUpdating / onUpdated	Before / after a record is updated
onDeleting / onDeleted	Before / after a record is deleted
onValidatingWrite	During validateWrite() — can accept or reject
onValidatingDelete	During validateDelete() — can accept or reject
onInitializedRecord	When a new record buffer is initialised (default values)
onModifiedField	When a field value changes on the form

💡 Scenario: Vik adds quality checks to sales confirmation

Axion needs a quality gate before sales order confirmation: if the order contains items flagged for inspection, confirmation should be blocked until inspection passes.

Vik cannot modify SalesConfirmJournalPost directly — it’s Microsoft’s class. Instead, he creates a PostHandlerFor on the validate() method. His handler checks whether any order lines reference inspection-required items. If an item hasn’t passed inspection, he overrides the return value to false and shows an error.

Zero changes to Microsoft’s code. When Microsoft updates the SalesConfirmJournalPost class, Vik’s handler continues to work because it subscribes to the event, not the implementation.

Key attributes

Attributes are metadata annotations that tell the runtime how to treat a class or method.

SysEntryPointAttribute

Required on every service method exposed to external callers (AIF, OData custom actions):

[SysEntryPointAttribute(true)]  // true = authorisation check enforced
public AxionInspectionResult performInspection(AxionInspectionId _inspectionId)
{
    // This method can be called from outside via service endpoint
    // The attribute tells the security framework to check the caller's privileges
}

DataMemberAttribute

Marks properties on a data contract class for serialisation (used in service contracts, batch jobs, SysOperation framework):

[DataContractAttribute]
class AxionInspectionContract
{
    AxionInspectionId inspectionId;
    TransDate fromDate;
    TransDate toDate;

    [DataMemberAttribute('InspectionId')]
    public AxionInspectionId parmInspectionId(
        AxionInspectionId _inspectionId = inspectionId)
    {
        inspectionId = _inspectionId;
        return inspectionId;
    }

    [DataMemberAttribute('FromDate')]
    public TransDate parmFromDate(TransDate _fromDate = fromDate)
    {
        fromDate = _fromDate;
        return fromDate;
    }

    [DataMemberAttribute('ToDate')]
    public TransDate parmToDate(TransDate _toDate = toDate)
    {
        toDate = _toDate;
        return toDate;
    }
}

Other important attributes

Attribute	Purpose
SysOperationContractProcessingAttribute	Links a service operation to its UI builder
SysEntryPointAttribute	Security entry point for service methods
DataContractAttribute	Marks a class as a serialisable data contract
DataMemberAttribute	Marks a property for serialisation
ExtensionOf	Declares a class extension (augmentation)
PreHandlerFor / PostHandlerFor	Subscribes to pre/post events on methods
ExportAttribute	Marks a class for dependency injection

Question

What happens if you expose a service method without the SysEntryPointAttribute?

Click or press Enter to reveal answer

Answer

The security framework cannot enforce authorisation checks on the method. At runtime, calls to the method may fail with a security error because the framework doesn't know this is a valid entry point. Always add [SysEntryPointAttribute(true)] to service methods.

Click to flip back

Question

What is a data contract class and when do you use one?

Click or press Enter to reveal answer

Answer

A data contract class is marked with [DataContractAttribute] and has properties decorated with [DataMemberAttribute]. It's used for serialisation — passing structured data to service operations, batch jobs (SysOperation framework), and external integrations. The parm* naming convention (parmFromDate, parmToDate) is standard.

Click to flip back

The parm* naming convention

D365 F&O uses a distinctive pattern for getter/setter methods:

// The parm method acts as both getter and setter
[DataMemberAttribute('InspectionId')]
public AxionInspectionId parmInspectionId(
    AxionInspectionId _inspectionId = inspectionId)
{
    inspectionId = _inspectionId;
    return inspectionId;
}

// Calling as getter:
AxionInspectionId id = contract.parmInspectionId();

// Calling as setter:
contract.parmInspectionId('INS-001');

The default parameter (= inspectionId) makes this work: when called without arguments, it returns the current value. When called with an argument, it sets and returns the new value.

💡 Exam tip: parm methods and data contracts

The exam frequently tests the parm pattern:

• Naming: parm + PropertyName (e.g., parmFromDate)
• Default parameter: Must default to the member variable
• DataMemberAttribute: Required for serialisation
• Return type: Must match the member variable type

If a question shows a data contract with [DataMemberAttribute] on a method that doesn’t follow the parm pattern, that’s likely the error they’re testing.

Extension vs overlayering: the fundamental rule

D365 F&O enforces extension-based development — overlayering is not supported

Approach	Overlayering (BANNED)	Extension (REQUIRED)
How it works	Directly modifying Microsoft's source code	Adding new elements or subscribing to events in a separate model
Allowed in D365 F&O?	No — blocked for most models since Platform Update 9+	Yes — the only supported customisation approach
Upgrade impact	Every Microsoft update could break your changes	Extensions survive updates — they're separate from the base code
Techniques	Copy and edit standard class/method	Class extension, event handler, table extension, form extension
Code conflicts	Yes — merge conflicts on every update	No — your code is in a separate model

💡 Scenario: Sophie migrates from AX 2012 overlayering

Sophie’s company Ferris Industries is migrating from AX 2012 where they overlayered dozens of standard classes. Mentor Carl explains the migration path:

“In AX 2012, we copied SalesFormLetter and added 50 lines of custom code. In D365, we can’t touch that class. Instead, we:

1. Create a class extension for any new methods we need
2. Create event handlers for the existing methods we modified
3. Move our custom logic into these extension points

The result? When Microsoft updates SalesFormLetter, our code continues to work because it’s in a separate layer.”

Putting it together: when to use what

Need	Approach
Add a new helper method to CustTable	Class extension with [ExtensionOf(tableStr(CustTable))]
Run extra validation before a standard post	[PreHandlerFor] event handler on the post method
Log every time an invoice is created	[PostHandlerFor] on the insert event or onInserted data event
Expose a new service endpoint	New class with [SysEntryPointAttribute] on the service method
Pass parameters to a batch job	Data contract class with [DataContractAttribute] and [DataMemberAttribute]
Create business logic for a new module	New class with construct() pattern, organised by responsibility

Knowledge Check

Vik needs to add custom validation that runs whenever a CustTable record is saved. He cannot modify the standard CustTable class. Which approach should he use?

ACreate a subclass of CustTable and override validateWrite()BCreate a class extension with [ExtensionOf(tableStr(CustTable))] and add a new validateWrite() methodCCreate an event handler class and subscribe to the onValidatingWrite data eventDModify the CustTable source code directly — it's the only way to add validation

Check Answer

Knowledge Check

A developer creates a data contract class for a batch job. The class has [DataContractAttribute] on the class and three parm methods for FromDate, ToDate, and CustomerId. But when the batch dialog opens, the CustomerId field doesn't appear. What is the most likely cause?

AThe CustomerId parm method is missing the [DataMemberAttribute]BThe class is missing the [SysEntryPointAttribute]CThe CustomerId field needs to be added to a form extensionDThe batch job needs to be recompiled in CIL

Check Answer

Knowledge Check

Elena needs to add a method to the standard InventTable that calculates a custom inspection score. She creates: [ExtensionOf(tableStr(InventTable))] final class AxionInventTable_Extension. The method compiles but when she calls inventTable.axionCalculateScore(), she gets a compile error 'method not found'. What went wrong?

AExtension methods must be declared as staticBThe method name must start with 'parm' to be recognisedCShe forgot to add the extension class to her project's build orderDThe extension class must be in the same model as InventTable

Check Answer

Knowledge Check

Which attribute must be applied to a service method that will be called externally via an OData custom action?

A[DataContractAttribute]B[DataMemberAttribute]C[SysEntryPointAttribute(true)]D[ExtensionOf(classStr(...))]

Check Answer

---

Next up: X++ Data Manipulation — dive into X++ coding patterns for selecting, inserting, updating, and deleting data (Domain 4 begins).