Free and Premium Microsoft MB-820 Dumps Questions Answers

The correct sequence of actions to configure telemetry for the SaaS tenant and test whether the ingested signals are displayed would be:

Create an Azure Application Insights instance by using the Azure Portal in the Customer's subscription.

Select the environment in the Admin Center and place the connection string in the Application Insights Connection String field.

Select the Application Insights instance, select Logs and then inspect the Traces table.

To set up telemetry for a SaaS tenant using Azure Application Insights, you need to follow these steps:

Create an Azure Application Insights instance: This is the first step where you create an instance in Azure that will collect the telemetry data. This should be done in the customer's Azure subscription because it's their data that you're monitoring.

Configure the SaaS tenant to use the created Application Insights instance: This involves entering the correct connection string in the Business Central Admin Center so that telemetry data from the tenant is sent to the Application Insights instance.

Verify that telemetry is being collected: After configuring, you would check if the telemetry is arriving as expected by inspecting the Traces table in the Azure Application Insights instance. The 'Traces' table holds the telemetry data, which you can query to verify that the correct signals are being ingested.

In the context provided by the case study, when calling an API action from a mobile application, the correct format for a POST request to an action in Business Central typically involves specifying the entity (/issues), the ID of the entity (88122e0e-5796-ec11-bb87-000d3a392eb5), and the action to be called (/Copy). The action name should match the exact name as defined in the AL code, which is case-sensitive.

Option A is incorrect because it uses a non-standard format for the action call.

Option B uses the PATCH method, which is generally used for update operations, not for calling actions.

Option C is correct as it uses the POST method, which is appropriate for calling actions, and correctly specifies the entity, ID, and action name.

Option D is incorrect because the action name /copy is in lowercase, while AL is case-sensitive, and it should match the case exactly as defined in the code.

Option E incorrectly adds 'MicrosoftNAV' before the action name, which is not standard for calling actions in Business Central APIs.

Hence, the correct action to use when calling the Issue API action from the mobile application is given in Option C.

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.

In Microsoft Dynamics 365 Business Central, when configuring snapshot debugging, it is crucial that the parameters in the configuration file are correctly set. From the options provided, the issue with the debugger not starting correctly is most likely due to an incorrect "userId" parameter.

Option A is the cause of the problem. The "userId" parameter must be the GUID of the user, not the username. The snapshot debugger needs the exact GUID to attach to the right session for debugging.

Option B is incorrect because "breakOnNext" set to "WebClient" is a valid setting. This tells the debugger to break on the next client action in the web client, which is a typical scenario.

Option C is not the cause of the problem. The "userId" parameter is meant to specify which user session to debug, and this works in conjunction with the "breakOnNext" parameter.

Option D is incorrect as the "executionContext" parameter does not need to be set to "Debug" for snapshot debugging to work. "DebugAndProfile" is a valid value for the "executionContext" parameter, as it allows for debugging and collecting performance information.

Therefore, the reason why the debugger does not start correctly is due to Option A: The "userId" parameter must have the GUID of the user specified, not the username.

 Verbosity::Critical: This ensures that the telemetry logs the failure as a critical event.

 DataClassification::CustomerContent: This helps classify the error as related to customer data.

 TelemetryScope::All: This ensures that the error is visible across all relevant telemetry scopes, making it easier to monitor the issue in real-time.

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】.

 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.

To correctly write the code to call the subcontractor's REST API, you would need to set the Authorization header with the base64 encoded username and password for basic authentication. The code segment indicates the use of the Base64Convert codeunit to convert the username and password to base64 format, which is then prefixed with "Basic " to form the proper Authorization header value.

The correct method to add the Authorization header to the RequestHeaders would be:

RequestHeaders.Add('Authorization', 'Basic ' + Base64Convert.ToBase64(Username + ':' + Password));

And the correct method to set the httpContent with the body of the request would be:

httpContent.WriteFrom(Body);

These are the necessary steps to form a well-structured HTTP request for basic authentication and to include the body of the request in the API call.

In the context of Microsoft Dynamics 365 Business Central, an extension may not appear in the tenant for several reasons, particularly after an upgrade to a new major version.

Option A suggests that the extension was published as a DEV extension, which typically would not cause it to disappear after an upgrade because DEV extensions are intended for development and testing within sandbox environments.

Option B indicates that the extension was not compatible with the new version within 60 days of the first notification. This is a likely reason because Microsoft enforces compatibility rules, and extensions that are not made compatible within the specified timeframe might be removed or disabled.

Option C refers to the extension being published as a PTE (Per-Tenant Extension) and mentions the Platform parameter not being updated. This could cause issues, but not specifically the disappearance of the extension after an upgrade.

