Florian's weblog

Limitations of the Dynamics Ax service references

flo2005 — Thu, 01 Jul 2010 09:39:57 GMT

The article about service-references limitations is available on my new blog.

Cross domain access to AIF Web Services (Dynamics Ax 2009)

flo2005 — Wed, 30 Jun 2010 21:29:40 GMT

I published the new article on my new blog.

.net programming for Dynamics AX developers slides

flo2005 — Wed, 30 Jun 2010 21:27:40 GMT

I published the slides from my last years presentation on my new blog. This is has been the working draft, but it contains much more slides as the final version, so I’m publishing this one.

Installing the COM Business Connector

flo2005 — Wed, 23 Jun 2010 16:11:10 GMT

I published the new article on my new blog.

My blog is Moving

flo2005 — Fri, 05 Feb 2010 09:40:29 GMT

I’m moving to Blogger since I’m writing these articles for personal purposes and I want to have as much control as possible on my postings. So Please be aware that I will will publish my next articles on the new blog.

Enterprise Portal license required for workflows with dynamics Ax 2009

flo2005 — Mon, 25 Jan 2010 16:58:12 GMT

Dynamics Ax workflow does require the Enterprise Portal (EP) license. License changes since Dynamics Ax 4 can be found here.

Please double-check that the EP license is well configured when the BC.Net throws the following exception (can be found in the Windows application-EventLogs):

Session log on for Microsoft Dynamics failed.
Dynamics Adapter LogonAs failed.
Microsoft.Dynamics.Framework.BusinessConnector.Session.Exceptions.FatalSessionExcept
ion
at
Microsoft.Dynamics.Framework.BusinessConnector.Session.DynamicsSession.HandleExcepti
on(String message, Exception exception, HandleExceptionCallback callback)
at
Microsoft.Dynamics.Framework.BusinessConnector.Session.DynamicsAdapter.LogonAs(Strin
g user, String domain, NetworkCredential bcProxyCredentials, String company, String
language, String objectServer, String configuration)

Delete TEMP files when sending mails with attached files

flo2005 — Mon, 25 Jan 2010 15:53:58 GMT

Attaching Documents is a frequently used functionality in Ax (PDF is just an example, but it is true for any attached file):

That is why tmp-files, that are generated each time you are using this, might consume quickly an important part of your hard disk, since they are not deleted at the end of the process. The temp-files are copies of the generated text, pdf or RTF files from the tmp-directory. This directory is defined as an user environment variable:

The easiest way is to schedule a batch which is cleaning the temp directly each time you are starting or shutting down your system. But even this is sometimes not enough. The it is necessary to change the X++ code.

When sending a report as an attachment, the kernel calls the method reportSendMail of the Info-class and passes all necessary information about the attachment in a variable of type PrintJobSettings.

The email is sent in the last line of this method:

m.sendMailAttach(p1.mailTo(),p1.mailCc(), p1.mailSubject(),'axapta report', true, p1.fileName(), fileName);

“m” is a variable of type SysINetMail. The path and file-name of the temp-file is passed as argument with p1.fileName(). Because the tmp-file is only used to attach the file to mail by using the Mapi, the is no risk to delete the file at the end of this process. The best place to delete this file is after the logoff of the Mapi session in the method sendMailAttach:

   1:          this.logoff();

   2:          if (!isRunningOnServer())

   3:          {

   4:              if(WinAPI::fileExists(_attachPath))

   5:              {

   6:                  WinAPI::deleteFile(_attachPath);

   7:              }

   8:          }

Line 2 to 8 is the new code. Line 2 checks if the code is called from the AOS, which is always false, but to be sure that any other custom-code will work, it is better to check this nevertheless. It would be better to encapsulate the delete-call in a try-catch-block, because deleting files is always a risk and must be treated, but this is just an example of course.

Working with Images (BLOBS) between Dynamics Ax and external applications (UPDATED: 06/01/2010)

flo2005 — Mon, 04 Jan 2010 15:00:00 GMT

(updated the 05/01/2010 and 06/01/2010)

The idea

Whenever you need to transfer data in a platform specific format (like Images), the easiest way of doing this is to create an envelope (in Xml) and put the data in an encoded format in this envelope.

Here’s a schema that shows such a scenario:

The Ax layer

On the Ax layer (the 2nd row) the image is transformed in a base64 string (the text file in the schema) and then put into an Xml-document (the envelope in the schema).

Just have a look at the table CompanyImage, that is used to persist the picture of an employee:

The type of the column in which the image is saved is “Container”. There is no explicit type for Images, but you will notice that the table in the SQL-Server database uses the type “Image” to persist the container information. The image-type of the SQL-Server 2008 is defined as:

Variable-length binary data from 0 through 2^31-1 (2,147,483,647) bytes.

In contrast to its name (“image”) this type is used to persist any binary data from Ax (container). Working in X++ with the binary data in the container requires the conversion to the type BinData which provides all necessary information to load, save, encode or decode binary data. This is what I will do in the following example.

Here’s a simple code that reads out the image (CompanyImage) and puts this in a XmlDocument:

   1:  public static XmlDocument  getImageXml(dataAreaId refDataAreaId, tableId refTableId, recId refRecId)

   2:  {

   3:      XmlDocument xmlEnvelope;

   4:      XmlElement childNode;

   5:      str content;

6:

   7:      CompanyImage ci;

8:

   9:      BinData bin = new BinData();

  10:  ;

11:

  12:  //getting image from CompanyImage

  13:  ci = CompanyImage::find(refDataAreaId, refTableId, refRecId);

14:

  15:  //creating BinData object from Container in the CompanyImage object

  16:  bin.setData(ci.Image);

  17:  //encoding the image to base64

  18:  content = bin.base64Encode();

19:

  20:  //creating the envelope and inserting a XmlElement that contains the image

  21:  //in a base64 string

  22:  xmlEnvelope = new XmlDocument();

  23:  childNode =  xmlEnvelope.CreateElement("image");

  24:  childNode.innerXml(content);

25:

  26:  xmlEnvelope.AppendChild(childNode);

27:

  28:  return xmlEnvelope;

  29:  }

Here’s the code for testing this function

   1:  static void Job11(Args _args)

   2:  {

   3:      str xmlContent;

   4:      XmlDocument xmlEnvelope;

5:

   6:      recId refRecId;

   7:      tableId refTableId;

   8:      dataAreaId refDataAreaId;

9:

  10:  int i;

  11:  ;

  12:  //Sample Data...

  13:  refDataAreaId = "ceu";

  14:  refTableId = 103;

  15:  refRecId = 5637144576;

  16:  xmlEnvelope = new XmlDocument();

  17:  //getting image from CompanyImage

  18:  xmlEnvelope = A1::getImageXml(refDataAreaId, refTableId, refRecId);

19:

  20:  xmlContent = xmlEnvelope.xml();

  21:  }

Just an useful hint: If you need to encode large images, you might run into an issue with the base64Encode method. Unfortunately this is not documented on msdn, but this is related to a limitation of the buffer size. This can be fixed as described by Paul Steynberg on his blog.

Whenever you communicate with an external application that can’t convert the Ax type XmlDocument, you need to wrap the method getImageXml with a method that returns a string:

   1:  public static str  getImage(dataAreaId refDataAreaId, tableId refTableId, recId refRecId)

   2:  {

   3:      return A1::getImageXml(refDataAreaId, refTableId, refRecId).xml();

   4:  }

The client (using BC.Net)

Now that we have a method that return a string instead of a XmlDocument, we can directly use CLR objects instead of using wrapper classes. In .Net we can handle the XmlDocument-content from the Ax 2009 in a string. But, since Xml is much more flexible than a simple encoded string, a method that does the conversion to a System.Xml.XmlDocument is recommended:

   1:          /// <summary>

   2:          /// Getting the Xml-envelope with the image

   3:          /// </summary>

   4:          /// <param name="refDataAreaId">ceu</param>

   5:          /// <param name="refTableId">103</param>

   6:          /// <param name="refRecId">5637144576</param>

   7:          /// <returns>The Xml-envelope with the image as content</returns>

   8:          private static XmlDocument GetXmlDocument(string refDataAreaId,

   9:              int refTableId,

  10:              long refRecId)

  11:          {

  12:              XmlDocument xml = new XmlDocument();

13:

  14:              using (Axapta ax = new Axapta())

  15:              {

  16:                  ax.Logon(refDataAreaId, string.Empty, string.Empty, string.Empty);

17:

  18:                  string xmlImageValue = (string)ax.CallStaticClassMethod("A1", "getImage", refDataAreaId, 103, 5637144576);

19:

  20:                  xml = new System.Xml.XmlDocument();

  21:                  xml.InnerXml = xmlImageValue;

  22:                  ax.Logoff();

  23:              }

24:

  25:              return xml;

  26:          }

