MB-820 Microsoft Dynamics 365 Business Central Developer Questions and Answers

 Upgrade codeunit trigger: OnValidateUpgradePerDatabase

Since the question specifies that you are handling data upgrades, and you need to use validation before upgrading at the database level, the correct choice is OnValidateUpgradePerDatabase. This method ensures that the upgrade process is validated before applying to the entire database, making it more efficient when data affects multiple companies or structures.

 DataTransfer method to use: CopyRows

CopyRows is the appropriate method when you are handling large data transfers between tables, especially in an upgrade scenario where you are migrating or transferring data from one table to another. It copies entire rows of data and is optimal for bulk data operations during upgrades.

In Business Central development using AL (the language for Business Central extensions), the use of access modifiers defines how variables and procedures are accessed within and outside of an object or codeunit.

Access Modifiers in AL:

Public: A public variable can be accessed from any object or codeunit within the same module or extension.

Protected: This restricts access to the current object and objects that inherit from the current object. However, in AL (at least in versions used for Business Central), the Protected access modifier is used with methods but not variables.

Internal: This modifier restricts the visibility to the current extension. This means that variables or methods declared as internal can only be accessed from within the same extension. This is appropriate when you want to provide functionality that is shared within the extension but not exposed externally.

Local: This restricts the variable or method to the current object or method where it is declared. It cannot be accessed from anywhere else, even within the same extension.

Scenario Justification:

In the scenario for Contoso, Ltd., IssueTotal is a global variable in the ISSUE BASE extension, and the ISSUE EXT extension needs to access it. Therefore, the variable cannot be declared as Local, because this would restrict access to just the current object (or method).

Using Public would expose the variable outside of the extension, which is unnecessary because you only want other parts of the extension (specifically the ISSUE EXT extension) to have access.

The best choice in this case is Internal because it restricts access to the variable to within the same extension, which includes the base extension and any dependent extensions like ISSUE EXT. It strikes the right balance between visibility and encapsulation.

Microsoft Dynamics 365 Business Central Developer References:

Access Modifiers in AL: Microsoft's documentation on AL provides the details on access modifiers, where it is specified that internal variables can be accessed within the extension, and the public variable is accessible across all extensions【source: Microsoft Learn on AL Programming】.

Best Practices for AL Development: Business Central development best practices suggest keeping variables internal unless they need to be accessed outside of the current extension【source: Microsoft Learn on AL development guidelines】.

Code Segment Analysis:

The AL code is trying to read JSON data from a response and process it to extract subcontracting order numbers. It uses JsonToken, JsonObject, and JsonArray to work with the JSON data.

JToken.ReadFrom(Data): This line reads the incoming JSON data and converts it into a token. It processes the full JSON body so you can start working with it.

JToken.SelectToken("results"): This line selects the part of the JSON containing the results array. The key "results" is where the JSON response data is expected to be found.

JsonArray: Once the results are extracted, they are stored as an array, and each element in the array (which is expected to contain subcontracting order numbers) is processed.

SubcontractingOrderNo: The extracted order_no from the JSON is stored in this variable.

Breakdown of Steps:

JToken.ReadFrom(Data): This step reads the entire JSON response.

JToken.SelectToken("results"): This step selects the results array from the JSON response.

JArray.AsArray(): This step converts the selected results token into a JSON array that can be iterated over.

GetValueAsText(JToken, 'order_no'): This step retrieves the order_no from each element in the array.

Correct Code Completion:

JToken.ReadFrom(Data): This is the correct method to read the incoming JSON response, as it will convert the string into a JsonToken that can be further processed.

JToken.SelectToken("results"): This is the correct method to extract the results array from the token. This method looks for the key "results" in the JSON and retrieves the relevant array.

Final Code Segment:

al

Copy code

procedure ReadJsonData(Data: text)

var

JToken: JsonToken;

JObject: JsonObject;

JArray: JsonArray;

SubcontractingOrderNo: Code[20];

begin

if Data = '' then

exit;

JToken := JToken.ReadFrom(Data); // Step 1: Read the JSON response data.

JToken := JToken.SelectToken('results'); // Step 2: Select the "results" array.

JArray := JToken.AsArray(); // Convert the token into a JSON array.

foreach JToken in JArray do begin

SubcontractingOrderNo := GetValueAsText(JToken, 'order_no'); // Retrieve the order number.

end;

end;

JToken.ReadFrom(Data): This reads the raw JSON data string and converts it into a JSON token that can be processed.

JToken.SelectToken("results"): This extracts the results array from the JSON data.

JArray.AsArray(): Converts the token into an array so we can iterate over it.

