Kernel functions exposed through BC.NET

BC.NET is a great feature of Dynamics AX. It allows to access the AX application from any external application that supports .NET, and provides a rather rich functionality out of the box.
But one feature that is missing in BC.NET is the ability to call AX kernel functions, like fieldId2Name, num2str, decRound, etc.

I needed to use these functions in my code recently, and in order to access them, I created a class in X++, that simply wraps the useful functions in static methods, kinda like the ones that exist in class Global.

Download Class_KernelFunctions.xpo

You need to import it into AX before using, of course. This can be automated, if you don't want to include this XPO as part of the package you deliver to your customers.

Now you can call it through the Business Connector the following way:

Axapta ax = new Axapta();            
ax.Logon("ext", null, "localhost", null);
// num2str(123.45, -1, 2, 1, 1);
Convert.ToDouble(ax.CallStaticClassMethod("KernelFunctions", "num2str", 123.45m, -1, 2, 1, 1));

TableBrowser.NET (a small .NET BC tutorial)

Here is a Visual Studio solution, demonstrating how the Dynamics AX database can be queried through the .NET Business Connector, and how the results of this can be presented to the user in a user-friendly manner.

Here is a screenshot of how it looks:


You can download the solution on axaptapedia.com.

The class to investigate in the solution is the DynamicsAX class. It provides a pretty good interface for reading data out of Dynamics AX.

After opening the solution, make sure to replace the BusinessConnectorNet.dll, pointing it to your AX installation path (if it is not in GAC)

Creating and Posting Inventory ProfitLoss journals in DAX using .NET Business Connector

Yesterday, I was helping a friend from Canada create a small solution that would create and post ProfitLoss journals in Microsoft Dynamics AX 4.0 using .NET Business Connector.

In the end, we created 2 solutions - one was entirely written in X++, and only simple class static method calls were made from C#. The other was completely written in C#, using various classes, available with .NET business connector.

I uploaded the solution to the following link, in case anyone would be interested to download it and play around with it or use in their projects.
Download ProfitLossPostingAppl

Also, here is the source code - it is a small console application, and I tried to add as many comments as possible, so that even complete X++ beginners would be able to easily read the code.

Notice that in the solution, there is a reference to the business connector dll.
You can find the Microsoft.Dynamics.BusinessConnectorNet.dll in the Client\Bin folder of your Dynamics AX installation. This dll is what provides you with access to the Dynamics AX application and the set of classes to use AX tables and classes.

using System;
using Microsoft.Dynamics.BusinessConnectorNet;

namespace ProfitLossPostingAppl
{
    class AxProfitLossPostingEngine
    {
        static void Main(string[] args)
        {
            Axapta ax = new Axapta();
            // company name, language, object server, configuration
            // this uses Windows Authentication
            ax.Logon("cmul", null, "localhost", null);
            
            try
            {
                // Start a transaction
                ax.TTSBegin();

                // AxaptaRecord is a class that allows to work with Tables in AX
                AxaptaRecord header = ax.CreateAxaptaRecord("InventJournalTable");
                AxaptaRecord journalName = ax.CreateAxaptaRecord("InventJournalName");
                AxaptaRecord line = ax.CreateAxaptaRecord("InventJournalTrans");
                AxaptaRecord inventTable = ax.CreateAxaptaRecord("InventTable");
                AxaptaRecord warehouse = ax.CreateAxaptaRecord("InventDim");

                // You can call static table methods using the following syntax
                journalName = ax.CallStaticRecordMethod("InventJournalName", "find", "IPL") as AxaptaRecord;

                // There is a set of predefined methods on the AxaptaRecord class, like the clear(), initValue, DML operations, etc.
                header.Clear();
                header.InitValue();
                // You can call table object methods as well, not only static
                header.Call("initFromInventJournalName", journalName);
                header.Insert();

                line.Clear();
                line.InitValue();
                line.Call("initFromInventJournalTable", header);
                // You cannot use table fields directly as in X++. Instead you have set/get methods
                line.set_Field("itemId", "B-R14");

                // Instead of using static table methods (like find) you can execute a direct SQL statement and receive the result in the AxaptaRecord object
                inventTable.ExecuteStmt("select * from %1 where %1.ItemId == 'B-R14'");
                // If you receive more that one record you can iterate through them using Next (as in AX)
                line.Call("initFromInventTable", inventTable);

                line.set_Field("Qty", 160.0);

                warehouse.Clear();
                warehouse.set_Field("InventLocationId", "MW");

                warehouse = ax.CallStaticRecordMethod("InventDim", "findOrCreate", warehouse) as AxaptaRecord;
                
                line.set_Field("InventDimId", warehouse.get_Field("inventDimId"));
                line.Insert();

                // Notice AxaptaRecord is passed by reference here
                ax.CallStaticRecordMethod("InventJournalTable", "initTotal", header);
                header.Update();

                ax.TTSCommit();
                
                // You can call static class methods the same way you call table static methods, but using a different method on Axapta class
                // So in case you wrote the posting in X++, you would be able to call it, passing the JournalId as the argument
                // int numOfLinesPosted = (int)ax.CallStaticClassMethod("DEV_ProfitLossEngine", "postProfitLossJournal", header.get_Field("JournalId"));
                
                // Or, you can use the AxaptaObject class to accomplish the same from C# 
                // You can initialize a new class using the Axapta class method
                // AxaptaObject journalCheckPost = ax.CreateAxaptaObject("InventJournalCheckPost");
                
                // Or using a static method, if that suites your needs better
                // Notice here that an object of type AxaptaRecord is passed into a method that expects InventJournalTable as the argument
                AxaptaObject journalCheckPost = ax.CallStaticClassMethod("InventJournalCheckPost", "newPostJournal", header) as AxaptaObject;
                // You can object methods the same way you would on a table
                journalCheckPost.Call("parmShowInfoResult", false);
                journalCheckPost.Call("parmThrowCheckFailed", true);
                journalCheckPost.Call("parmTransferErrors", false);
    
                journalCheckPost.Call("run");
                int numOfLinesPosted = (int)journalCheckPost.Call("numOfPostedLines");

                Console.WriteLine(String.Format("{0} line(s) have been successfully posted", numOfLinesPosted));
                Console.WriteLine("JournalId is " + header.get_Field("JournalId"));
                Console.WriteLine("Press any key to continue ...");

                ax.Logoff();
            }
            catch (Exception ex)
            {
                ax.TTSAbort();
                ax.Logoff();

                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }
    }
}

P.S. Of course, it would probably be a better idea to use classed InventJournalTableData, InventJournalTransData, etc.
But for the simplisity of the example, everything is done directly with tables.