As we already know, codeunits, as well as other application objects, are created in the Object Designer. The first time you save a new object, you will be requested to assign an ID number and a name to it and compile the object. But the Compiled option prevents saving the object if its code has syntax errors. Let's see how we can handle the commonplace situation of saving an object before fixing bugs.

If the code of an object contains a syntax error, an attempt to compile this object will fail, and the compilation will stop on the first encountered error. Let's modify the Hello World example from the previous chapter and see how the Object Designer...

When you open a NAV application object in the designer and review its code, function names are probably among the first things you notice. Code is structured in blocks with function headers clearly highlighted in bold font. But if you try to change a function's declaration—for example, change its name or add a parameter—you will see that the line with the function declaration is not editable.

Function names, return types, and parameter lists are accessed through a separate editor, and cannot be modified in the main code editor window.

In the next example, we will create a simple function to illustrate the process of declaring C/AL functions. This is a slightly modified version of the previous Hello World example. Now, we will not show the message in the standard codeunit trigger, but delegate the greeting to a local function instead...

In the previous example, we simply call a function that displays a hardcoded message. But if we want to make the function more flexible and able to show different text, we must pass a text parameter into the function. Function parameters in NAV are declared in the same way as functions themselves. A line of code representing the function declaration in the code editor is not editable. Parameters are described in a separate editor window instead. In this section, we will see how to pass parameters to a function and return a resulting value from it.

Let's modify the codeunit so that the message to be shown to the user will be passed in the function...

As we saw in the previous topic in this chapter, functions and function parameters in C/SIDE are not declared directly in the code editor. Instead, they are entered in a tabular view presented in a separate editor. This is also true for variables; we do not describe variables in C/AL code, but access the variable declaration through the C/AL Locals and C/AL Globals windows.

To illustrate the declaration and use of local variables, we will implement a simple algorithm comparing two strings to find the editorial distance, or Levenshtein distance. This distance is a measure of similarity between strings that is often used in various text processing systems to suggest...

To simplify the example, we will skip the sorting of the input array, but instead generate a random array whose elements are already sorted in ascending order. The GenerateRandomSortedArray function will do this: it simply fills an array with random values, each value greater than the previous one. A generated array is the result that must be returned from the function. But the function return value can only be a scalar; it is not possible to return an array directly as a function value. A ByVar parameter can help us to work around this problem. If we pass an array variable to GenerateRandomSortedArray by reference, any changes made inside the function will be visible to the calling code. Let's see how this works.

Inside the function, declare an InputArray parameter of type Integer and set the checkmark in the Var field. To complete...

Record is one of the most important and widely used data types in C/AL code. A Record variable refers to a database table, and allows us to retrieve and manipulate table data. A code example in this section will demonstrate how to search data with a Record variable and update found records. This is a more business-related scenario than those we coded in previous sections. As an example, we will update sales prices for an item based on certain criteria calculated from other database tables.

To declare a Record variable, you must enter its name, select the Record data type in the DataType field, and choose one of the database tables as the variable's Subtype. In the next code...

In all code examples in this chapter, we created codeunits that contained functions used locally by codeunits themselves. But a codeunit is a code library that could contain common functionality available to other objects. The following section will show how to invoke functions from code libraries in C/AL:

LOCAL ExportPriceList(FileName : Text)
    XMLDoc := XMLDoc.XmlDocument;
    XMLDOMManagement.AddRootElement(XMLDoc,'PriceList',RootNode);
    IF Item.FINDSET THEN
        REPEAT
            XMLDOMManagement.AddElement(RootNode,'Item',Item."No.",'',ItemNode);
            XMLDOMManagement.AddAttribute(ItemNode,'Description',Item.Description);
            XMLDOMManagement.AddAttribute(ItemNode,'Price',FORMAT(Item."Unit Price"));
        UNTIL Item.NEXT...

Text constants in C/AL are declared the same way as variables: through the C/AL Locals or C/AL Globals editors. In most cases, constants are declared as globals. It is good practice to avoid global variables when a local one is sufficient, but this is not the case with constants. A global variable often causes specific bugs; since it is available in any part of the code, and any function can change its value, it becomes very difficult to track the value of the variable while the volume of the code grows. This is not a problem with constants, because once assigned, the value of a constant cannot be changed.

With this in mind, in all code samples where text constants are involved, we will declare them as globals. A typical application of text constants is UI messages: process information or error notifications. And having a constant in the global scope is handy when...

The second chapter gave a more detailed overview of a topic started in Chapter 1, Getting Started with the NAV Development Environment. We learned to create codeunits, structure C/AL code into functions, pass parameters to functions, and use return values. The first examples illustrating C/SIDE capabilities were of a somewhat abstract nature, but closer to the end of the chapter, we learned how to use the database and discussed a more business-related scenario.

In the following chapter, readers will not only learn to use Record variables, but will complete a walk-through example of creating a custom table and writing table triggers.