Rash thoughts about .NET, C#, F# and Dynamics NAV.

"Every solution will only lead to new problems."

Category Dynamics NAV 2009

In dieser Katergorie geht es um die neue Navision-Version Microsoft Dynamics NAV 2009 (Codename: Dynamics NAV “6.0”).

Monday, 12. May 2014

Weird floating point arithmetic in Dynamics NAV 2013 R2

Filed under: Dynamics NAV 2009,Dynamics NAV 2013,Navision — Steffen Forkmann at 13:42 Uhr

At the moment we are porting one of our products from Dynamics NAV 2009 R2 (Classic Client) to NAV 2013 R2. We have thousands of unit tests and most of them work out of the box.
But now my colleague Matthias Schäfer found a very strange issue. Consider this snippet:

On Dynamics NAV 2009 R2 Classic client (Build 6.00.33494) we get the same message twice:

Dynamics NAV 2009 R2

But on Dynamics NAV 2013 R2 (Build 7.10.36281) we get:

Dynamics NAV 2013 R2

Dynamics NAV 2013 R2

Weird, isn’t it?

Update 1

This is what the Dynamics NAV compiler is emitting:

We assume this is what the Dynamics NAV compiler should do:

Wednesday, 18. December 2013

Microsoft Dynamics NAV type provider

Filed under: Dynamics NAV 2009,Dynamics NAV 2013,F#,Navision — Steffen Forkmann at 14:34 Uhr

In earlier posts I showed how we can use F# type providers to access Dynamics NAV 2009 via Web Services and Dynamics NAV 2013 via OData. This time I want to point to a new type provider which allows Dynamics NAV data access directly via the SQL Server. The new type provider aims to be a replacement for C/Front.NET and gives a much nicer API.

alt text

It’s already available on nuget and has documentation with a “getting started guide”.

Tags: , ,

Friday, 5. April 2013

Stati-C/AL Supervision – blazing-fast static analysis for Microsoft Dynamics NAV

Filed under: Dynamics NAV 2009,Dynamics NAV 2013,F#,Navision — Steffen Forkmann at 17:26 Uhr

Until yesterday I thought I would be the only person on this planet who plays with a combination of F# and Dynamics NAV. Turned out I was wrong. Smiley

Christian Clausen and Bent Rasmussen created a really really cool static analysis tool for Dynamics NAV written in F#. For those who worked with the Dynamics NAV Developer’s Toolkit this is your new friend:


“Supervision is a free software program which can transform C/AL object text files into color-coded hyper-linked interactive HTML files.

The purpose of Supervision is to give Microsoft Dynamics NAV developers an easy and intuitive way to browse C/AL source code which provides better insight into the semantics of C/AL programs.”

[Project page]

Some of the features are:

  • Produces HTML/JavaScript code from Microsoft Dynamics NAV text export files
  • Usages of user-defined functions, variables, parameters, fields, system-defined variables, and object types link to their declaration
  • Usages of C/AL system functions link to official Microsoft C/AL language documentation
  • Code coloring
  • It’s blazing-fast Zwinkerndes Smiley

Check out the project page and watch the presentation at the Community for F# which gives some details about the implementation.

Tags: , ,

Friday, 4. January 2013

F# and Microsoft Dynamics NAV 2013 OData Services

Filed under: C#,Diverses,Dynamics NAV 2009,Dynamics NAV 2013,F#,Visual Studio — Steffen Forkmann at 13:52 Uhr

In my last post I described how we can access Dynamics NAV 2009 SOAP web services from F# and the benefits we get by using a type provder. Since version 2013 it’s also possible to expose NAV pages via OData. In this article I will show you how the OData type provider which is part of F# 3 can help you to easily access this data.

Exposing the data

First of all follow this walkthrough and expose the Customer Page from Microsoft Dynamics NAV 2013 as an OData feed.

Show the available companies

Let’s try to connect to the OData feed and list all available companies. Therefore we create a new F# console project (.NET 4.0) in Visual Studio 2012 and add references to FSharp.Data.TypeProviders and System.Data.Services.Client. With the following snippet we can access and print the company names:

As you can see we don’t need to use the “Add Service Reference” dialog. All service type are generated on the fly.

Access data within a company

Unfortunately Dynamics NAV 2013 seems to have a bug in the generated metadata. In order to access data within a company we need to apply a small trick. In the following sample we create a modified data context which points directly to a company:

Now we can start to access the data:

