Microsoft Dynamics AX 2012 R2 Services

5 (1 reviews total)
By Klaas Deforche , Kenny Saelen
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Getting Started with Microsoft Dynamics AX 2012 Services

About this book

Enterprise Resource Planning (ERP) systems such as Microsoft Dynamics AX 2012 play a central role in an organization, and therefore, there will always be the need to integrate them with other applications. In many cases, services are the preferred way to do this, and Microsoft Dynamics AX 2012 is now more flexible than ever when it comes to the creation and use of these services. Understanding these services will help you effectively identify where they can be used.

Microsoft Dynamics AX 2012 R2 Services is a hands-on guide that provides you with all the knowledge you will need to implement services with Microsoft Dynamics AX 2012 R2. The step-by-step examples will walk you through many of the tasks that you need to perform frequently when creating and using services. This book has been updated to include features of the R2 release while staying relevant to previous version of Microsoft Dynamics AX 2012.

This book will help you to identify situations where services can be used for your implementations. By providing step-by-step instructions for many of the common tasks you will face, you will gain practical know-how on to get the job done.

Easy-to-follow instructions are provided for all the types of services you will encounter. You will learn how to create document services using the AIF Document Service Wizard, and how to use X++ to create custom services. You will also learn how to deploy services and web services and how you can consume them in both X++ and .NET. These services are also put to use in the SysOperation framework, which uses services to run business logic and is the new way to create batch processes in Microsoft Dynamics AX 2012.

Microsoft Dynamics AX 2012 R2 Services provides detailed and practical examples for creating and using services that will make it an invaluable resource that you will consult frequently during your implementations.

Publication date:
March 2014
Publisher
Packt
Pages
264
ISBN
9781782176725

 

Chapter 1. Getting Started with Microsoft Dynamics AX 2012 Services

Microsoft Dynamics AX 2012 introduces a lot of new features that are related to the Application Integration Framework (AIF) and services in general. Many of the existing concepts have been radically changed. This chapter unveils these new features and enhancements made to the services in Microsoft Dynamics AX 2012.

At the end of this chapter, you will have a clear picture of what services mean in the context of Microsoft Dynamics AX 2012. This should enable you to identify where and when to use services in your solution and what type of service to use.

The following topics are covered in this chapter:

  • Introducing services and SOA: We will start by defining what services are and what SOA has to offer, and derive from that the scenarios in which they can be used.

  • Architecture overview: We will look at an overview of the services and AIF architecture and familiarize ourselves with the key components of the architecture.

  • New and enhanced features: We will discuss the new features and enhancements that have been made compared to Microsoft Dynamics AX 2009. This is also an opportunity to find out why some of these changes were made.

  • Types of services and comparison: There are several types of services available to choose from when implementing your solution. Therefore, it is important to be able to distinguish between these different types and choose the type that suits your needs best.

 

Introducing services and SOA


So what is a service? The best way to understand what a service is, is understanding why you would need a service. Typically, there are a lot of different applications being used in an enterprise. Sometimes this is by design; for example, because a specialized functionality is needed that is not implemented in the ERP system. In other cases, legacy systems are not replaced when implementing an ERP system, simply because they do their jobs well. Whatever the reasons, these or others, the result is the same: a growing number of different applications.

One of the problems with these applications is that they are likely to have been built using different technologies. Because they speak a different language, it makes them unable to communicate with each other. This is a problem that services address by providing a means by which applications can communicate, independent of their technology. They achieve this by adhering to standards and protocols so that, in essence, they start speaking the same language.

A service should have many of the same qualities as modern applications. Applications should be modular, components should be reusable, and everything should be loosely coupled. These principles also apply when developing services. Your services should have a well-defined functionality and should be able to autonomously execute that functionality without interaction with other services.

Services should also be abstract. By this we mean that other applications should not have to know the inner workings of the provider in order to use the service. This can be attained by hiding details such as how data is stored, what technologies are used, and how the business logic is implemented. Abstraction is not an end goal, but a way to achieve loose coupling and reusability.