GetValueAsText(JToken, 'order_no'): Extracts the order_no value from each item in the array.

HeadLinePart

FactBox

NavigatePage

 Design pattern for the setup table:

The correct selection here is Adapter. The Adapter design pattern is commonly used when you need to handle integration points or create a setup table that acts as an intermediary for data manipulation, which fits the requirement for the configuration of the non-conformity functionality.

 Data type of the primary key field:

The correct data type is Code. In Business Central, when creating a table with a primary key field, the Code data type is typically used for fields such as document numbers, codes, and identifiers. For a setup table, a Code field is appropriate for keys like "No." series or setup identifiers.

 Property required to prevent users from adding records:

The correct property is InitValue. This property is used to set initial values for fields and can be configured in such a way that users are prevented from adding records directly, typically enforcing control over record creation and editing in configuration scenarios.

codeunit 52102 "POS API Management"

{

Access = Public;

Permissions = TableData "POS Information" = rwdx;

trigger OnRun()

begin

readAPI();

end;

procedure readAPI()

begin

// Your code here to read from the POS API

end;

}

LogMessage('PT001', 'Business Process is failed.', Verbosity::Critical, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustDimension);

var

TempBlob: Codeunit "Temp Blob";

IncidentOutStream: OutStream;

IncidentInStream: InStream;

ImageFilter, FileName: Text;

begin

// Initialize the TempBlob and streams

TempBlob.CreateOutStream(IncidentOutStream);

Rec.Image.ExportStream(IncidentOutStream); // 'Rec' refers to the current Room Incident record

TempBlob.CreateInStream(IncidentInStream);

// Set the filters and filename for the image

ImageFilter := 'Image Files (*.bmp,*.jpg,*.jpeg,*.gif)|*.bmp;*.jpg;*.jpeg;*.gif';

FileName := 'Customer Picture';

// Prompt the user to download the image

if not DownloadFromStream(IncidentInStream, '', 'Download Incident Picture', '', ImageFilter, FileName) then

Error('Unable to download the image.');

end;

For the Install codeunit required for the extension used for installing or updating the Housekeeping app, you should use the following data type and declaration:

Data type for information: ModuleInfo

Start of the declaration of the method or procedure to perform the tasks: local procedure

In AL language, which is used for developing extensions in Business Central, an Install codeunit is a special type of codeunit that is used to handle installation or upgrade logic for an extension.

ModuleInfo is a data type that contains information about the current extension, such as its version. It is typically used within the OnInstallAppPerCompany or OnUpgradePerCompany triggers of an Install codeunit to determine if the app is being installed for the first time or upgraded.

A local procedure within an Install codeunit is a method that is only accessible within the codeunit itself. It is not visible to other objects or extensions. This is suitable for tasks that are internal to the installation process and should not be exposed globally.

These selections align with the requirements of handling installation and update procedures in a controlled and encapsulated manner within Business Central extensions.

Read Scale-Out:

Read scale-out is a feature in Business Central that allows you to improve performance by distributing read-only queries (such as the ones from the ticketAPI) across multiple read replicas in the cloud database. This reduces the load on the primary database and helps improve the response time for read-intensive operations, like analyzing POS data through the ticketAPI.

Data Access Intent - ReadOnly:

When enabling read scale-out, you can configure the DataAccessIntent property of APIs to be ReadOnly. This directs the system to use read replicas to handle read-only queries, which enhances performance by offloading such queries from the primary database.

Why Not Other Options?

Option A (ODataReadonlyGetEnabled): This parameter is unrelated to read scale-out and primarily affects OData services behavior, not API performance tuning.

Option B (AccessByPermission): Setting the permission to Read does not directly affect the performance. It only controls access based on user permissions.

Option D (DataAccessIntent ReadOnly): While setting this property to ReadOnly helps in read-only operations, enabling read scale-out (option C) ensures the underlying infrastructure is optimized to handle such read operations, which is the fundamental action required.

Reference Documentation:

Read Scale-Out in Business Central

Data Access Intent in AL

Language table → System layer

Activities Cue table → Base layer

Extension Management codeunit → System layer

Business Unit Card page → Base layer

Application Layers in Business Central:

In Business Central, there are different layers such as Base and System, which represent different levels of the application architecture. Here's a breakdown of where each object is likely to belong based on typical Business Central architecture:

Language Table:This table typically belongs to the System layer, as language and localization features are often part of the foundational aspects of the system.

Activities Cue Table:This would likely be found in the Base layer because it involves business logic that supports user interface elements (like activity cues) specific to the Business Central application.

Extension Management Codeunit:The Extension Management Codeunit likely belongs to the System layer, as it deals with handling extensions, which is closely related to the core system functionality for managing and deploying changes.