As you can see this approach is very easy and avoids the problem with the manual code generation. If you expose more pages then they are instantly available in your code.

As with the Wsdl type provider you can expose the generated types from this F# project for use in C# projects.

Further information:

Tags: , , ,

Thursday, 3. January 2013

F# and Microsoft Dynamics NAV 2009 Web Services

Filed under: C#,Dynamics NAV 2009,F#,Navision,Visual Studio,WCF — Steffen Forkmann at 9:25 Uhr

If you are a Dynamics NAV developer you have probably heared of the web services feature which comes with the 2009 version. In this walkthrough you can learn how to create and consume a Codeunit Web Service. This method works very well if you only need to create the C# proxy classes once. If you have more than one developer, an automated build system, changing web services or many web services then you will come to a point where this code generation system is very difficult to handle.

Microsoft Visual F# 3.0 comes with feature called “type providers” that helps to simplify your life in such a situation. For the case of WCF the Wsdl type provider allows us to automate the proxy generation. Let’s see how this works.

Web service generation

In the first step we create the Dynamics NAV 2009 Codeunit web service in exactly the same way as in the MSDN walkthrough.

Connecting to the web service

Now we create a new F# console project (.NET 4.0 or 4.5) in Visual Studio 2012 and add references to FSharp.Data.TypeProviders, System.Runtime.Serialization and System.ServiceModel. After this we are ready to use the Wsdl type provider:

At this point the type provider creates the proxy classes in the background – no “add web reference” dialog is needed. The only thing we need to do is configuring the access security and consume the webservice:

Access from C#

This is so much easier than the C# version from the walkthrough. But if you want you can still access the provided types from C#. Just add a new C# project to the solution and reference the F# project. In the F# project rename Program.fs to Services.fs and expose the service via a new function:

In the C# project you can now access the service like this:

Changing the service

Now let’s see what happens if we change the service. Go to the Letters Codeunit in Dynamics NAV 2009 and add a second parameter (allLetters:Boolean) to the Capitalize method. After saving the Codeunit go back to the C# project and try to compile it again. As you can see the changes are directly reflected as a compile error.

In the next blog post I will show you how you can easily access a Dynamics NAV 2013 OData feed from F#.

Tags: , , ,

Friday, 28. September 2012

NavTechDays 2012 Notizen Teil 2

Filed under: Dynamics NAV 2009,Navision,Veranstaltungen — Steffen Forkmann at 13:21 Uhr

Gestern habe ich schon den ersten Teil meiner Notizen hier auf dem Blog veröffentlicht. Jetzt geht es weiter mit Teil 2.


Microsoft hat den internen Prozess auf Scrum umgestellt und ich finde das merkt man wirklich. Es sind zwar nur zwei Tage Konferenz, aber das Produkt fühlt sich tatsächlich “fertig” an. Es ist interessant zu sehen wie eine so konservative Organisation wie NAV auf einen agilen Prozess umstellt. Ich bin gespannt was mit diesen ganzen Wasserfall-Tools wie SureStep und Co. passiert. Hier auf dieser Developer-Konferenz hat jedenfalls keiner davon geredet.

  • 20 Scrum Teams mit zweiwöchigen Sprints
  • Verwaltung der User Stories im TFS (Source Control irgendwo anders)
  • ATDD wird eingesetzt aber kein TDD
  • Umstellung auf Kanban steht jetzt bevor


  • OData Webservices aus NAV + Excel PowerPivot ist eine geniale Kombination für Auswertungen (Low Cost BI) – MSDN Walkthrough
  • OData ist im Moment nur read-only


  • Völlig überarbeitet.
  • Viel weniger Kopien der Dimensionen – nur noch über einen Schlüssel referenziert


  • Neuer Data Access Stack angeblich schneller als Classic Client.
  • FIND und FINDSET sind gleich schnell
  • SETCURRENTKEY macht Abfragen jetzt nur noch langsamer (da Sortierung) keinesfalls schneller
  • SQL Call Stack Traces – Blog post
  • Es sind keine Writes in die Object und Company Tabellen mehr möglich
  • Security Filters überarbeitet. Erlaubt es Nutzern nur gefilterte Datensätze zu zeigen.
    • Neue Optionen um Probleme mit indirekten Rechten zu lösen
    • Security Filter Feature kann im C/AL direkt an Record-Variablen konfiguriert werden
    • Security-Einstellungen zeigen sofort Wirkung. Keine manuelle Synchronisation der Nutzer oder Neustarts nötig
    • Standard App wurde noch nicht nach möglichen Security Filter Problemen durchforstet
    • Validated Mode sollte möglichst nicht benutzt werden, da es langsamer als die anderen Optionen ist

