Author Archive

Release Management – Customize timouts on default tools / actions

April 14th, 2014 No comments

In Release Management for Visual Studio 2013, you can customize your tools and actions to work with. The last few days I was creating a Release template for use with Dynamics AX 2012. One of the actions early in the template is backing up the database. ( Of course you need to backup first :-) ) And there I faced a little inconvenience: I could not adjust the timeout of the restore action but this was needed as an AX model store database restore could not be completed within 5 minutes.

So I decided to go back to the Restore SQL Database action and adjust the timeout setting. But hey, you are unable to do that on the default tool!


There is a parameter to setup default timeouts, but this only applies when creating new actions. So that doesn’t help a lot.


So for me, the most convenient and simple solution was to copy the tool that is available out of the box and create a new one from it. Then you do have the ability to set the timeout.




The given value of type String from the data source cannot be converted to type nvarchar of the specified target column.

March 17th, 2014 No comments

Today I experienced this problem while importing models from the build machine into one of the developer machines:

The given value of type String from the data source cannot be converted to type nvarchar of the specified target column.

A quick search on the internet took me to this blog post that explains the importance of initializing / updating your model store after installing CU’s. To initialize/update your model store you simply have to run the AxUtil with the schema command. (Alternative for powershell is Initialize-AXModelStore)

For a full list of AXUtil and PowerShell commands, please refer to MSDN.

Announcing Microsoft Dynamics AX 2012 R2 Services

March 5th, 2014 No comments

Hello everybody!

I’m very happy to announce Microsoft Dynamics AX 2012 R2 Services, published byPackt Publishing and authored by Klaas and myself. It is the successor of Microsoft Dynamics AX 2012 Services which was very well received. Based on the feedback you had and based on the new R2 version, we started working on an update in September 2013. We have gone through all existing content, updated and improved it, and added a lot of new content. We are really happy with the result and are excited to hear your reactions.

We are working hard on the book at the moment, the expected release date is May 2014 but you can already pre-order it.

There are also a couple of giveaways that can be won! More information can be found in the full blog post created by Klaas.


The Registry.CurrentUser impediment

February 19th, 2014 No comments

Today I was working on creating a build process template for AX2012. I will not go into the details about the build process template and the custom activities as these activities will be covered by Joris De Gruyter later on. But still, I wanted to show you guys a nasty little problem I was experiencing yesterday.

The build process threw an exception : ” Object reference not set to an instance of an object

So, this was of course a null reference, but after some investigation ( by using primitive logging because this was running in the agent process :-) ) it turned out to be located in this code:

public static string GetInstallDir32()
    RegistryKey componentsKey = Registry.CurrentUser.OpenSubKey(regKey, false);
    String installDir32 = componentsKey.GetValue("InstallDir32", null) as String;
    return System.Environment.ExpandEnvironmentVariables(installDir32);

It turned out to be the Registry.CurrentUser property that returned null. And then it struck me, the agent ran under a service account s_tfs_build and since this account was never used to log on interactively, the profile of this user was not loaded up to that point.

The simple solution was to log on to the system with the service account so that the user profile and registry hive were loaded. From then on, the Registry.CurrentUser property was properly filled.

Technical conference 2014 : Day two

February 5th, 2014 No comments

Today we were present early for the second day at the technical conference. The plan for today was to follow these sessions:

  • Data synchronisation between multiple instances using Master Data Services
  • optimizing the performance of an AX deployment
  • Compelling report designs
  • Help! MRP is slow

I could put all of my notes from today here, but there will be plenty of blog posts dealing with that today and I’ll just put in the fragments that I’ll really remember from today:

  • MDS
    • The master data services are using SQL  server and are working on an entity level to copy data between AX instances.
    • Change tracking is used but this does cause some overhead so pay attention to that and take steps to see if that is acceptable in your production environment.
  • Performance
    • Pay attention to your batch group setup when multi-threading your batch jobs. RunTimeTasks wille be created in your empty batchgroup if you do not specify the group via code!
    • Parameter sniffing
    • The rest was actually stuff that everyone should already know when working with Ax for a couple of years.
      Index optimization, recordset based operators, …
    • The 5 key points when looking at performance:
      • Few or many calls
      • Find where you lose time
      • Running or waiting : Find our where your code is waiting instead of running. Total elapsed time for SQL statements should be as close to the actual running time as possible.
      • 20 / 80 : With 20% of your effort, you can solve 80% of your performance problems.
      • 80 / 10 / 10: 80% is in your code, the 20% left is hardware en configuration.
  • Compelling report designs
    • TJ Vassar is by far the most interesting figure on stage the last few days! In 3 words: Chill, funny and honest :)
    • To be able to play around with your design and not having to run it from inside of AX to have the right data from your data provider, you can make your temporary table non-temporary, fill it with data and just switch over to Visual Studio entirely. Also do not forget to implement the processReport() method and comment out the super(). This is to make sure when running the report in SSRS, it is not processed within AX as long as you are working on your layout.
    • Microsoft really took the feedback to heart and fixed lots of issue concerning reporting. Including new tools for comparing reports.
    • Emailing parameters! A customization that lot’s of us have made is adding functionality to the print settings to be able to specify more and selecting email addresses from a dropdown. Well now it’s in the standard.