A service is also self-describing, meaning it can provide other applications with metadata about itself. This metadata describes what operations can be used and what the input and output is. In the case of Microsoft Dynamics AX, this information is published using the Web Service Description Language (WSDL).

All of these qualities make services usable in a Service-Oriented Architecture (SOA). In an SOA, services are published and made discoverable. Services are then composed to create loosely coupled applications.

Example implementations

To make the previous explanation about services more concrete, we will take a look at three very different scenarios in which services can be used.

Bing API

Microsoft provides an API for Bing Maps and Search that is available to developers in various ways, including a web service. Developers can use this service for things such as calculating a route between two addresses, locating an address on a map, getting search results for a certain query, and so on. It's not hard to imagine this service being used in a logistics application; for example, to calculate the most efficient route for delivering goods to customers.

Mobile application

Let's look at a scenario where a mobile application has to be developed for Microsoft Dynamics AX 2012. Even if your mobile application contains business logic to work offline, data will have to be sent back to the Application Object Server (AOS) at some point. The mobile application could use services to execute business logic and send data to the AOS when a network is available. A mobile application can also be built without containing business logic, in a way that it only renders a Graphical User Interface (GUI). In this scenario, the application will have to stay connected to the AOS over the network because the AOS will drive the application and tell it what to do using services.

Business Process Modeling (BPM)

You can use services in an SOA to model business processes. When all requirements for the business processes are available as services, it is possible to compose processes entirely using services. When done right, this is very powerful because of the great flexibility that the combination of BPM and SOA provides.

 

Architectural overview


Depending on the requirements of your projects, a different architectural approach will be needed. To make the right decisions when designing your solutions, it is important to understand the services and AIF architecture.

Compared to Microsoft Dynamics AX 2009, there have been a lot of improvements made to the service architecture in Microsoft Dynamics AX 2012. The biggest improvement is the native Windows Communications Foundation (WCF) support. As a result, the proprietary Microsoft Message Queuing (MSMQ) and BizTalk adapters that were available in Microsoft Dynamics AX 2009 have been deprecated and replaced by adapters that use WCF. The MSMQ adapter in particular is replaced by an adapter that uses the WCF NetMsmq binding. The filesystem adapter remains intact and still allows you to import and export messages from and to the filesystem.

All services are WCF services and are hosted on the AOS. When an application wants to consume these services on the local network, no further deployment is needed because it can connect directly to the AOS. Just like with Microsoft Dynamics AX 2009, deployment on Internet Information Services (IIS) is needed for consumers that are not on the intranet. However, the services themselves are no longer deployed on IIS; instead, a WCF routing service on the IIS routes everything to the AOS.

If you want to modify messages before they are received or after they are sent, you can use pipelines and transformations. Pipelines only apply to the body of a message and are handled by the request preprocessor and response postprocessor. You can use transformations to transform a complete message, including the header. This allows you to exchange messages in a non-XML format.

The following diagram depicts the architecture as it is in Microsoft Dynamics AX 2012 and clearly shows the central role of WCF:

While not displayed in the diagram, there is now load balancing support for services using Windows Server Network Load Balancing (NLB). Combined with NLB for IIS, which was already available, this enables high availability and load balancing for services.

 

New and enhanced features


Services have been around for some time in Microsoft Dynamics AX. AIF was initially introduced with the release of Microsoft Dynamics AX 4.0, with Microsoft Dynamics AX 2009 continuing to build on that. But with the release of Microsoft Dynamics AX 2012, Microsoft has really succeeded in bringing the service functionality to a whole new level. Occasionally, even more features and enhancements are added in new releases and cumulative updates. Let us take a walk through the major changes that Microsoft Dynamics AX 2012 brings to the table.

The AOS WCF service host