Option D expands on Option C by adding that both the Platform and Runtime parameters were not updated in the application file. This is a critical aspect because if these parameters are not correctly set to indicate compatibility with the new version of Business Central, the extension could be disabled or removed.

Option E is similar to Option B but mentions a 90-day period. This option does not align with standard Business Central practices for version compatibility requirements.

Therefore, the two possible reasons for the disappearance of the extension in the tenant after an upgrade are that the extension was not compatible with the new version within the required timeframe (Option B) and that the extension was published as a PTE without the Platform and Runtime parameters being updated (Option D).

A. Codeunit

Codeunits can be extended in AL to add or modify functionality in Business Central.

B. Report

Reports can also be extended to customize the format or data presented in the reports without modifying the base report.

Incorrect Options:

C. Query: Queries cannot be extended. You would need to create new queries or modify the existing ones directly.

D. API page: You cannot extend API pages, but you can create new API pages.

E. Enum: You cannot extend Enums because they are predefined sets of values.

You are customizing Business Central using Visual Studio Code and JSON files for configuration.

You plan to:

Open page 21 after publishing.

Enable debugging.

Disable the capability to download the source code.

Which configurations should you add?

The options involve two primary JSON files: launch.json and app.json, and configuration tags like startupObjectId and resourceExposurePolicy.

This event occurs before posting a sales document.

PreviewMode is available in the parameters, which allows checking whether the process is being run in preview mode.

This event is typically used for sales order posting and can be used for both shipping and invoicing.

This event matches the requirements because:

You can check if PreviewMode is false.

It can run for both shipping and invoicing.

When developing an app for Microsoft AppSource, it is crucial to adhere to specific guidelines and standards to ensure compatibility and compliance. The three code analyzers you should activate are:

CodeCop (A): This is the default analyzer for AL language extensions. It enforces the AL Coding Guidelines, ensuring that the code follows best practices for readability, maintainability, and performance. It checks for a wide range of issues, from syntax errors to best practice violations, making it essential for any AL development.

PerTenantExtensionCop (D): This analyzer is specifically designed for extensions that are intended to be installed for individual tenants. It includes rules that ensure the extension does not interfere with the per-tenant customizations and adheres to the guidelines for extensions that can be safely installed and uninstalled without affecting the underlying application.

AppSourceCop (E): This analyzer is tailored for extensions that are intended for publication on Microsoft AppSource. It enforces additional rules that are specific to AppSource submissions, such as checking for the use of reserved object ranges and ensuring that all prerequisite dependencies are correctly declared. This is crucial for ensuring that your app meets all the requirements for listing on AppSource.

By activating these three analyzers, developers can ensure their app adheres to the standards required for AppSource, as well as maintain high code quality and compatibility with Business Central.

A user observes error messages such as:

"Unhandled UI: Message"

"Unhandled UI: Confirm"

These messages indicate that the test code is not handling system prompts like Message and Confirm dialogs, which can appear during test execution.

Options Explanation:

Message Handler and Confirm Handler methods are used to intercept and handle these UI prompts during automated testing.

These methods should be added to the test runner codeunit, which is responsible for running the tests and handling these system-level interactions.

In the context of cleaning up sandbox environments for a company where data needs to be cleared each time an extension is published, the schemaUpdateMode property in the launch.json file should be set to Recreate (D). Setting this property to Recreate ensures that every time the extension is published, the existing tables and data are dropped, and then the tables are recreated based on the current extension's schema. This mode is particularly useful in development and testing environments where you need a clean slate for testing each version of the extension without the remnants of previous data affecting the outcomes. It's important to use this setting cautiously, as it results in the loss of all existing data in the tables defined by the extension, which is suitable for a sandbox environment but not for production environments.

When developing an app for Microsoft AppSource, it is essential to use an object range that is specifically designated by Microsoft to avoid conflicts with other apps and the base application. The correct object range to use is:

An object range within the range of 70000000 to 74999999 that is requested from Microsoft (D): This range is reserved for AppSource apps. Developers need to request this range from Microsoft to ensure that the objects used in their extension do not conflict with those used by other extensions or by the base application. Using this reserved range helps maintain the integrity and compatibility of extensions published on AppSource.

It's important to note that the other ranges mentioned (A, B, C, and E) are not suitable for apps intended for AppSource. Ranges 50000 to 59999 and 50000 to 99999 are typically reserved for per-tenant customizations or partner solutions, not for distribution on AppSource. The standard range 1 to 49999 is reserved for the base application objects, and using an object range divided by countries (C) is not a standard practice for AppSource apps.