Technical conference 2014 : Day one

February 4th, 2014 No comments

I’m putting a blog post online today because yesterday the Wifi was really letting us down. But anyway, it turned out to be a very interesting day!


It all started out with what Microsoft is good at, giving presentations! The keynote was packed with content and demo’s so we were immediately excited to see some of the demo’s.

  • Professional services
    This demo showed a few new neat features when it comes to project management inside Dynamics AX
  • Retail
    This was a really nice demo! It was packed with new features and showed the new mobile experiences and nice demo’s on online shops.
    I was really impressed with all of the features available for retail.
  • Warehousing
    Another interesting demo was about the Blue Horseshoe warehousing solution. This really made me realize that all of the features I have been implementing the last 5 years were actually in there.
    There was a nice demo of the mobile app that lets you do stuff like picking, …
    Another nice addition here is the possibility to diable warehouse processes for certain inventory locations. Someone from the Blue Horseshoe guys even noted that they have eliminated the need for quarantine warehouses. There is an extra status now on the on hand inventory screen where you can specify that tis inventory cannot be used for other processes.

 A day in the life of a developer

The first actual session I attended was called “A day in the life of a developer / IT Manager”.

When I look at my scribbles, there’s a lot in there. But let me just mention a few key things that I noticed:

  • Trace parser
    Developers use the trace parser not enough when they are finished coding a feature. Being proactive means tracing your code to get out the obvious flaws.
  • LCS model upload
    We are using the feature in lifecycle services to upload the model for customization analysis. People should use that more often too.
    There is actually a HTML report available in the same format as the compiler output so developers can import that in AX to directly access the corresponding code.
  • Machines for building
    When devs check in there code, there should obviously be a build process that builds the code. For this, developers request hardware but this should be kept in mind when looking at the build performace:

    • Put all of the components on one box
    • Put in at least 16GB of RAM
    • Do not constraint the SQL memory
    • Install KB2844240 to optimize index performance optimizations
    • Request faster CPU’s first instead of more CPU’s
    • Install an SSD on the build machine
    • Use AxBuild.Exe :-)

Data export and Import Framework (DIXF)

The session about DIXF was also nice as a recap of what I already knew by working with DIXF at a customer site.

There were some interesting new features available in the R3 version:

  • Compare and copy data between companies (Only on entity level)
  • Copy entity data accross difference Microsoft Dynamics AX environments (Only on entity level)
  • MDM on top of DIXF
    Reuses DIXF for master data management (More in posts to come on this)
  • Out of the box support for 150+ entities
    • Master entities
    • Documents
    • Journals
    • Parameters
    • Reference data
    • Configuration data (EP Settings, Server Settings, Batch Settings, …)
  • Performance of staging to target
    There is support for parallel task bundling. Large files can be split up over several tasks.
  • There is a compare entity wizard that can compare entities between companies

Create AX Builds using the new server side compiler

For me, this was interesting because I have been playing around a lot with builds and the sessions turned out to be more like a Q&A session.

Firstly there was an explanation about how the compiler works. Roughly seen, there are 3 main parts:

  • Phase 1: Header compilation for tables and classes.
  • Phase 2: Complete X++ sources compiled into P-Code. Error log get created
  • Phase 3: Compile the error list. Here they did not actually managed that the number of passes depends on the errors. An number of error is incremented and as long are there are errors a new pass is tried. (Up to pass 5)

The important part here is that this is done on all of the tiers. The client performs the compilation and the communication goes all the way through the AOS to the SQL Database. But this has been solved and now the compilation is actually done on the server now. It is a 64bit compilation and X++ execution is kept to a minimum.