The first major feature that has been added to this release is that the AOS is now the host for the Microsoft Dynamics AX 2012 services. In previous releases, the exchange of messages was either through adapters such as the filesystem, BizTalk, and MSMQ adapter, or services that were exposed as WCF 3.5 services through IIS. With the latter, IIS was acting as the host for the WCF services.

With this new release of Microsoft Dynamics AX, services will be exposed as WCF 4.0 services hosted directly in the AOS Windows service. As long as intranet users and applications are consuming these services, no IIS is needed.

WCF adapters

Microsoft Dynamics AX 2012 provides a lot more support for WCF. Proprietary adapters such as BizTalk and MSMQ that were previously available are now obsolete and no longer available. Instead, support for MSMQ and BizTalk is provided by a native WCF equivalent of these adapters.

This does not mean that creating custom adapters using the AIF adapter framework is not supported anymore. Custom adapters can still be added by implementing the AifIntegrationAdapter interface.

Out of the box, Microsoft Dynamics AX 2012 comes with the following adapters:

  • NetTcp: This is the default adapter used when creating a new integration port. This adapter type corresponds to the WCF NetTcpBinding. It provides synchronous message exchanges by using WS-* standards over the Transmission Control Protocol (TCP).

  • Filesystem: This can be used for asynchronous exchange of XML messages stored in the filesystem directories.

  • MSMQ: This is used when support for queuing is needed. Message exchange is asynchronous and uses MSMQ. Note that choosing this adapter type actually uses the WCF NetMsmq binding.

  • HTTP: This supports synchronous message exchanges over the HTTP and HTTPS protocols. This was already available in Microsoft Dynamics AX 2009, but there is a difference in the deployment to the IIS. The business connector is no longer used for services hosted on the IIS; instead, a WCF routing service is used. There is more about routing services later in this chapter.

    Note

    More information about the bindings that are used in these adapters can be found on MSDN at http://msdn.microsoft.com/en-us/library/ms733027.aspx. If you want to learn more about WS-* standards, check out the Web Services Specification Index Page at http://msdn.microsoft.com/en-us/library/ms951274.aspx.

Integration ports

In Microsoft Dynamics AX 2009, there was a lot of configuration required to get AIF up and running. This included configuration of the following:

  • Endpoints

  • Local endpoints

  • Channels

  • Endpoint users

  • Endpoint constraints

Now, integration ports have been added and they provide a simpler way to configure services. There are two types of integration ports: inbound and outbound. Which type you should use for your service depends on whether the message originates from outside or inside of Microsoft Dynamics AX.

The inbound integration ports can be divided into two types: basic and enhanced. Out of the box, Microsoft Dynamics AX 2012 already has some services that are associated with basic integration ports. These have been deployed and enabled by default. We will discuss how these basic ports differ from enhanced ports in later chapters.

Instead of having Microsoft-Dynamics-AX-specific endpoints and channels, integration ports use native WCF to deploy services and therefore endpoints, security, behaviors, bindings, and so on. All of this is configured using the WCF Configuration utility. By default, integration ports are hosted on the AOS using the NetTcp binding.

IIS hosting without Business Connector

Previously, when services were deployed on IIS, they used the .NET Business Connector to communicate with the AOS. This has been replaced by a WCF routing service that implements the IRequestReplyRouter interface. Regardless of whether services are consumed from the intranet or the Internet, they are always processed by the AOS. So, when services are deployed to be used on the Internet, they will be deployed both on the AOS and on the IIS. The AOS hosts the service using the NetTcp binding, and the IIS has a WCF routing service that will forward service requests to the internal services hosted on the AOS.

Non-XML support

Using transformations, Microsoft Dynamics 2012 can transform inbound messages from a variety of formats into a format AIF can understand. Likewise, outbound messages can be transformed from the AIF format into a format required by external systems. There are two types of transformations that can be used: Extensible Stylesheet Language Transformations (XSLT) and .NET assemblies.