When creating a test codeunit in Microsoft Dynamics 365 Business Central to write unit test functions, the SubType property (A) of the codeunit should be set to Test. This property is crucial for defining the codeunit's purpose and behavior within the application. By setting the SubType property to Test, you are indicating that the codeunit contains test functions intended to validate the functionality of other parts of the application, such as customizations or new developments. This distinction ensures that the testing framework within Business Central recognizes the codeunit as a container for test functions, allowing it to execute these functions in a testing context, which can include setting up test data, running the tests, and cleaning up after the tests have completed.

The property InherentPermissions is used to automatically grant permissions to the table object it is applied to, but setting it to Rl (which seems to be a typo and should likely be 'RL' for Read and Insert permissions) is not sufficient in this scenario. The issues reported by the users suggest that they need more than just read and insert permissions on MyTable. Since users are unable to post sales orders, they likely need Modify, Delete, or Execute permissions on certain tables or objects related to the sales order process. Additionally, the inability to access the list page created in MyTable could be due to lacking Read permissions on other related objects or pages. Therefore, merely setting InherentPermissions = RL on MyTable does not comprehensively address the users' permission issues, especially when considering the principle of least privilege. A more tailored approach to permissions, potentially involving adjustments to the app's code or configuration to ensure proper permissions are applied where necessary, would be needed.

To prevent a caption from being translated in an extension for Microsoft Dynamics 365 Business Central, you should add the Locked = true parameter to the Caption (C). This parameter explicitly marks the caption as locked for translation, ensuring that it remains unchanged across different language versions of the extension. This approach is useful for specific terms, brand names, or other elements within the application that should remain consistent regardless of the user's language settings. Unlike the other options, which involve manual manipulation of the translation file or properties, setting Locked = true directly in the AL code provides a clear, maintainable, and error-proof method to exclude specific captions from the translation process.

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

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;

}

Table Structure in Business Central: When creating entities such as "non-conformity" entities in Business Central, you use document tables to represent entities that have a header and line structure. In this case, the non-conformity entity has:

A header with common information (Non-conformity Number, Date, Vendor No., etc.).

One or more lines representing the detailed information for each non-conforming item.

Document Table Usage:

Document Table: A document table is the correct table type for scenarios where you have a header (with general information like vendor details) and lines (with detailed, item-specific information).

Document tables are typically used for entities such as Sales Orders, Purchase Orders, or any other transactional data where you have both header and line information.

Supplemental Table (Option C):

Supplemental tables are usually used to add supplementary information to existing data in Business Central. In this case, we need to store detailed line information, which is a core part of the entity rather than supplementary data, so a supplemental table would not be appropriate here.

Document History Table (Option A):

Document history tables are used to track changes and historical data for entities but are not suitable for the main introduction of the entity and its lines. This option is also not appropriate.

Reference Documentation:

Introduction to Business Central Tables

Document Tables in Business Central

API Publishing for Extensions:

In Business Central, when creating custom APIs like RoomsAPI, it is important to ensure that they are automatically published during the installation or upgrade of the extension.

To achieve this, you can include a codeunit of type Install in the extension that explicitly publishes the custom API (RoomsAPI) as a web service. This ensures that it is available for use immediately after the extension is deployed without requiring manual intervention.

Codeunit Type:

A codeunit of type Install runs when the extension is installed or upgraded. This type of codeunit can be used to perform setup tasks such as publishing web services or APIs like RoomsAPI.

Why Not Other Options?

Option A (default API configuration): This would not automatically publish the RoomsAPI. Default APIs do not cover custom APIs.

Option B (enable APIs for the environment): Enabling APIs in Business Central allows the standard APIs to be used, but custom APIs still need to be manually published.

Option C (publish via Web Services page): This would work but requires manual intervention to publish RoomsAPI, which does not fulfill the requirement of automatic publishing during installation.

Reference Documentation:

Publishing APIs in Extensions

Codeunit Types in Business Central

In Business Central, fields in tables are assigned specific data types that determine the kind of data they can store. For the Non-conformity table mentioned in the case study, the following data types should be used:

Date for the Non-Conformity Date field: This is because the Non-conformity Date field is required to store only the date when the non-conformity was recorded. The Date data type is appropriate for storing dates without times.

Code for the Non-Conformity Number field: The Non-conformity Number field is described to use alphanumeric values with a format that includes "NC" and the year, like "NC24-001". In Business Central, the Code data type is used for fields that store alphanumeric keys. It is a text field with a limited length, which makes it suitable for number series that contain letters and numbers.

Other options are not suitable:

A. Integer for the Non-conformity Number field: This would not be appropriate because the Non-conformity Number includes alphanumeric characters and not just integers.

B. DateTime for the Non-Conformity Date field: This is not correct because there is no requirement to store the time alongside the date.

C. Char for the Non-Conformity Number field: Char data type is not typically used in Business Central for number series or identifiers. The Code data type is preferred for this purpose.

 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.

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.

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;