After the session, later on the evening, we met up with Robert Badawy which gave the sessions.  It was nice to have a chat with him and get his view on all of this and how Microsoft does the build process internally.

Cleaning up after AxBuild.exe

November 14th, 2013 9 comments

So the AxBuild.exe tool has been around for a couple of weeks now and imho this is the best addition that a CU brought until now.

There have been some nice post about how it works and what you should keep in mind:

Though the tool is fantastic, we noticed that after performing a compile we always needed some manual actions to get the error count to 0.
Due to the limitations of AxBuild we always had approximately 100 errors left after compiling. A lot of them were custom .Net assemblies that could not be referenced at compile time.

So here is what you normally do when performing a full compile now:

  • AxBuild your environment
  • Import the HTML compiler output
  • In the compiler windows, select create project to create a project with all of the objects that were still invalid
  • Compile the project inside the Ax client

Well, just to make it easier, I have created a little tool which does the last 3 actions at once so that we do not need to perform these things manually. (And enabling us to incorporate it in automated builds).

The idea is to have a startup command which I can use like this :

ax32.exe -startupCmd=importandcompileaxbuildlog_<Full path to the exported compiler log file>

Due to the nature of the (imho not so good) design of the startup commands, it is not possible to enter a file path with spaces in your command prompt. Also putting quotes around it wouldn’t help too.
Therefor I have used the ‘*’ sign and the startup command will replace the ‘*’ charaters with spaces. For example:

ax32.exe -startupCmd=importandcompileaxbuildlog_C:\Program Files\Microsoft*Dynamics*AX\60\Server\AX60R2\Log\AxCompileAll.html

If you want to try it yourself, you can find an XPO containing the code here.

AX2012 R2 Enterprise portal installation issues – Part 1

September 4th, 2013 No comments

The last few days I have been playing around with the Enterprise Portal. I needed to setup a High Available portal and there were soms discoveries along the road.

Though I’m planning on writing some other posts on the general architecture used when installing the Enterprise Portal in a HA environment and the possible installation issues you might have, I wanted to discuss one of the smaller issues encountered.

When opening the Enterprise Portal site, you can run into the following error:

c:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS\ep\EPSecurityControl.ascx.cs(13): error CS0234: The type or namespace name ‘AX’ does not exist in the namespace ‘Microsoft.Dynamics’ (are you missing an assembly reference?)

You can solve this by running the Ax installer for EP installation on all of the machines in the farm. When installing, uncheck all of the checkboxes to only install the binaries.

AX2012 DLL Deployment and how AX binds DLL’s at runtime

May 22nd, 2013 2 comments

In an earlier post I have showed how to use custom WPF controls with Dynamics AX 2012.

Well when using this type of fuctionality, you will often come into troubles when using it on other environments because of the corresponding DLL files not being deployed on their machine.

For that, you can use the automatic deployment feature of Ax when adding projects to the AOT. But it seems that there is an issue there. You can find lots of information on this post made by Joris De Gruyter:

And there is also information to be found here:

In short you have the following options to deploy your DLL files:

  • Automatic deployment feature of Visual Studio projects in the AOT
  • Using the SysFileDeployer framework (Joris mentioned an upcoming blog post on that, so that will be cool and interesting)
  • Copy them into the client\bin or server\bin directories
  • Use the Global Assembly Cache to store assemblies

While opinions might be devided, I tend to like the latter option. Simply because the GAC is intended to manage just that. Some of the benefits of the GAC:

  • No polution of the file system with DLL files being copied all around
  • Assemblies must be signed and the PublicKeyToken can be used to differentiate versions of your DLL file (Think of disallowing an assembly in production if it is coming from development environments and the wrong version was accidentally added)
  • Due to the previous fact, you can also have multiple versions of the same DLL file in your GAC.
  • GAC Redirection can be used to point to the right assembly if older versions are searched for

So let’s look back at the initial problem that I was facing. Dynamics AX threw up an error mentioning that it could not find the DLL file it needed. Strange because it was present in the GAC so it should always find it there.


Well to find out why it did not find the DLL I needed to check where AX was actually looking for it. And to do that you can use a .net framework tool called fuslogvw. This little helpfull tool is actually an assembly binding logging tool. So if DLL files are searched for, this little guy will give you the details about it.

So open up a Visual Studio Command Prompt and type fuslogvw and hit enter. First we need to do some minor setup to get it to log stuff. So go to Settings and select the log all binds to disk option. Then select a path to store the log in and you’re set to go.