You can create XSLT transformations by using any text editor, but tools such as BizTalk MAPPER, Visual Studio, or Altova MapForce make it very easy. .NET assemblies are DLL files that can be compiled using Visual Studio and do transformations in code. This is especially convenient for transforming from or into a non-XML format. Some of the tools available can actually generate both the XSLT and the managed code needed to compile a .NET assembly.

 

AIF change tracking


In Microsoft Dynamics AX 2009, document services had a set of six operations available for use. They are as follows:

  • Create

  • Delete

  • Find

  • FindKeys

  • Read

  • Update

In Microsoft Dynamics AX 2012, there are two additional operations available for developers:

  • GetKeys: This can be used in combination with a document filter to only obtain the keys of the documents that were the result of the filter.

  • GetChangedKeys: This does the same as the GetKeys operation with the addition of a date and time being passed to the action. This way, only the keys of documents that have actually changed since that time are returned.

 

Custom services


One of the major changes in Microsoft Dynamics AX 2012 is the ease and flexibility by which you can create custom services. Instead of having to provide all the technical details on how the documents need to be serialized by implementing AifSerializable, you can now easily attribute class instance methods. These attributes are used to identify service operations and data contract members.

 

The SysOperation framework


Prior to Microsoft Dynamics AX 2012, the RunBase framework was used to provide a generic way to create processes and batch jobs in the system.

In Microsoft Dynamics AX 2012, the SysOperation framework allows you to leverage the power of services to execute your business logic in Microsoft Dynamics AX. When you create a service, it encapsulates the business logic so other components within the system can use the service instead of accessing the business logic themselves.

The SysOperation framework makes use of the Model-view-controller (MVC) pattern by using multiple components that each have their own responsibilities. These components separate the business logic from the code that is responsible for rendering the GUI and the classes that represent the data model. This is a great leap forward from Microsoft Dynamics AX 2009, where everything was written in one class that extended Runbase.

Also important to note is that, when a service has been created for the SysOperation framework, it requires little effort to expose the same service to the outside world. You can simply expose it using an integration port.

So the advantages of the SysOperation framework can be summarized as follows:

  • It facilitates a service-oriented approach within Microsoft Dynamics AX

  • It implements the MVC pattern for more efficient client/server communication and separation of responsibilities

  • The GUI is automatically generated based on data contracts

  • Less effort in exposing business functionality externally using services

 

Types of services


Microsoft Dynamics AX 2012 already provides a number of services out of the box. These services, together with additional services that can be developed, can be divided into three types. Each of the service types has its own characteristics and a different approach to create it.

Document services

Document services use documents to represent business objects such as purchase and sales orders, customers, and vendors.

A document service is composed of the following components:

  • Document query: This is a query that is created in the Application Object Tree (AOT) and contains all the tables that are related to the business object that you want to expose. Based on this query, the Document Service Generation Wizard can be used to generate the other artifacts that make up the document service.

  • AxBC classes: This class is a wrapper for a table and contains business logic that is needed for the Create, Read, Update, and Delete (CRUD) operations.

  • Document class: The purpose of this class is to contain business logic that is associated with the creation and modification of the business entity itself. For example, the AxdCustomer class could contain logic to handle a customer's party information.

  • Document service class: This is the actual service implementation class and extends the AifDocumentService class. This class implements the service operations that are published through the service contract.

When creating document services, developers need to make sure that the business object is mapped correctly to the document query. The document services framework will handle all other things, such as the serialization and deserialization of XML and date effectiveness.

Document services can be deployed using the integration ports and all available adapters can be used.

Custom services

Custom services were already available in Microsoft Dynamics AX 2009, but support for Extended Data Types (EDTs) was limited, which resulted in developers having to provide custom serialization and deserialization logic. Microsoft Dynamics AX 2012 introduces the concept of attributes. Attributes provide a way to specify metadata about classes and methods. Two of these attributes are used when creating data contracts: the DataContractAttribute and DataMemberAttribute attributes.

The DataContractAttribute attribute is used to define that a class is a data contract. The DataMemberAttribute attribute is added to methods of data contracts representing data members that have to be exposed. This way of defining data contracts is very similar to other programming languages such as C#.