Please be aware that this is just an example and that in a real world application you must implement an exception handling which I do not implement here to have code that is easier to read.

Now that we do have the xmlEnvelope with the encoded image as content, we need a method that does read out the content and returns the image:

   1:          private static Image UnwrapImage(XmlDocument xmlEnvelope)

   2:          {

   3:              XmlElement imageContent = (XmlElement) xmlEnvelope.FirstChild;

   4:              string base64Image = imageContent.InnerXml;

5:

   6:              byte[] imageBytes = Convert.FromBase64String(base64Image);

7:

   8:              MemoryStream stream = new MemoryStream(imageBytes);

   9:              Image content = Image.FromStream(stream);

10:

  11:              return content;

  12:          }

All that we need is an event that dos call this method and that assigns the image-content for example to a visual control like a picture-box:

   1:          private void button6_Click(object sender, EventArgs e)

   2:          {

   3:              string refDataAreaId = "ceu";

   4:              int refTableId = 103;

   5:              long refRecId = 5637144576;

6:

   7:              XmlDocument xmlEnvelope =

   8:                  GetXmlDocument(refDataAreaId,

   9:                      refTableId,

  10:                      refRecId);

11:

  12:              Image content = UnwrapImage(xmlEnvelope);

13:

  14:              pictureBox1.Image = content;

  15:          }

The Ax layer (using the AIF)

The first schema was based on the communication with Xml data. I was not explicitly showing the possibility to use the BC.Net because the real advantage of the xmlEnvelope data is given when all the communication is based on Xml. This is the case with WebServices. Creating an AIF-service that exposes a method returning the XmlEnvelope is quite easy. First you need a class that is derived from the AifDocumentService and that implements the following methods:

   1:  class AifSampleImageService extends AifDocumentService

   2:  {

   3:  }

   1:  public static str  getImage(dataAreaId refDataAreaId, tableId refTableId, recId refRecId)

   2:  {

   3:      return A1::getImageXml(refDataAreaId, refTableId, refRecId).xml();

   4:  }

   1:  protected void new()

   2:  {

   3:      ;

   4:      super();

   5:  }

   1:  public static AifSampleImageService construct()

   2:  {

   3:      return new AifSampleImageService();

   4:  }

After that a new Service and the operator needs to be configured in the AOT:

Be careful that the security key is configured. Otherwise this will result in an authorization error.

Once the Service is configured this new service is available in the AIF-configuration by refreshing the available AIF-services and enabling the new AIF-service the AIF-services in the AIF-administration:

Then the services need to be regenerated (“Generate button). The new service is now available and accessible with the Internet Explorer:

The Xml-schema (Xsd) that represents the AIF-operator is the following:

   1:  <?xml version="1.0" encoding="utf-8"?>

   2:  <xs:schema elementFormDefault="qualified" targetNamespace="http://tempuri.org" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://tempuri.org">

   3:    <xs:element name="AifSampleImageServiceGetImageRequest">

   4:      <xs:complexType>

   5:        <xs:sequence>

   6:          <xs:element minOccurs="0" name="refDataAreaId" nillable="true" type="xs:string"/>

   7:          <xs:element minOccurs="0" name="refRecId" type="xs:long"/>

   8:          <xs:element minOccurs="0" name="refTableId" type="xs:int"/>

   9:        </xs:sequence>

  10:      </xs:complexType>

  11:    </xs:element>

  12:    <xs:element name="AifSampleImageServiceGetImageResponse">

  13:      <xs:complexType>

  14:        <xs:sequence>

  15:          <xs:element minOccurs="0" name="response" nillable="true" type="xs:string"/>

  16:        </xs:sequence>

  17:      </xs:complexType>

  18:    </xs:element>

  19:  </xs:schema>