Business Unit Card Page:This object would typically be part of the Base layer, as it is a business-specific object that handles the user interface for business unit data, part of the core Business Central application.

Here is the correct sequence of the four code segments:

if "No." = '' then begin

ContosoSetup.Get();

ContosoSetup.TestField("Vendor Nos.");

NoSeriesManagement.InitSeries(ContosoSetup."Vendor Nos.", xRec."No. Series", 0D, "No.", "No. Series"); end;

Check for empty value: The standard pattern for OnInsert is to only assign a number automatically if the user has not manually entered one. Therefore, you start with if "No." = '' then begin.

Retrieve Setup: You must retrieve the setup record to access the configured No. Series code. The singleton pattern for setup tables uses ContosoSetup.Get();.

Verify Configuration: Before attempting to use the series code, best practice dictates you ensure it is actually populated in the setup table. ContosoSetup.TestField("Vendor Nos."); checks this field.

Initialize Series: Finally, you call the InitSeries function.

Argument 1 (Source): ContosoSetup."Vendor Nos." is the field containing the Series Code (as stated in the prompt).

Argument 2 (Previous): xRec."No. Series" handles standard renaming/validation logic.

Argument 4 & 5 (Targets): "No." and "No. Series" are the fields on the current record being updated.

Note: The other available InitSeries block is incorrect because it tries to read a field named "No. Series" from the ContosoSetup table, which does not match the prompt's description.

https://learn.microsoft.com/en-us/dynamics365/business-central/dev-itpro/developer/attributes/devenv-handlerfunctions-attribute

For a task that is performed infrequently and requires users to follow a sequence of steps, a wizard-like interface is ideal. In Microsoft Dynamics 365 Business Central, the NavigatePage page type (A) is best suited for this purpose. NavigatePage is designed to guide users through a series of steps or pages, allowing them to complete a task by making choices or entering data in a structured manner. This page type is often used for setup wizards, data migration tasks, or any other process that benefits from a step-by-step approach. Unlike the other page types like Card (B), RoleCenter (C), or List (D), NavigatePage specifically supports the navigation and decision-making flow required for wizard creation, making it the optimal choice for this requirement.

https://learn.microsoft.com/en-us/dynamics365/business-central/dev-itpro/developer/devenv-pages-overview

The telemetry trace sends custom signals to an Application Insights resource specified in the extension's app.json file and on the tenant. = YES

Dictionary keys for the extension name and version must be specified to identify the extension during analysis. = YES

The telemetry trace sends events to Application Insights resources set up on the tenant. = YES

Telemetry in Business Central allows developers to collect custom telemetry for extensions using Application Insights. The telemetry trace is used to send custom signals to an Application Insights resource. This resource is typically specified in the app.json file of the extension and must be configured on the tenant where the extension is installed.

The use of dictionary keys for the extension name and version is a best practice to identify the extension during analysis in Application Insights. These keys can be added to the telemetry trace to ensure that when the data is collected, it's clear which extension the data is associated with.

Finally, it is correct that the telemetry trace sends events to Application Insights resources that are set up on the tenant, enabling the collection and analysis of telemetry at the tenant level.

A: In Business Central, wizard pages are created using the NavigatePage type because it allows step-by-step navigation, which is perfect for wizard-like user experiences.

B: The group control organizes the content for each step in the guide, and it’s essential to add these controls to the layout's Content area for each step of the wizard.

C: Worksheet is used for pages designed to handle larger datasets, not for wizard or step-by-step flows.

D: Repeater controls are used for displaying multiple records, not for guiding users through steps, so it’s incorrect for this scenario.

For more information, you can refer to Assisted Setup in Business Central.

Include all records from TableA Header even if no matching record value exists in the linked TableA Line: LeftOuterJoin

Include only matched records from TableB Header: InnerJoin

In SQL and similarly in Business Central when defining table relationships in query objects, the type of join determines how records from one table are combined with records from another table. Here's what each join type means in the context of the company's requirements:

LeftOuterJoin:

A LeftOuterJoin includes all records from the 'left' table (TableA Header) and the matched records from the 'right' table (TableA Line). If there is no match, the result is NULL on the side of the 'right' table. This is why it fits the requirement to include all records from TableA Header even if there is no matching record in TableA Line.

InnerJoin:

An InnerJoin includes records when there is at least one match in both tables. So, it will only include records from TableB Header where a corresponding match is found in TableB Line. If there is no match, the records from TableB Header will not appear in the result set. This aligns with the requirement to include only matched records from TableB Header.

By using these join types, the company can ensure that their dataset includes the appropriate records from the document tables and document history tables according to their specified requirements.