Support for more complex datatypes such as collections and tables has been added so that these types can be serialized and deserialized without developers having to provide the logic themselves.

In a typical custom service, you will find the following components:

  • Service contract: A service contract is an X++ class that contains methods with the SysEntryPointAttribute attribute. This identifies methods that will result in a service operation contract when the service is exposed.

  • Data contracts: A data contract is an X++ class that is attributed with the DataContractAttribute attribute. It contains parameter methods that will be attributed as data members for each member variable that needs to be part of the data contract.

Custom services can be deployed using the integration ports and any available adapter can be used.

System services

These services are new since the release of Microsoft Dynamics AX 2012. The main difference between these services and the previous two types is that they are not customizable and are not mapped to a query or X++ code. They are not customizable because they are written by Microsoft in managed code. One exception is the user session service, which is written in X++ code but is generally considered as a system service.

There are four system services available for use in Microsoft Dynamics AX 2012: the query service, the metadata service, the user session service, and the OData query service.

The query service

The query service provides the means to run queries of the following three types:

  • Static queries defined in the AOT.

  • User-defined queries by using the QueryMetaData class in the service.

  • Dynamic queries that are written in X++ classes. These classes need to extend the AIFQueryBuilder class.

When queries are called by a service, the AOS authorization ensures that the caller has the correct permissions to retrieve the information. This means that unpermitted fields will be omitted from the query result. Furthermore, when joined data sources are not allowed to be used, the query call will result in an error that can be caught by the calling application.

The resulting rows will be returned as an ADO.NET DataSet object. This can be very useful when you make use of controls in your application that can be bound to a DataSet object.

The query service can be found at the following link: net.tcp://<hostname:port>/DynamicsAX/Services/QueryService

The metadata service

This system service can be used to retrieve metadata information about the AOT. Consumers of this service can get information such as which tables, classes, forms, and menu items are available in the system. An example use case for this service is when retrieving information about the AOT and using it in a dashboard application running on the Microsoft .NET Framework. We will create an example dashboard application in Chapter 7, System Services, where we will use this service to look up queries in the AOT.

The metadata service can be found at net.tcp://<hostname:port>/DynamicsAX/Services/MetaDataService.

The user session service

The third system service is the user session service. With this service, you can retrieve information about the caller's user session. This information includes the user's default company, language, preferred calendar, time zone, and currency.

The user session service can be found at the following link: net.tcp://<hostname:port>/DynamicsAX/Services/UserSessionService

The OData query service

The OData query service is a REST-based service that uses the OData protocol to expose the results of a query object in the AOT in an Atom feed. Open Data Protocol (OData) is a web protocol that allows CRUD operations, but the Microsoft Dynamics AX 2012 implementation only supports reading data.

The OData query service can be found at the following link: http://<hostname:port>/DynamicsAX/Services/ODataQueryService

Tip

What is a RESTful web service?

Representational State Transfer (REST) represents a set of design principles by which web services are developed. For more details about REST, you can go to the following link: http://www.ibm.com/developerworks/webservices/library/ws-restful/

Choosing the right service for the job

Now that it is clear what types of services Microsoft Dynamics AX 2012 has to offer, the question arises as to when each type of service should be used. There is no simple answer for this due to the fact that every type has its strengths and weaknesses. Let us take a look at two factors that may help you make the right decision.

Complexity

Both document services and custom services can handle any business entity complexity. The document services framework parses the incoming XML and validates it against an XML Schema Definition (XSD) document. After validation, the framework calls the appropriate service action.

Custom services, on the other hand, use the .NET XMLSerializer class and no validation of data is done. This means that any validations of the data in the data contract need to be written in code. Using custom services, you not only have to code all validation, but also all the other business logic. When working with data from the database, this puts custom services at a disadvantage because document services use AxBC and document classes that already contain a lot of the logic needed for CRUD operations.

Flexibility

