Unlocking the Power of Ternary Operators and Extendable Interfaces in Business Central

Developers are continually looking for ways to write cleaner, more efficient code. Two powerful tools that have emerged to meet this need are the ternary operator and extendable interfaces. This blog explores how these features can enhance your AL code, making it more readable and maintainable.

Ternary Operator in Business Central

The ternary operator, introduced in the 2024 release wave 2 of Business Central, is a concise way to perform conditional assignments. It offers a streamlined alternative to traditional if-else statements, promoting code clarity and reducing verbosity.

Syntax and Example

The ternary operator in AL has the following syntax:

condition ? exprIfTrue : exprIfFalse

Here’s an example that demonstrates its usage:

pageextension 50300 CustomerListExtension extends “Customer List” {
layout {
     addlast(Content) {
         field(“Customer Status”; IsCustomerActive) {
             ApplicationArea = All;
         }
     }
}

var
     IsCustomerActive: Text;

trigger OnAfterGetCurrRecord();
begin
     IsCustomerActive := Rec.Blocked = Rec.Blocked::” ” ? ‘Active’ : ‘Inactive’;
end;
}

In this example, the ternary operator is used to determine whether a customer is active or inactive based on their Blocked status. The result is a concise and more readable conditional assignment.

Extendable Interfaces in Business Central

Extendable interfaces provide a modular and flexible way to define reusable logic across different components in Business Central. They allow developers to create scalable systems that can easily adapt to changing business requirements.

Defining and Implementing Extendable Interfaces

Base Interface:

interface INotificationProvider {
procedure SendNotification(Message: Text): Text;
}

Extended Interface:

interface INotificationProviderExt extends INotificationProvider {
procedure SendEmailNotification(Message: Text): Text;
procedure SendSMSNotification(Message: Text): Text;
}

Implementing the Interfaces in Codeunits:

Email Notification Provider:
codeunit 50301 EmailNotificationProvider implements INotificationProvider {
procedure SendNotification(Message: Text): Text;
begin
     exit(‘Email sent with message: ‘ + Message);
end;
}

SMS Notification Provider:
codeunit 50302 SMSNotificationProvider implements INotificationProvider {
procedure SendNotification(Message: Text): Text;
begin
     exit(‘SMS sent with message: ‘ + Message);
end;
}

Advanced Notification Provider:
codeunit 50303 AdvancedNotificationProvider implements INotificationProviderExt {
procedure SendNotification(Message: Text): Text;
begin
     exit(‘Notification sent with message: ‘ + Message);
end;

procedure SendEmailNotification(Message: Text): Text;
begin
     exit(‘Email sent with message: ‘ + Message);
end;

procedure SendSMSNotification(Message: Text): Text;
begin
     exit(‘SMS sent with message: ‘ + Message);
end;
}

Real-World Application

Let’s implement these interfaces in a page extension to add actions for sending notifications to customers.

pageextension 50300 CustomerListExt extends “Customer List” {
actions {
     addafter(ApplyTemplate) {
         action(SendEmail) {
             ApplicationArea = All;
             Image = Email;
             Caption = ‘Send Email’;
             Promoted = true;
             PromotedCategory = Process;
             trigger OnAction()
             begin
                 iNotificationProvider := EmailNotificationProvider;
                 Message(iNotificationProvider.SendNotification(‘Email message to customer’));
             end;
         }

action(SendSMS) {
             Image = Phone;
             Caption = ‘Send SMS’;
             ApplicationArea = All;
             Promoted = true;
             PromotedCategory = Process;
             trigger OnAction()
             begin
                 iNotificationProvider := SMSNotificationProvider;
                 Message(iNotificationProvider.SendNotification(‘SMS message to customer’));
             end;
         }

action(SendAdvancedNotification) {
             Image = Notification;
             Caption = ‘Send Advanced Notification’;
             ApplicationArea = All;
             Promoted = true;
             PromotedCategory = Process;
             trigger OnAction()
             begin
                    iNotificationProviderExt := AdvancedNotificationProvider;
                    Message(iNotificationProviderExt.SendEmailNotification(‘Advanced Email message to customer’));
                    Message(iNotificationProviderExt.SendSMSNotification(‘Advanced SMS message to customer’));
             end;
         }
     }
}

var
     iNotificationProvider: Interface INotificationProvider;
     iNotificationProviderExt: Interface INotificationProviderExt;
     EmailNotificationProvider: Codeunit EmailNotificationProvider;
     SMSNotificationProvider: Codeunit SMSNotificationProvider;
     AdvancedNotificationProvider: Codeunit AdvancedNotificationProvider;
}

This example demonstrates how to use extendable interfaces to create a flexible and maintainable notification provider system in Business Central, allowing for different types of notifications to be added seamlessly.

Conclusion

The ternary operator and extendable interfaces in Business Central are powerful tools that can significantly enhance your AL code. By using the ternary operator, you can streamline conditional logic and improve code readability. Extendable interfaces, on the other hand, allow for modular, scalable solutions that can adapt to changing business needs.

Embrace these features to build more efficient, maintainable, and future-proof solutions in Business Central.