Fuslogvw Settings

At that point I fired up the AX client and openened up the form that uses the assembly that appeared to be missing. Fuslogvw caught the information that is displayed below.


*** Assembly Binder Log Entry  (17/05/2013 @ 9:03:38) ***
The operation failed.
Bind result: hr = 0x80070002. The system cannot find the file specified.
Assembly manager loaded from:  C:\Windows\Microsoft.NET\Framework\v4.0.30319\clr.dll
Running under executable  C:\Program Files (x86)\Microsoft Dynamics AX\60\Client\Bin\Ax32.exe
--- A detailed error log follows. 
=== Pre-bind state information ===
LOG: User = EPS\lab rd wdpan59
LOG: DisplayName = EPS.AX.WPFControls, Version=, Culture=neutral, PublicKeyToken=null
LOG: Appbase = file:///C:/Program Files (x86)/Microsoft Dynamics AX/60/Client/Bin/
LOG: Initial PrivatePath = NULL
LOG: Dynamic Base = NULL
LOG: Cache Base = NULL
LOG: AppName = Ax32.exe
Calling assembly : Microsoft.Dynamics.AX.ManagedInterop, Version=, Culture=neutral, PublicKeyToken=31bf3856ad364e35.
LOG: This bind starts in default load context.
LOG: Using application configuration file: C:\Program Files (x86)\Microsoft Dynamics AX\60\Client\Bin\Ax32.exe.Config
LOG: Using host configuration file: 
LOG: Using machine configuration file from C:\Windows\Microsoft.NET\Framework\v4.0.30319\config\machine.config.
LOG: Policy not being applied to reference at this time (private, custom, partial, or location-based assembly bind).
LOG: The same bind was seen before, and was failed with hr = 0x80070002.
ERR: Unrecoverable error occurred during pre-download check (hr = 0x80070002).

The following line shows what was wrong at the time:

LOG: DisplayName = EPS.AX.WPFControls, Version=, Culture=neutral, PublicKeyToken=null

The assembly manager was actually looking for an unsigned version of my assembly in the GAC. But that version is not present since I had signed my assembly… So why was it looking for an unsigned version?? Well the answer to this was the order in which I had done things.

For development purposes I did the following in the exact same order:

  • Created a Visual Studio solution and added it to the AOT.
  • Added a ManagedHost control on a form and pointed out to the assembly that I needed. (Filedbased) (Until now an unsigned one)
  • When all was working well, I tried to do stuff the BP way and I signed my assembly and put it into the GAC.

As that seems to be enough, environments other than my machine were still facing the issue even though the DLL was in the GAC there too. And when looking at the ManagedHost control in AX, I saw that it was keeping a reference to the unsigned assembly and not the signed one!! So to solve it, you need to do things in a different order:

  • Create the Visual studio project.
  • Sign and build your assembly.
  • Add the solution to the AOT.
  • Add the ManagedHost control now and point to the assembly (that is now in your GAC already)

When this is done, you will have a reference in AX that also takes the right PublicKeyToken in to account and it works on the other machines also. To be sure I checked with fuslogvw again and this is the output.


*** Assembly Binder Log Entry  (17/05/2013 @ 9:03:42) ***
The operation was successful.
Bind result: hr = 0x0. The operation completed successfully.
Assembly manager loaded from:  C:\Windows\Microsoft.NET\Framework\v4.0.30319\clr.dll
Running under executable  C:\Program Files (x86)\Microsoft Dynamics AX\60\Client\Bin\Ax32.exe
--- A detailed error log follows. 
=== Pre-bind state information ===
LOG: User = EPS\lab rd wdpan59
LOG: DisplayName = EPS.AX.WPFControls, Version=, Culture=neutral, PublicKeyToken=14cd416a5dbff93c, processorArchitecture=x86
LOG: Appbase = file:///C:/Program Files (x86)/Microsoft Dynamics AX/60/Client/Bin/
LOG: Initial PrivatePath = NULL
LOG: Dynamic Base = NULL
LOG: Cache Base = NULL
LOG: AppName = Ax32.exe
Calling assembly : Microsoft.Dynamics.AX.ManagedInterop, Version=, Culture=neutral, PublicKeyToken=31bf3856ad364e35.
LOG: This bind starts in default load context.
LOG: Using application configuration file: C:\Program Files (x86)\Microsoft Dynamics AX\60\Client\Bin\Ax32.exe.Config
LOG: Using host configuration file: 
LOG: Using machine configuration file from C:\Windows\Microsoft.NET\Framework\v4.0.30319\config\machine.config.
LOG: Post-policy reference: EPS.AX.WPFControls, Version=, Culture=neutral, PublicKeyToken=14cd416a5dbff93c, processorArchitecture=x86
LOG: Found assembly by looking in the GAC.
LOG: Binding succeeds. Returns assembly from C:\Windows\Microsoft.Net\assembly\GAC_32\EPS.AX.WPFControls\v4.0_1.0.0.0__14cd416a5dbff93c\EPS.AX.WPFControls.dll.
LOG: Assembly is loaded in default load context.