Document services have service contracts that are tightly coupled with the AOT Query object. This means that when the query changes, the schema also changes. Data policies allow you to control which fields are exposed. When using custom services, this cannot be done by setup, but has to be done at design time.

Custom services have flexibility towards the service contract, while document services lack such flexibility. Here, the developer is in full control of what is in the contract and what is not. The operations, input parameters, and return types are all the responsibility of the developer.

Another benefit of using custom services is the ability to use shared data contracts as parameters for your operations. Think of a company-wide software solution that involves the use of Microsoft Dynamics AX 2012 together with SharePoint and .NET applications that are all linked through BizTalk. You could opt to share data contracts to make sure that entities are the same for all of the components in the architecture.

In that scenario, you're able to create a data contract in managed code and reference it in Microsoft Dynamics AX 2012. Then you can use that .NET data contract in your service operations as a parameter.

There will probably be more factors that you will take into consideration to choose between the service types, but we can come to the following conclusion about when to use which type of service:

  • Custom services: These should be used when exposing entities that have a low complexity or data contracts that need to be shared between other applications. They are also ideal when custom logic needs to be exposed that may have nothing to do with data structures within Microsoft Dynamics AX.

  • Document services: These should be used when exposing entities that have high complexity and when validation of the data and structure would require a lot of work for developers to implement on their own.

  • Query service: This should be used only when read operations are needed and there is no need for updates, inserts, or delete actions. It can be used when writing .NET Framework applications that leverage the data from Microsoft Dynamics AX and are returned as an ADO.NET DataSet.

  • Metadata service: This service should be used when metadata information about objects in the AOT is required.

  • User session service: This should be used when user-session-related information is required.

  • OData query service: The OData query service can be used when you want to expose data from AX over HTTP using the OData protocol. This allows for compatibility with other applications that support OData, such as the PowerPivot add-in for Microsoft Excel.

 

Summary


In this first chapter, we went through the major changes that Microsoft Dynamics AX 2012 brings for services architecturally and saw that a lot has changed because of the WCF support.

Looking at the new features that were added, it is clear that Microsoft has provided us with a lot of new tools and methods for integration. A lot of work has been done to enable developers to expose business logic in a more intuitive way using attributes. The setup is simplified, and the system services allow you to build entire applications without the need for development in X++.

There are a lot of options to choose from, so it is not always easy to choose the right approach for your implementation. In this book, you will get to know all of the features to help you to make the best choice.

In the next chapter, we will look at the service architecture in more detail and review the many options that are available when deploying services.

About the Authors

  • Klaas Deforche

    Klaas Deforche started working as a developer on Microsoft Dynamics AX in 2007 for the Belgian ICT company RealDolmen, primarily working with Dynamics AX 4.0. He gained experience with AX 2009 while working on projects for some well-known Belgian fashion retailers, especially on the integration side of things. He is currently working on AX 2012 projects for customers in the healthcare sector. Klaas likes to share his knowledge with the community, which is why he started his AX-oriented blog artofcreation.be in 2009. This is also why, in 2012, Klaas co-authored the book Microsoft Dynamics AX 2012 Services, Packt Publishing, to help spread knowledge on the subject.

    Browse publications by this author
  • Kenny Saelen

    Kenny Saelen is a Dynamics AX MVP who works for the Belgian ICT company RealDolmen. He started as a developer on Microsoft Dynamics AX in 2004, primarily working on a European customer implementation with Dynamics AX 3.0. At RealDolmen, he gained experience with Dynamics AX 2009 while implementing AX internally, followed by an implementation at a book wholesale company. Currently, he is working as a technical architect for a worldwide customer implementation with Microsoft Dynamics AX 2012 R2, mainly working towards integrating Dynamics AX with other technologies such as SharePoint, BizTalk, and AgilePoint. He can be reached through his blog ksaelen.be.

    Browse publications by this author

Latest Reviews

(1 reviews total)
Terug een zeer goed boek, geschreven door insiders bij Microsoft Dynamics AX.