Locks und Blocks

  • Alle Slides und Samples sind auf Stryks Blog downloadbar
  • SQL Server Lock Escalation sollte vermieden werden -> „always rowlock” benutzen (jedoch nicht auf 32bit und unter 8GB RAM)
  • LOCKTABLE erhöht das Transaction Isolation Level auf Serializable
    • Über einen DB switch kann auf Repeatable Read umgestellt werden (Unterschied wie Tag und Nacht)
    • Das ist sowieso der Standard bei NAV2013
    • Es können zwar Phantom Reads entstehen, aber das sind Probleme die in der Praxis nicht existieren (“habe ich noch nie gesehen”)
  • Block und Dead Lock Detection Tool auf seinem Blog
  • Job Queue von NAV2013 kann auch in älteren Versionen nachgebaut werden
  • Beispiel 1: In Document Dimensions den Clustered SQL Index fixen – Document No.,  Document Type nach vorne -> weniger Blocks da die gelockten Zeilen näher beisammen sind
  • Beispiel 2: In Codeunit 80 und 90 gibt es ein globales Lock auf die „GL Entry“. Das wird auch ausgeführt wenn gar keine Sachbuchungen passieren. Lock mit PostToGL Flag fixen (bereits in NAV2013 gefixt)
  • Beispiel 3: In Tabelle 36 gibt es einen „Warehouse bug“ – Selbst wenn die Warehouse Tabelle leer ist wird die Tabelle gelockt. Generell sollte immer über ISEMPTY geprüft werden ob überhaupt Datensätze im Filter sind bevor man ein DELETEALL oder MODIFYALL durchführt
  • Beispiel 4: Reservation Entry.Lock() hat ein ähnliches Problem. Einfach am Anfang der Funktion prüfen ob die Tabelle leer ist. Wenn ja dann mit EXIT aus der Funktion springen
  • Beispiel 5: No. Series Line Tabelle ist „zu klein“ für das Lock und es werden mehr als eine Zeile gelockt. Folge: Wenn jemand eine Rechnung erzeugt kann ein anderer u.U. keine Artikel erzeugen. Lässt sich leicht mit Dummy Feldern fixen. 😉


  • Es gibt nur noch RDCL Reports
  • Classic Sections (und deren Trigger) fallen weg
  • Es gibt einen „Dataset designer“ als Ersatz für die Sections (analog Query designer)
  • Es wird nun RDLC 2008, Report Viewer 2010 und Visual Studio 2010 benutzt.
  • Reports erlauben „Save as Word“
  • “Heavy reports” über Background Session auf dem Server drucken (“Server side printing”)
  • Im Webclient gibt es “Preview” (nur IE) und „Save as PDF“ (alle Browser)
  • „Tray selection“ fixed – zusätzlich ein Codeunit 1 Trigger der es erlaubt die Papierfachsteuerung zu überschreiben
  • Upgrade Prozess
    • Hotfixes in NAV 5 und 6 erlauben Trigger in Codeunit 1 „OnBeforeRunReport“ (erlaubt zu zählen wie oft der Report tatsächlich genutzt wird)
    • Automatische Transformation hilft bei Upgrade von existieren NAV 2009 RDLC Reports (Tools/Upgrade Report)
    • Upgrade braucht ein technisches Upgrade auf NAV2013 als Zwischenschritt, da der Report kompilierbar sein muss um das Transformations-Tool zu benutzen
    • Automatisch vergebene Namen im Anschluss aufräumen
    • Doppelte Spalten entfernen
    • UI Guidelines auf MSDN befolgen
    • CreateTotals entfernen

Insgesamt war es ein sehr gute Veranstaltung mit vielen Informationen zu Dynamics NAV 2013. Vielen Dank an die Organisatoren und die Speaker.

Thursday, 27. September 2012

Notizen von den NavTechDays 2012 Teil 1

Filed under: Dynamics NAV 2009,Navision,Veranstaltungen — Steffen Forkmann at 14:04 Uhr