And as we can see, Dynamics AX now takes the key into account and mentioned that it indeed found the assembly in the GAC.

LOG: DisplayName = EPS.AX.WPFControls, Version=, Culture=neutral, PublicKeyToken=14cd416a5dbff93c, processorArchitecture=x86

So for now, we have stored all the assemblies that we use in a folder on the network and every time there is a new version available, simple scripts are run to update the GAC and that is the only thing that needs to be done.



Hosting custom WPF calendar control in AX 2012

May 20th, 2013 No comments

The requirement

A couple of days ago, I needed to create a calendar like lookup but it had to be possible to block out dates for selection. In Dynamics AX, there is calendar lookup form available, but there are some minors to it:

  • It is not really (easy) customizable
  • It has limited functionality

What I needed the calendar form to do:

  • Visually block dates for selection
  • Easy navigation over longer periods
  • Support for different selection types (Single date, weeks, multiple selected dates, …)
  • Provide a custom range to display dates

So it is clear that Ax does not have a calendar like that, so I had the idea of creating a custom control for this. But due to time restriction ( isn’t there always a time restriction ! :-) ) I went looking for a WPF control that I could wrap around and integrate it with Ax. And then I found the following control that has all I need : But having a working control in a WPF application is one thing, getting it to work with Dynamics AX is another. I noticed when I was using the control directly, the client crashed and some of the properties were not marshallable because Dynamics AX does not support generics. So wrapping the control in a control of my own was an option here. And there are two reasons why I did wrap the control:

  • When using the control directly, it crashed :)
  • When wrapping into your own control, you can decide which of the features you want to be available and which are omitted
  • It is possible to write some helper methods for generic properties since Ax does not support generics

Now let me show you how to do it.

Creating a custom WPF user control

First start of by creating a custom WPF user control. Open up visual studio and create a new project of the type WPF User Control Library. NewProject Since we are going to implement the vhCalendat control, add a reference to the vhCalendar dll file. (Found in the CodeProject post link above). Once the reference is in place and before going into XAML mode, let us take a look at the code behind file and put some things in place.

Control definition

First we have a partial class that defines the CalendarViewControl. Extending this later with your own stuff should be easy since it is a partial. public partial class CalendarViewControl : UserControl, INotifyPropertyChanged

Control properties

Now lets add properties for all of the calendar’s properties that we want to expose. (Here I will not show them all, just some examples)

/// <summary>
/// Gets/Sets the date that is being displayed in the calendar
/// </summary>
public DateTime DisplayDate 
        return (DateTime)theCalendar.DisplayDate; 
        theCalendar.DisplayDate = value; 
/// <summary>
/// Gets/Sets animations are used
/// </summary>
public bool IsAnimated 
        return (bool)theCalendar.IsAnimated; 
        theCalendar.IsAnimated = value; 
/// <summary>
/// Gets/Sets the selection mode 
/// </summary>
public CalendarSelectionType SelectionMode 
        int i = (int)theCalendar.SelectionMode; 
        return (CalendarSelectionType)i; 
        int i = (int)theCalendar.SelectionMode; 
        theCalendar.SelectionMode = (SelectionType)i; 

The last property above shows a bit of ‘nasty’ code because I needed to translate the System.Windows.Visibility enum into a custom enum. This was because the CIL generator had a problem with the System.Windows.Visibility enum. CIL kept giving me the error : ‘Invalid cast’ until I used a custom enum.

Control events

Next to some properties, there are also a couple of events. The first one is to let Dynamics AX know that the selected date has changed.