As you can see in line 15, the return type of the operator “GetImage” has the type “string”. This is certainly not the best solution in a SOA-context, since you loose the type information of your Xml-document. In a real world application it would be much better to define a special type within Ax that describes the format. It seems to be clear, that the following schema explains perfectly, that image-element contains a encoded base64 value:

   1:  <?xml version="1.0" encoding="utf-8"?>

   2:  <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">

   3:    <xs:element name="image" type="xs:base64Binary" />

   4:  </xs:schema>

The type “base64Binary” is part of the Xml-schema specification of the W3C and defined as:

base64Binary represents Base64-encoded arbitrary binary data. The ·value space· of base64Binary is the set of finite-length sequences of binary octets. For base64Binary data the entire binary stream is encoded using the Base64 Alphabet in [RFC 2045].

This is exactly what the XmlDocument contains:

   1:  <?xml version="1.0" encoding="UTF-8"?>

   2:  <envelope>

   3:  <image> [the image encoded in a base64 value] </image>

   4:  </envelope>

How to create data types is explained on the Aif blog in a good article about creating custom Ax services. There you could implement the method “getSchema” of the interface “AifXmlSerializable”. The article explains you in detail how to do this and this would go too far for this article. Just keep in mind that communicating Xml-documents in a string is a ‘no do’ in a SOA environment and that there are better ways with Dynamics Ax.

The .Net client (Consuming the AIF-service)

The Wsdl, that is exposed by this new service, can now be referenced in a Visual Studio 2008 project as a Service Reference:

The GetXmlDocument method from the first example (using the BC.Net) is changed to consume a WebService:

   1:          /// <returns>The Xml-envelope with the image as content</returns>

   2:          private static XmlDocument GetXmlDocumentFromAif(string refDataAreaId,

   3:              int refTableId,

   4:              long refRecId)

   5:          {

   6:              XmlDocument xml = new XmlDocument();

7:

   8:              AifSampleImageServiceClient client = new AifSampleImageServiceClient();

   9:              string xmlImageValue = client.getImage(refDataAreaId, refRecId, refTableId);

  10:              xml = new System.Xml.XmlDocument();

  11:              xml.InnerXml = xmlImageValue;

12:

  13:              return xml;

  14:          }

Now the an event lets us consume get and unwrap the image and display in a PictureBox as in the first example. The method UnwrapImage is taken from the first example.

   1:          private void button8_Click(object sender, EventArgs e)

   2:          {

   3:              string refDataAreaId = "ceu";

   4:              int refTableId = 103;

   5:              long refRecId = 5637144576;

6:

   7:              XmlDocument xmlEnvelope =

   8:                  GetXmlDocument(refDataAreaId,

   9:                      refTableId,

  10:                      refRecId);

11:

  12:              Image content = UnwrapImage(xmlEnvelope);

13:

  14:              pictureBox1.Image = content;

  15:          }

Memory leaks and profiling with .Net

flo2005 — Wed, 04 Nov 2009 21:48:00 GMT

I wrote some moths ago an article about the GC and highlighted some particularities (unsafe and unmanaged code, disposing and finalizing, etc).

When you are developing with .Net you will be sometimes faced to memory or resource leaks. Especially if you are using the BC.Net, since the BC.Net is using unsafe and unmanaged code. But even with X++ you will be more and more faced to such problems. So it is very useful to know as much as possible about causes, identification and resolving.

Fabrice Marguerie (co-author of LINQ in Action) wrote a great article on MSDN (his blog entry for the trackback) about this subject. Enjoy this article!

IDynamicsAXExpressionBuilder returned error code 0x80131509 - reloaded

flo2005 — Thu, 20 Aug 2009 12:21:12 GMT

As I already wrote it in the update of that blog entry in my first posing about this issue:

The origin of this issue can be found in the method 'buildEnumerationXml' of the class 'SysExpression':

Currently, a loop iterates until the last element:
for (i = sysDictEnum.firstValue(); i <= sysDictEnum.lastValue(); i = sysDictEnum.nextValue(i)) 
I you replace this (sysDictEnum.lastValue(); ) by the number of elements (sysDictEnum.values();) the issue is solved.

[UPDATE 03/09/2009]

The hotfix for this bug has been published: KB974925 (Build: 5.0.1500.1255).