Working with Classes and Methods in X++

Working with Classes and Methods in X++: A Comprehensive Guide

X++ is the programming language used in Microsoft Dynamics 365 Finance and Operations (D365FO) for customizations, automation, and business logic implementations. Understanding how to work with classes and methods in X++ is essential for creating scalable, modular, and maintainable code. This article will guide you through the basics of working with classes and methods in X++.

1. Introduction to Classes in X++

A class in X++ is a blueprint for creating objects that contain both data (properties) and methods (functions) to perform specific operations. Classes are defined using the class keyword and can include fields, methods, and constructors.

Syntax for Defining a Class:

class MyClass
{
// Fields (variables)
int myField;

// Constructor
public void new()
{
myField = 10; // Initializing the field
}

// Method (function)
public void displayFieldValue()
{
info(strFmt('The value of myField is: %1', myField));
}
}

In the example above:

• myField is a class field.
• The new method is the constructor, which initializes myField when an object is created.
• The displayFieldValue method displays the value of myField in the infolog.

2. Creating an Instance of a Class

Once a class is defined, you can create an object (instance) of that class using the new keyword. For example:

static void createClassInstance(Args _args)
{
MyClass myObject; // Declare an object of the class
myObject = new MyClass(); // Create an instance of MyClass

myObject.displayFieldValue(); // Call the method of the class
}

In this example:

• The new MyClass() statement creates a new instance of the MyClass class.
• The method displayFieldValue is called on the myObject instance to display the field’s value.

3. Working with Methods in X++

A method in X++ is a function that performs a specific action, such as modifying data, calling external systems, or processing information. Methods can be public or private. Public methods can be accessed from other classes, while private methods are only accessible within the same class.

Method Types:

• Public Methods: Accessible from outside the class.
• Private Methods: Accessible only from within the class.
• Static Methods: Do not require an instance of the class to be invoked.

Syntax for Defining Methods:

class MyClass
{
// Public method
public void myPublicMethod()
{
info("This is a public method.");
}

// Private method
private void myPrivateMethod()
{
info("This is a private method.");
}

// Static method
public static void myStaticMethod()
{
info("This is a static method.");
}
}

4. Accessing Methods

Methods are accessed using an object instance for non-static methods and directly from the class for static methods.

Accessing Non-Static Methods:

static void accessMethods(Args _args)
{
MyClass myObject = new MyClass(); // Create an object of MyClass

myObject.myPublicMethod(); // Accessing the public method
myObject.myPrivateMethod(); // This will throw an error as it's private
}

In this example:

• myPublicMethod is called on the myObject instance, and it will execute successfully.
• Attempting to call myPrivateMethod will result in an error, as it’s marked as private

Accessing Static Methods:

static void accessStaticMethod(Args _args)
{
MyClass::myStaticMethod(); // Accessing the static method without an object
}

Static methods can be invoked directly through the class name, without the need to create an object instance.

5. Constructors in X++

A constructor is a special method that is called when an object of the class is created. In X++, the constructor is defined by the new() method.

class MyClass
{
int fieldValue;

// Constructor
public void new(int value)
{
fieldValue = value; // Initializing field with passed value
}

public void displayValue()
{
info(strFmt('The value is: %1', fieldValue));
}
}

static void testConstructor(Args _args)
{
MyClass myObject = new MyClass(20); // Passing value to constructor
myObject.displayValue(); // Output: The value is: 20
}

class BaseClass
{
public void baseMethod()
{
info("This is a method from the base class.");
}
}

class DerivedClass extends BaseClass
{
public void derivedMethod()
{
info("This is a method from the derived class.");
}
}