public delegate void SelectedDateChangedEventHandler(object sender, EventArgs e); 
public event SelectedDateChangedEventHandler SelectedDateChanged; 
/// <summary>
/// Raised when the selected date changes in the calendar.
/// </summary>
public void RaiseSelectedDateChanged(object sender, vhCalendar.SelectedDateChangedEventArgs e) 
    if (SelectedDateChanged != null) 
        SelectedDateChanged(this, new EPSSelectedDateChangedEventArgs() { NewDate = e.NewDate, OldDate = e.OldDate }); 

Please note that the delegate is outside of the class but in the same namespace. Af of now, I’ve implemented single selection but there are also events in the calendar for when multiple selection changes.

Another important one is the RaisePropertyChanged event. This event will be useful to us when we are using binding in XAML. It will notify the control’s user interface that a property has changed and all of the UI elements that are bound to the corresponding property will be updated. (Note that the delegate PropertyChangedEventHandler is already known because our control implement INotifyPropertyChanged.

/// <summary>
/// Raised when one of the properties was changed in the WPF control
/// </summary>
public void RaisePropertyChanged(string propertyName) 
    if (PropertyChanged != null) 
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); 

Implement the control in Dynamics AX

Now for the AX part, start with creating a form with a ManagedHost control so that we can host the control. When you add the ManagedHost control, a windows will popup to select the control type that you want to use. In that window, select the reference to the dll (or browse for your dll) and select the type of control to use.


 Next we need a way to handle the events of the calencar control. When we choose a date in the control, we need to be notified in X++ so that we can do what we want with it.

To do that, you can right click the ManagedHost control and select events. In the events window, you can now select our selectedDateChanged event and add an X++ handler method to it.


  The following code was added to our form ( Note that you can also use the ManagedEventHandler class when you are consuming external services asynchronously! ):

_ManagedHost_Control = ManagedHost.control();
_ManagedHost_Control.add_SelectedDateChanged(new ManagedEventHandler(this, 'ManagedHost_SelectedDateChanged'));

So when we open our form and we select a date in the calendar, the ManagedHost_SelectedDateChanged method will be called. So let’s open up the form and see what it looks like.


Nice! But are we satisfied yet? Not quite…

Imho when implementing things like this, you should always keep in mind that others want to use your control in other contexts. Today I want to use it when selecting delivery dates but if we make some modifications, everyone can use this in any context they want.

What I did to achieve this is to create two things:

  • A property bag class that contains all of the properties that can be passed to the control.
  • An interface that forms need to implement when they want to host the control.

So first let’s take a look at the property bag. This is in fact merely a class with some parm methods on it. No PhD required here :)

/// <summary>
/// Data container class containing the parameters that can be set on the WPF control from inside Ax.
/// </summary>
public class EPSWPFCalendarParameters
    // Selection type of dates (single, multiple, ...)
    EPS.AX.WPFControls.CalendarSelectionType selectionType;
    // Start view of the calendar (month, year, decade, ...)
    EPS.AX.WPFControls.CalendarDisplayType displayType;
    // Date being displayed in the calendar
    System.DateTime displayDate;
    // Date from where the calendar displays dates
    System.DateTime displayDateStart;
    // Date to where the calendar displays dates
    System.DateTime displayDateEnd;
    // Use animation and transitions in the calendar
    boolean isAnimated;
    // Show the footer
    EPS.AX.WPFControls.CalendarVisibilityType footerVisibility;
    // Color the today's date in the calendar
    boolean isTodayHighlighted;
    // Show week columns
    EPS.AX.WPFControls.CalendarVisibilityType weekColumnVisibility;
    // Dates that will be marked as blocked and will not be selectable in the calendar
    Map blockedDatesList;

Apart from the parm methods, there is also an initialization method present so that some defaults are set in case they are not specified by the caller.

public void initDefaults()
    this.parmDisplayDate            (systemDateGet());
    this.parmDisplayType            (EPS.AX.WPFControls.CalendarDisplayType::Month);
    this.parmFooterVisibility       (EPS.AX.WPFControls.CalendarVisibilityType::Visible);
    this.parmIsAnimated             (true);
    this.parmIsTodayHighlighted     (true);
    this.parmSelectionType          (EPS.AX.WPFControls.CalendarSelectionType::Single);
    this.parmWeekColumnVisibility   (EPS.AX.WPFControls.CalendarVisibilityType::Visible);
    this.parmBlockedDatesList       (new Map(Types::Date, Types::Date));

Now for the next part, let’s create an interface that simply asures that forms hosting the control have a method to construct parameters for the calendar control.