Microsoft Dynamics NAV 2013 wurde vorgestern released und so trifft es sich das gerade jetzt die NavTechDays 2012 in Antwerpen stattfinden. Hier meine Notizen nach fast einem Tag Konferenz.


  • Das NAV Menü ist bekanntermaßen sehr umfangreich -> NAV2013 hat jetzt eine Suche dafür
  • Der Classic Client heißt jetzt Development Environment und ist kein echter Client mehr. Da es keine Forms mehr gibt wird auch gern als „Retired Client“ bezeichnet.
  • Die Administration der Service Tiere kann nun vollständig über Powershell gescriptet werden. Das geht auch von remote.
  • Der Page Designer wurde deutlich verbessert und erlaubt nun eine „Live Preview“. Damit kann man die Änderungen direkt betrachten – ohne zu kompilieren und NAV neu zu starten.
    • Gruppen können eingeklappt werden
  • NAV2013 unterstützt OData
    • Erlaubt Query Objekte nach außen über Webservices zu veröffentlichen.
    • Gut für Anbindung von externen (Reporting) Tools
  • Der Windows client (ehemals RTC) wurde verbessert
    • Row styles feature erlaubt es Zeilen je nach Bedingung unterschiedlich zu färben
    • Neue Shortcuts (copy & paste, ….)
    • Grids erlauben es aus der automatischen Anordnung der Controls auszubrechen
    • Addins können .NET Events nutzen
  • „Rapid Start“ soll alle Einrichtungsvorgange vereinheitlichen
    • Fragebögen erstellen
    • Am Ende entsteht ein Package das auf andere Datenbanken angewendet werden kann -> Fragebögen werden angezeigt und Daten werden eingerichtet

Unit Testing

  • MS nutzt das Ding jetzt endlich selber (und zeigt es sogar in der Keynote)
  • Die Testing Features von NAV 2009 wurden nochmal gezeigt
    • Konvention: // *** hinter jede Zeile die Daten füllt, die für den eigentlichen Test unerheblich sind aber aus anderen Gründen gefüllt werden müssen
  • Die neuen „Page Testing“ features erlauben „Scripted UI testing“ durch den neuen Datentyp TestPage.
    • Erlaubt es Pages zu öffnen: myPage.OPENNEW;
    • Kann Daten füllen: myPage.MyField.SETVALUE(value)
    • Ermöglicht es Buttons zu drücken: myPage.MyAction.INVOKE;
    • Alle Parts (auch Subpages) können abgegriffen werden
    • Felder können auf Inhalt, Sichtbarkeit, Editierbarkeit usw. geprüft werden
    • „Page traps“: Registriert sich auf ein Page und wenn die geöffnet wird dann wird zurück in den Test gesprungen
  • Page Tests dauern länger als Unit Tests aber erlauben es aus Usersicht zu testen
  • “Test Isolation” Fführt ein Change tracking durch und setzt die Datenbank nach einem Test wieder in den Ausgangsstand zurück. Teardown Funktionen sind jetzt nicht mehr nötig. Das funktioniert selbst dann, wenn der zu testende Code ein Commit enthält. Wie geil ist das denn? Hammer!
  • Recorder zur Aufzeichnung von Page Tests ist in Planung.


  • Debugger ist in C/AL entwickelt und damit anpassbar. WTF?!
  • Erlaubt Remote NAS Debugging und zeigt den Code in C/AL an J
  • Alle Sessions können debuggt werden (auch noch nicht etablierte wie Webservice Sessions)
  • Sogar Endlosschleife können debuggt werden (ging mit altem Debugger natürlich nicht)
  • Conditional Breakpoints (z.B. nur anhalten wenn Variable > 10)
  • Man kann Breakpoints hinter das Ende von Funktionen setzen -> hält beim Verlassen der Funktion an. Egal welches EXIT genutzt wurde
  • Im Call Stack kann man auch in anderen Ebenen die Variablen inspizieren
  • „Debugger Breakpoint List“ erlaubt es die Breakpoints in Gruppen an und ab zu schalten
  • „Break on record changes“ erlaubt es bei jedem DB write anzuhalten.
  • Debugger hat Option um Codeunit 1 zu skippen
  • „Code Coverage“ Feature kann aus C/AL gestartet werden. Berührte Codezeilen können abgefragt und ausgewertet werden -> kommt ins Test Framework

