Transfer data between .NET Core and NAV

In this article, I will discuss different methods to transfer data between .NET Core and NAV in JSON format. We will also explore how to consume published NAV codeunit using .NET Core and build an external API to manage NAV data.

The implementation of .NET Core NAV middleware can vary based on the NAV version, authentication types, and data specifics. In this article, we will discuss three different ways of implementing the middleware.

.NET Core NAV middleware based on SOAP web services and WCF

This approach works for NAV2009-NAV2018 when codeunit is published as SOAP web service.

1. The core of our .NET Core NAV middleware is the Codeunit, which exports the external function GetJSON. This function takes Request and Param as input parameters and returns ReturnJSON in JSON format. GetJSON is the central entry point, and depending on the Request, it distributes data to the internal functions of the Codeunit.
2. For instance, an internal function, GetItems, returns a list of products in JSON format using the Newtonsoft.Json library as a .NET add-on.
3. To make our Codeunit available to .NET Core, we publish it as a SOAP Web service with a specific URL.
4. By opening this URL in a browser, we can see the WSDL metadata of the published GetJSON function.
5. To connect the published Codeunit, we use Visual Studio tools and CoreWCF, which is a port of the service-side of Windows Communication Foundation (WCF).
6. The WCF library generates all the necessary proxy classes automatically.
7. Using the generated proxy classes, we create a ServiceRepository class, which manages the connection channel.
8. In the ServiceRepository class, we create a wrapper over the GetJSON function to establish a connection between the NAV middle tier and the .NET Core NAV middleware.

.NET Core NAV middleware based on SOAP web services and System.Net.Http.HttpClient

To establish a more convenient and lightweight connection with NAV in certain scenarios, one can avoid using WCF. By employing basic authorization and maintaining the GetJSON function signature, the System.Net.Http.HttpClient library can be utilized for sending simple POST or GET requests in XML format. This approach can streamline the process and offer a simpler solution for certain use cases.

1. To communicate with a published SOAP service, we can directly provide an XML envelope that adheres to specific rules. The JSON data from the <return_value> XML tag can be easily extracted from the request response body.
2. To pass authorization in the SOAP service, we need to provide the login and password encoded in a base64 string as the Authorization header. Additionally, we should include the codeunit name and function name as the SOAPAction header.
3. In Postman, we can enter the login and password for Basic Authorization in the Authorization tab.
4. Using the .NET System.Net.Http.HttpClient library, we can create a POST request, pass the necessary headers, and the XML envelope in the body to retrieve data from the SOAP service.

.NET Core NAV middleware besed on OData V4 Unbound Action and System.Net.Http.HttpClient

From Microsoft Dynamics NAV 2018 and onwards, it is feasible to expose a function as a web service action using OData V4. This represents a more advanced and modern approach to interacting with NAV, surpassing the SOAP Web services method. OData V4 is widely adopted to connect to Business Central.

1. In Visual Studio Code, we can create an entry point for the GetJSON function, utilizing the same approach mentioned earlier to distribute data between internal functions of the codeunit.
2. As an example, we can create a Ping function that simply sends to the output whatever it receives as an input parameter.
3. Codeunit is published as an OData V4 service.
4. We can call codeunit function by URL /NAVMiddleTierName/ODataV4/CodeunitName_FunctionName. However, it’s important to include basic Authorization and Company in the request headers.
5. By passing a JSON body to the POST request, we can receive a response from the Ping function.
6. With the .NET System.Net.Http.HttpClient library, we can create a POST request and include the necessary headers and JSON data in the body.

Building API to manage NAV data with .NET Core.

With the three methods outlined above, we have successfully established a connection between .NET Core and the NAV codeunit. The next step is to create an API for frontend clients such as web and mobile applications, or other systems that require NAV integration.

To accomplish this, we can utilize the ASP.NET Core MVC framework to implement the API, user interfaces, data, and control logic.

1. Here’s an example of an MVC controller that receives the Request parameter as a NAV method name, and a JSON string in the body. It passes this data to the GetJSON function.
2. Frontend applications can leverage this controller by calling the GetItems method, which enables them to retrieve a list of items directly from NAV and draw them on the screen.

Extending .NET Core NAV middleware

In this article, we have explored several methods on how to use .NET Core to extract data from NAV in JSON format and transmit it to client applications. However, the concept of .NET Core NAV middleware goes beyond being a mere data transmitter. It serves several additional purposes, such as:

1. Load balancing for a large number of requests
2. Request caching in internal memory
3. Intermediate storage of files and pictures
4. Authentication and data protection
5. Sending email or SMS notifications
6. Integration with payment systems
7. Logging and monitoring tools

These functionalities can be implemented as plug-ins and added to the middleware, based on the customer’s specific requirements. By leveraging the .NET Core NAV middleware, developers can create custom solutions that not only provide seamless integration with NAV but also offer additional features and functionalities to meet the client’s specific business needs.