/// <summary>
/// Interface for defining what is needed to be able to host the EPS WPF Calendar control on that form.
/// </summary>
public interface EPSWPFCalendarFormHostable { } 
/// <summary>
/// Calendar parameter data bag.
/// </summary>
/// <returns>
/// An instance of EPSWPFCalendarParameters 
/// </returns>
public EPSWPFCalendarParameters calendarParameters() 
{ }

This interface needs to be implemented on the caller form. Below we have an example of just that. (Note that for this example the code is on the form, but this should be done in a form handler class)

class FormRun extends ObjectRun implements EPSWPFCalendarFormHostable
/// <summary>
/// Contains parameters for the WPF calendar
/// <summary>
/// <returns>
/// An instance of EPSWPFCalendarParameters. 
/// </returns> 
public EPSWPFCalendarParameters calendarParameters() 
    // Create default instance of the parameters 
    calendarParameters = EPSWPFCalendarParameters::construct(); 
    // Set the calendar selection mode to a single date 
    // Set the default view to a month 
    // Passes a map of dates to be blocked for selection in the calendar
    return calendarParameters; 

For the last part, we need to glue these together. This is done in the form where we host the calendar control. When the form is called, it requests the calendar parameters from the caller and applies all of them to the control.

public void init()
    SysSetupFormRun formRun = element.args().caller();
    // Check if the managed host is even the right type
    if(ManagedHost.control() is EPS.AX.WPFControls.CalendarViewControl)
        calendarViewControl = ManagedHost.control() as EPS.AX.WPFControls.CalendarViewControl;
        throw error("@EPS6008");
    // Initialize from the caller interface (The caller should have implemented the interface that contains the calendarParameters)
    if(formHasMethod(formRun, 'calendarParameters'))
        hostable = element.args().caller();
        // The hostable should have the parameters defined
        calendarParameters = hostable.calendarParameters();
        // Initialize the calendar control based on the found parameters
        throw error("@EPS6009");
    // Register an event handler that attached to the selected date changed event of the calendar control)
    calendarViewControl.add_SelectedDateChanged(new ManagedEventHandler(this, 'ManagedHost_SelectedDateChanged'));

Note the formHasMethod call. This is an extra safety check. When using classes, the compiler makes sure that you have implemented the interface’s methods. But with forms, you never have a constructor called so that the compiler can do the check for you.

/// <summary>
/// Initializes the control based on the parameters found in the caller.
/// <summary>
private void initControlParameters() 
    Map blockedDates = calendarParameters.parmBlockedDatesList(); 
    MapEnumerator mapEnum; 
    TransDate fromDate; 
    TransDate toDate; 
    calendarViewControl.set_SelectionMode (calendarParameters.parmSelectionType()); 
    calendarViewControl.set_DisplayMode (calendarParameters.parmDisplayType()); 
    calendarViewControl.set_FooterVisibility (calendarParameters.parmFooterVisibility()); 
    calendarViewControl.set_IsAnimated (calendarParameters.parmIsAnimated()); 
    calendarViewControl.set_IsTodayHighlighted (calendarParameters.parmIsTodayHighlighted()); 
    calendarViewControl.set_WeekColumnVisibility (calendarParameters.parmWeekColumnVisibility()); 
        calendarViewControl.set_DisplayDate (calendarParameters.parmDisplayDate()); 
        calendarViewControl.set_DisplayDateStart (calendarParameters.parmDisplayDateStart()); 
        calendarViewControl.set_DisplayDateEnd (calendarParameters.parmDisplayDateEnd()); 
    // Pass the blocked out dates collection to the control. 
        mapEnum = blockedDates.getEnumerator(); 
        while (mapEnum.moveNext()) 
            fromDate = mapEnum.currentKey(); 
            toDate = mapEnum.currentValue(); 
            calendarViewControl.addBlockedDate(fromDate, toDate); 

So when all of this is in place, the calendar form calls the calling form and requests the parameters, passes them to the control and renders the control. Everyone that want to have the same control hosted on their for only need to implement the calendar parameters method on the form and that’s it.

When all is in place, this is what it looks like when the calendar has blocked days:



When clicking on the month title, you can easily navigate between months and years:





So that is the end of it. I hope you already have some ideas as to what controls you can now host within Dynamics AX 2012. It is possible to create your own, but you can host any other WPF control if you want. (Think of Infragistics controls, Telerik, …)