Entity metadata in a console application

Posted by on

There was a question in the Community forum about creating tables in an external databases that would match the schema of F&O data entities.

One of the possible approaches is generating SQL code for CREATE TABLE statement. The information about field names, types and such things would be taken from F&O metadata and we already have a nice API for this purpose.

Here is code for simple console application getting some of the necessary data:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Dynamics.AX.Metadata.MetaModel;
using Microsoft.Dynamics.AX.Metadata.Storage;
using Microsoft.Dynamics.AX.Metadata.Storage.Runtime;
 
namespace DataEntityFields
{
    public class Demo
    {
        public static void Main(string[] args)
        {
            var environment = Microsoft.Dynamics.ApplicationPlatform.Environment.EnvironmentFactory.GetApplicationEnvironment();
            var runtimeConfiguration = new RuntimeProviderConfiguration(environment.Aos.PackageDirectory);
            var metadataProvider = new MetadataProviderFactory().CreateRuntimeProviderWithExtensions(runtimeConfiguration);
 
            AxDataEntityView entity = metadataProvider.DataEntityViews.Read("VendVendorV2Entity");
 
            foreach (AxDataEntityViewMappedField entityField in entity.Fields.Where(f => f is AxDataEntityViewMappedField))
            {
                var datasource = FindDataSource(entity.ViewMetadata.DataSources, entityField.DataSource);
                if (datasource == null)
                {
                    continue;
                }
 
                AxTable table = metadataProvider.Tables.Read(datasource.Table);
                AxTableField field = table.Fields[entityField.DataField];
                AxTableFieldString stringField = field as AxTableFieldString;
                if (stringField != null)
                {
                    AxEdtString edt = null;
                    if (stringField.ExtendedDataType != "")
                    {
                        edt = metadataProvider.Edts.Read(stringField.ExtendedDataType) as AxEdtString;
                    }
 
                    int stringSize = edt?.StringSize ?? stringField.StringSize;
                    Console.WriteLine($"{entityField.Name} (String {stringSize})");
                }
            }
 
            Console.ReadLine();
        }
 
        private static AxQuerySimpleDataSource FindDataSource(IEnumerable<AxQuerySimpleDatasource> dataSources, string dataSourceName)
        {
            foreach (AxQuerySimpleDataSource ds in dataSources)
            {
                if (ds.Name == dataSourceName)
                {
                    return ds;
                }
 
                return FindDataSource(ds.DataSources, dataSourceName);
            }
 
            return null;
        }
    }
}

Note that it requires references to a few assemblies:

  • Microsoft.Dynamics.AX.Metadata.dll
  • Microsoft.Dynamics.AX.Metadata.Core.dll
  • Microsoft.Dynamics.AX.Metadata.Storage.dll
  • Microsoft.Dynamics.ApplicationPlatform.Environment.dll

Simple metadata query in Powershell (D365FO)

Posted by on

If I need to extra metadata of a D365FO application, my preferred way is the new metadata API. But sometimes the requirement is so simple that it’s sufficient to query source XML files directly.

For example, this all what’s needed to get a list of fields from a table (together with their types) and store it in a CSV file. It’s written in Powershell:

[xml]$xml = Get-Content $inputXmlFilePath
$xml.AxTable.Fields.AxTableField | select Name, ExtendedDataType, EnumType | Export-CSV $outputCsvFilePath -nti

It’s great for trivial cases like this. If I needed more details about fields or I had to take into account table extensions, for example, then the metadata API would be a better choice.

Finding display methods in D365FO

Posted by on

Somebody asked in the Community forum for examples of display methods in views in the standard D365FO application. It’s not necessary to remember any concrete examples – finding all such methods is very simple. The right tool for this purpose is Metadata search.

Open Metadata search (Visual Studio > Dynamics 365 > Metadata search) and put the following query to the search box on the top:

type:view,method property:"IsDisplay=True"

The first part (type:view,method) says that we’re interested in methods in views. The latter part (property:”IsDisplay=True”) makes sure that only method with the given property value are returned.

Colored tabs in Visual Studio

Posted by on

Do you have many tabs in Visual Studio with designers and code editors and do you struggle to make sense of them? It’s not surprising – we often work with many things at once and some elements even have same names (e.g. VendTable table and form), which means that tabs for them look identical.

Original view of tabs (no colors)

Wouldn’t it be great if, for example, tabs for tables had a different color than tabs for forms?

It can be done…

Open Visual Studio and go to Tools > Extensions and Updates. Switch to Online and find and install Productivity Power Tools.

Note that Power Tools contain many more features than just tab coloring. You probably want to review them and configure them as needed (which might also mean disabling some of them).

Open Tools > Options and switch to Productivity Power Tools > Custom Document Well. Uncheck Color tabs by project and tick Color tabs by regular expression.

Then go to Productivity Power Tools > Custom Document Well > Advanced and tick Use full document path for regular expression matching.

Then it’s time to define colors and rules for using them. The setup we’ve just done allows us to find patterns in paths of files used in tabs. For example, if I open VendTable table in the designer, the path (in my environment) is K:\AosService\PackagesLocalDirectory\ApplicationSuite\Foundation\AxTable\VendTable.xml. If I want to assign a color to all tabs with table designers, I can use a regular expression like .*\\AxTable\\.*. It finds paths containing \AxTable\.

This setup is done under Productivity Power Tools > Custom Document Well > Color Coding.

Here is an example of how we can use it.

Configuration of tab colors

Here I’ve decided to use different colors for designers and code editors. For example, a tab with table editor has a dark red color, while opening code for the table creates a tab with a lighter red color. The same is done for classes, just using green color instead of red.

This is what I can see in Visual Studio:

Colored tabs

Now I can clearly distinguish element types and if I remember my setup, I can even immediately say which tab is for which type.

By the way, I could also go to Custom Document Well options and set Place tabs on the Left to display tabs vertically:

Vertical tabs

If you prefer, you can set colors based on something else than element types. For example, you could use different colors for elements from different packages. You’re limited only by what information you can extract from file paths.

It works nicely in both Visual Studio 2015 and Visual Studio 2017. Unfortunately it’s not supported in Visual Studio 2019, although there seem to be ways how to get it working.

FormObservableLink works in data source extensions

Posted by on

FormObservableLink class is useful for refreshing display and edit methods in D365FO. You create an instance variable of FormObservableLink type in a form, initialize it and call its observe() method in display/edit methods that you need to refresh on demand. When the refresh is required, you call markChanged() method of FormObservableLink and the system will rerun the methods and display new values. You can find more details in AX 7. Display methods and Form Observability, for instance.

I wondered if I can do the same in a data source extension and I wasn’t really sure that it would work. But it does – and the implementation is virtually the same as when building a whole form.

Here is a simple example:

[ExtensionOf(formDataSourceStr(smmContactPerson, ContactPerson))]
final class MySmmContactPerson_ContactPersonDs_Extension
{
    // Declare and initalize FormObservableLink
    private FormObservableLink observableLink = new FormObservableLink();
 
    edit NoYes myMethod(boolean _set, ContactPerson _contactPerson, NoYes _newValue)
    {
        // This says that observableLink will be able to refresh myMethod()
        observableLink.observe();
        ...
    }
 
    void refreshMethodsWhenSomethingHappened()
    {
        // Here we trigger a refresh
        observableLink.markChanged();
    }
}