Performance talk

  • Die Data Access Layer ist jetzt komplet neu in Managed Code geschrieben. Damit ist das Anlegen von Records jetzt deutlich schneller, da nicht zwischen C++ und .NET vermittelt werden muss.
    • Temp Records neu geschrieben. Haben jetzt selbe Sortierung wie normale Records.
    • Marked Records sind jetzt auch entsprechend richtig sortiert.
    • @-Operator funktioniert jetzt wieder richtig beim Filtern.
  • Query object
    • Erlaubt Joins (inner, outer,..) und Aggregations (sum, count, average)
    • Wird auf dem SQL Server ausgeführt -> Kein Netzwerktraffic zum NAV Server
    • Massive Performancegewinne möglich
    • Abgefragte Daten sind read-only -> aber dadurch kaum Locks
    • Programmiermodel analog wie Reports
    • Gut z.B. für alle Statistik Pages
    • Wird bereits in vielen Teilen des Standard genutzt
  • Background Sessions erlauben „Fire and Forget“-Tasks. Das funktioniert sogar in andere Mandanten.
    • Beispiel: Buch.-Blatt starten und die Buchungen werden asynchron auf dem Server ausgeführt. Der Client kann ganz normal weiter arbeiten. Wird bereits zum Buchen von Rechnungen verwendet.
    • Erzeugt allerdings eine komplett neue Session – samt Login usw.
    • Background Sessions kosten nichts für die Lizenz.
    • Die Tasks gehen in eine Job Queue. Die erlaubt dass die Tasks nicht alle parallel stattfinden. Durch diese Linearisierung gibt es weniger konkurrierende Locks.
  • CALCSUMS geht auch auf Feldern die nicht im SIFT sind. Wird dann auf dem SQL Server summiert -> schneller als manuelles Summieren auf dem NAV Server.
  • SETAUTOCALCFIELDS („Smart SQL“) ermöglicht es, dass FlowFields immer direkt beim Abrufen des eigentlichen Datensatzes mit abgerufen werden. -> Weniger Roundtrips zum SQL-Server.
    • Immer an bei Pages und Reports.
  • Connection Pooling zum SQL Server. Nur noch ein Account nötig. Das spart sehr viel Memory.
  • Data caching wurde verbessert. Jetzt werden Record API calls benutzerübergreifend gecached.
  • Security model wurde vereinfacht. „Synchronize all logins“ fällt weg, da Permissions nur noch im NAV Server geprüft werden.
  • Isolation Level wurde von SERIALIZABLE auf REPEATABLE READ geändert.
  • Locks wurden massiv reduziert bzw. es wird viel viel später gelockt (90% vs. 10% der Zeit beim Buchen)
  • Dimensionen wurden komplett überarbeitet (viel weniger Datensätze, weniger Writes).
  • „Buffered inserts“ werden jetzt viel öfter genutzt.
  • „SQL callstack trace“ erlaubt es heraus zu bekommen welche Codezeile ein bestimmtes (schlechtes) SQL statement erzeugt hat.
  • Es werden keine Cursors mehr für den SQL Server benutzt sondern Multiple Active Result Sets (MARS).
    • Folge: Kein SETCURRENTKEY mehr nutzen wenn man die Sortierung nicht braucht. (SETCURRENTKEY ist nur noch schlecht auf SQL Server da er sortieren muss.)

Morgen dann sicher mehr.

Wednesday, 10. November 2010

Dynamics NAV 2009 R2 Developer Day

Filed under: Dynamics NAV 2009,Veranstaltungen — Steffen Forkmann at 10:33 Uhr

Heute fand der “Dynamics NAV 2009 R2 Developer Day” statt. Bei diesem Event hat Microsoft mal wieder eine Konferenz in die Welt gestreamt. Da der Dynamics Bereich aber traditionell eher verschlossen ist, wurde der Stream nicht öffentlich gemacht, sondern nur in den jeweiligen Microsoft-Centern in 18 Ländern für eingeladene Partner gezeigt.

In diesem Blogpost verwalte ich meine eigenen Notizen zum Developer Day. Falls etwas zu knapp formuliert ist, kann gern über die Kommentare nachgefragt werden.

Als Release-Termin für Dynamics NAV 2009 R2 wurde der 15.12. angegeben.

What’s new in C/SIDE

Page Designer

  • Neuer Wizzard
  • Stärkerer Einsatz von Factboxes
  • “Strukturhighlighting” (= Gruppen werden fett dargestellt)

Go to Definition

  • Ctrl+F12 ==> Go to definition
  • Wenn die Definition nicht im selben Objekt ist, wird immer ein neues Designer-Fenster geöffnet, auch falls schon ein Fester des Objekts offen ist .
  • Momentan kein “Find References”

Multi-Developer Szenarien

  • Locking von Objekten
  • Öffnen von gelockten Objekten ist in Read-Only-Modus möglich
  • “Force unlock” ist für Superuser möglich
  • Meine Frage nach “Lock auch aus C/AL-Code” wurde mit Ja beantwortet.
  • Tools/Options/“Auto-lock on design”
    • Meine Frage nach “Auto-lock on first modification” wurde leider nicht beantwortet
How to use the application testability features
  • Vortrag war Low-Level-Einführung in automatisiertes Testen
  • Keine Verbesserungen zu NAV 2009 SP 1
    • also auch immer noch kein Mocking von Triggern
  • Jeder Test wird in eigener Transaktion durchgeführt
  • Code nach ASSERTERROR wird trotzdem ausgeführt
    • Transaktion wird jedoch zurück gerollt
  • Neues Application Test Toolset auf Partnersource (mit 226 Test Cases)
    • Meine Frage nach einer Erweiterung der Standardtestfunktionen wurde nicht beantwortet.
.NET Interoperability
  • Interop nur mit .NET 3.5 libs möglich
  • Nur auf NAV Server bzw. RTC
  • Anlegen von .NET Typen ist unglaublich umständlich
    • Warum schreibt man alle Typen in eine einzige Liste?
    • Keine einfache Möglichkeit über Namespaces zu browsen
  • Simple Datentypen (Double, Integer, Text) werden automatisch in ihre .NET-Entsprechungen gemappt
    • Options auf enums?
  • Format() mapped auf .ToString()
  • Achtung: Static classes werden über alle Client-Sessions geshared
  • NAV Scoping Regeln werden angewendet
    • Wenn lokale C/AL-Methode endet, wird das .NET Objekt disposed
    • Was ist mit Referenzen in noch lebenden .NET Objekten
  • .NET Variablen habe ein RunOnClient-Property
  • Deployment von Custom .NET Assemblies
    • Auf C/SIDE-Client für Development (Compile)
    • Auf die Tier wo der .NET Typ benutzt wird (siehe RunOnClient)
  • Client Warning bei erster Benutzung einer .NET Assembly
    • Keine Warnung bei SPN-Deployment
  • Kein try/catch/finally Exception handling
    • Exception wird als Textnachricht an den Client gesendet
  • Keine Events
Calling out to other Web Services from NAV

NAV Web Services

  • NAV 2009 SP1 führt Web Services immer in UTC-Zeit aus
  • NAV 2009 R2 führt WebServiceDefaultTimeZone ein (Default UTC)
  • Manuelles Change-Tracking immer noch nötig
  • Meine Frage nach “echtem” WCF noch unbeantwortet (aber Demo sah so aus)

Externe Web Services

  • Benutzt .NET Interop ==> Genauso wie in C#
  • Wenn WSL vorhanden, dann kann ein Proxy über svcutil erzeugt werden. Dieser muss dann als DLL auf den NAV Server deployed werden
  • Meine Frage nach asynchronem Aufruf wurde nicht beantwortet
    • Ich vermute unmöglich, da keine .NET Events unterstützt werden und ich noch keine Möglichkeit sehe Callbacks zurück ins NAV zu registrieren
    • Sicherlich möglich durch Publish eines Callback-Webservice (aber das ist irgend nicht schön)
CRM Integration
  • “Connector for Microsoft Dynamics“ für das Mapping
    • Hat NAV und CRM Adapter
    • Eigene 3-Tier-Applikation mit eigenem SQL-Server für Integrationsdaten
    • Integration ID – GUID hält NAV und CRM Datensatz zusammen
  • Neue Database Trigger in Codeunit 1 die IMMER bei INSERT, MODIFY, DELETE und RENAME feuern
  • Jede zu synchronisierende Tabelle muss auf NAV Seite als Page WebService veröffentlicht werden
  • Viele Synchronisationswege nur One-Way
    • Rechnungen sollten z.B. nur vom ERP-System verwaltet werden
  • Eindruck: Unglaublich kompliziertes System, da Mapping über Wizzard im Connector mit eigener kleiner Programmiersprache
    • Warum keine simple C# Projektvorlage mit ein paar Interfaces die man implementieren muss?
    • Warum extra SQL-Server-Instanz? Warum reicht nicht eine Message-Queue?
  • Backup und Restore muss zwischen allen 3 Datenbanken (NAV, CRM, Connector) synchronisiert werden
SSRS (RDLC) Reports in Microsoft Dynamics NAV 2009
  • Dataset kann refreshed werden ohne das Visual Studio geschlossen wird
  • Printer Selection funktioniert jetzt mit RTC über die Request Page
  • Transfooter und Transheader offenbar möglich (siehe http://blogs.msdn.com/nav)
  • Kein Druck auf dem NAV Server
    • Wie Archivierung von PDFs?
Developing Pages
  • Keine wirklichen Neuerungen in R2
Business Data Visualization Add-Ins for the RTC
  • Interessante neue Visualisierungsmöglichkeiten
    • Samples werden auf Beispiel-DVD mitgeliefert
    • Beispiel: Interaktive Zeitreihe
Ausblick auf Dynamics NAV 7
  • Forms Designer ist bereits ausgebaut – “There is no way back”
  • C/SIDE bleibt die Entwicklungsplattform – Keine Visual Studio Variante
    • Aussage in Hamburg: Entwicklung im RTC – Gezeigte Screenshots sagen etwas anderes
  • Offenbar integrierte Versionskontrolle geplant 😉
  • UI-Testing “könnte” kommen
  • .NET Interop mit Events
  • Rewrite vieler interner Funktionen um das .NET-Framework besser zu nutzen
    • Da es in NAV 7 keinen Classic-Client geben wird, ist dies auch problemlos möglich.
  • Keine Hybrid-Reports mehr. Entweder Classic Reports oder RDLC
    • 100% automatische Konvertierung in neuen Report Designer
Tags: , ,

Wednesday, 7. July 2010

Strange bug in Dynamics NAV client

Filed under: Dynamics NAV 2009,Navision — Steffen Forkmann at 7:34 Uhr

My colleague Mathias Meissner found a strange bug in the Dynamics NAV Client (occurs at least in the native clients for NAV 403, 501 and 601). It seems the following code creates a strange memory allocation issue. (Download sample)

OBJECT Codeunit 99500 NAV Bug
    Version List=;
            TestMiddleCase;  // comment this line out and ReverseString works!


    PROCEDURE TestMiddleCase@5128500();
      MiddleCase('fooo AnD bar');

    PROCEDURE TestReverseString@5128502();
      l_String@5128500 : Text[1024];
      l_Result@5128503 : Integer;
      l_String :=
        '1101101111011011110110111101101111011011110110111101101111011011' +
        '1101101111011011110110111101101111011011110110111101101111011011' +
        '1101101111011011110110111101101111011011110110111101101111011011' +
        '1101101111011011110110111101101111011011110110111101101111011011' +
        '1101101111011011110110111101101111011011110110111101101111011011' +
        '1101101111011011110110111101101111011011110110111101101111011011' +
        '1101101111011011110110111101101111011011110110111101101111011011' +

      IF STRLEN(l_String) <> 512 THEN
        ERROR('Wrong strlen');

      l_Result := TestReverseStringSub(l_String);

      IF l_Result <> 512 THEN
        ERROR('Error: Actual: ' + FORMAT(l_Result) + ' ' + ' Expected: 512');

    PROCEDURE TestReverseStringSub@5128521(p_String@5128500 : Text[1024]) r_Int : Integer;
      l_StringMgt@5128501 : Codeunit 5128519;
      p_String := ReverseString(p_String);

    PROCEDURE ReverseString@5128509(p_In@5128502 : Text[1024]) Result : Text[1024];
      i@5128500 : Integer;
      l_Length@5128501 : Integer;
      l_Length := STRLEN(p_In) + 1;

      FOR i := 1 TO l_Length - 1 DO
        Result[i] := p_In[l_Length-i];

    PROCEDURE MiddleCase@1000000000(p_StringToConvert@1000000000 : Text[250]) ConvertedString : Text[250];
      ConvertedString :=
        UPPERCASE(COPYSTR(p_StringToConvert, 1, 1)) +
        LOWERCASE(COPYSTR(p_StringToConvert, 2));


Since we don’t do anything evil here my only advice is to initialize every return parameter with a default value. This seems to fix the bug.

    PROCEDURE ReverseString@5128509(p_In@5128502 : Text[1024]) Result : Text[1024];
      i@5128500 : Integer;
      l_Length@5128501 : Integer;
      Result := ''; // Init return value – this fixes the issue!
      l_Length := STRLEN(p_In) + 1;

      FOR i := 1 TO l_Length - 1 DO
        Result[i] := p_In[l_Length-i];

Interestingly I didn’t find a smaller sample which reproduces this memory issue.

Tags: ,

Thursday, 5. March 2009

Sample chapter from "Implementing Microsoft Dynamics NAV 2009" published on Navision-blog.de

Filed under: C#,Dynamics NAV 2009,English posts,msu solutions GmbH,Visual Studio — Steffen Forkmann at 14:39 Uhr

Implementing Microsoft® Dynamics™ NAV 2009"Implementing Microsoft Dynamics NAV 2009" is a new book by David Roys (MVP for Dynamics NAV) and Vjekoslav Babic (Dynamics NAV consultant). It shows the new features of Dynamics NAV 2009 in step-by-step explanations of real-world examples.

If you are interested in this book you can read the complete seventh chapter right here on navision-blog.de:

Chapter 6 (“Modifying the System”) is also available for download.

What the book covers

Chapter 1

The purpose of this chapter is a teaser introduction to get you excited about the product, what’s in it in general, and what’s in it as compared to previous versions, to give you a little taste of what’s coming up in the book, and explain what the fuss about this new release is all about.

Chapter 2

The RoleTailored client is the new user interface for users of Microsoft Dynamics NAV 2009, and it is completely different to the pervious versions. We’ll take you through the different components of the interface, introduce the terminology, explore the navigation components and page types, and teach you how to personalize the application to meet your own requirements using the extensive personalization features.

Chapter 3

Microsoft Dynamics NAV 2009 introduces a new paradigm to ERP. Instead of the system being focused on the forms that capture and present data and the functions the user can perform, the system is based around the individuals within an organization, their roles, and the tasks they perform. We cover how Microsoft researched the roles and explore the departments, roles, and tasks that have been identified in the Microsoft Dynamics Customer Model. We also show the reader how to assign the standard roles to users, how to create new roles, and how to allow departmental super users to configure the application for their role so that the change is applied to all users with the same profile.

Chapter 4

Microsoft Dynamics NAV is not a product with a Next-Next-Finish type of installation, and it takes a lengthy project to deploy it successfully. We focus on the six phases of the implementation process, and explain each phase with detailed dos and don’ts for a typical implementation. Based on the Dynamics Sure Step implementation methodology with advice liberally sprinkled throughout, special attention is given to new features of Microsoft Dynamics NAV 2009, and where the new capabilities must be taken into account to make most out of the implementation project.

Chapter 5

Every implementation of Microsoft Dynamics NAV 2009 will require the system to be configured to meet the needs of the business. This chapter tells the implementation consultant how to do this from a core financials perspective and provides valuable information that will allow developers to understand more about the application they are changing. We cover basic accounting for programmers, dimensions, and posting groups, and how to use the Rapid Implementation Methodology (RIM) Toolkit to speed things along.

Chapter 6

Hardly any standard system can fit the needs of a business out of the box. Either the customer must shape their processes to match the system, or the consultant must shape the system to match the processes, and usually the latter prevails. This chapter explains the process of modifying the system, how to design a viable data model, and how to design and develop a functional user interface for both RoleTailored and Classic clients, without writing any code.

Chapter 7

The three-tiered architecture of Microsoft Dynamics NAV 2009 and native Web Services Enablement open up a whole new world of possibilities for NAV implementations. We cover some of the many possibilities for extending the application, allowing the consultant and developer to understand the technologies that are available and their respective design considerations. Our practical examples introduce the NAV programmer to the world of .NET and show how you can use the information available on the internet to develop your own killer .NET add-ons.

Chapter 8

There’s much more to development than programming. It starts with understanding what customer really needs, and usually extends way beyond the system being deployed to a test environment. This chapter focuses on the development phase, and what it takes to get from a concept to a live and working solution.

Chapter 9

After the system goes live, or as it grows, there are periods when new problems may arise, and often their source is far from obvious. This chapter explores the tools and techniques available for detecting problems, pinpointing the source, and helping to remove them from the system quickly and painlessly. It explains how to debug the Service Tier, how to troubleshoot performance issues, what can be done to avoid problems, and how proper planning before design can help to get it right the first time.

Chapter 10

Our sample application focuses on requirements gathering, functional specification creation, solution design, and the eventual build of a prototype. We look at how a business problem can be explored using techniques such as interviewing, use-case modeling, and object-role modeling to create a solution design that can be molded into a working prototype.

If you want to get more information about the book visit: http://www.packtpub.com/implementing-microsoft-dynamics-nav-2009/book

Tags: ,