Microsoft Axapta Development III
Course 8419: Four days; Instructor-Led

• Object Oriented Analysis, Design and Programming

• Database Design and SQL

Please refer to the section Suggested reading to obtain references covering the subjects above.

It is required that students have completed:

• Development II: Introduction to X++

It is assumed that the student has been working with development in Microsoft Axapta and has gained some experience on the topics covered by Development I & II.

Student Materials

The student kit includes a comprehensive workbook and other necessary materials for this class.

The following is provided in the student kit:

• Development III: Advanced X++ Course Manual

Course Outline
Chapter 1: Development Environment and Tools

This chapter gives a comprehensive foundation for the use of the development environment and integrated tools.

Sections

Development environment

• Files (Client, Application, Server)

• Transfer of modifications to test environment

• AOS setup (Prefer development in 3-tier thin environment)

Application architecture

• X-references

• Application hierarchy browser

• MorphXPlorer

Performance/Monitoring

• Debugger

• System Monitoring

• Method Trace

• Development Warnings

• SQL Trace

• Query Time Limit

• Deadlocks

• Database Trace

• Code Profiler

Application upgrade

• Upgrade project

• Compare tool

Exercises

• Use the tools to analyze the structures of the standard application.

• Find the bottleneck in a specific function in the standard application

• Make an upgrade of a project containing a few modified application objects.

After completing this chapter, students will:

• Be able to make a transfer of modifications from the development environment to test or live environment

• Be able to browse, examine, analyze and understand the structures of the standard application

• Be able to use the monitoring tools and interpret the related reporting

• Understand the upgrade of modifications from one version or service pack to another version or service pack

Chapter 2: Fetch of Data

This chapter focuses on fetching of data from the database. The goal is to make optimal communication with the database with respect to performance. In addition, the student will have knowledge in why and how the use of temporary tables.

Sections

• Query (Structure, Properties)

• Cost based optimizer

• while select (Syntax, Qualifiers, Field lists, Join, Placeholders/Literals)

• Caching

• Locking

• Temporary tables

Exercises

• Build a query in the AOT and with X++

• Create a fetch using a query and a while select

• Improve performance by implementing display-method caching

• Reduction of locking

• Monitor the impact of the use of field list, aggregation and caching

• Use of multiple instances of a temporary table.

After completing this chapter students will be able to:

• Program optimal database access

• Understand the concept of literals and placeholders

• Understand the caching mechanisms in Microsoft Axapta

• Use temporary tables in classes, forms and reports

Chapter 3: Classes

This chapter will teach the student to be able to create and modify classes and methods, according to Best Practice using object oriented concepts.

Sections

Object Oriented implementation in Microsoft Axapta

Most important differences from the standard application and C#, VB.NET and Java examples

• Classdeclaration

• Variables

• Data members

• Methods (qualifiers, parameters and return value)

• Overriding/Overloading

• Access modifiers

• Types of Microsoft Axapta Classes (Examples in parenthesis)

Sections

Application classes

• Basic functionality (Dialog)

• Wrapping of general routines (NumberSequence)

• Form support classes (LedgerJournalEngine)

• Table "polymorphism" (SalesTableType)

• API to the modules (LedgerVoucher, CustVoucher)

• Batch processing (RunBase)

Kernel classes

• Tools (Binary, DialogBox, RecordSortedList)

• Application objects (FormDataSource, QueryBuildRange,..)

• Integration (COM, ODBC, IO)

• System classes (xApplication, xCompany, xInfo)

• Runbase framework

• Args-objects

•

Exercises

• Design an abstract class

• Design and implementation of an interface.

• Implementation of accessor methods

• Implementation of foundation classes

• Use of kernel classes to access metadata

• Implementation of exeption handling

• Design and implement a new class hierarchy using polymorphism.

• Create a new class using the Runbase-framework.

• Modify the class LedgerExchAdj to include a query and to initialize the query from the current selected account in the form.

After completing this chapter, students will be able to:

• Understand the implementation of the object oriented concept in Microsoft Axapta

• Create a new class according to Best Practice

• Understand and implement a solution using polymorphism

• Use the RunBase-framework to create new batch processes

• Transfer information using the args-object

Chapter 4: Forms

This chapter will teach the student how to create and modify advanced forms.

Sections

• Architecture

• AOT (general methods, datasource, design)

• Kernel classes and object model

• Properties

• Best practice (Initializing via args, Design, Validation / Modification)

• Placement of code (Priority: Table, Support class, Datasource, Design)

• Top ten methods to use

• Handles to the objects in forms

• Interaction between form and RunBase classes

• Queries. Synchronizing (Active/Passive), Joins, Modify by code (Filtering, Sorting, Aggregation)

• Special controls in short (ActiveX, List view, Table, Tree, Window)

• Special forms (Lookup, Wizard)

• Activate a form from X++ using ClassFactory

Exercises

• Modify the form with customer transactions to toggle between active and passive synchronizing.

• Create a form with ledger transactions to include dynamic modification of filtering.

• Modify the employee form to include a web browser control.

• Create a lookup form to select an item which includes a picture of the item.

After completing this chapter, students will be able to:

• Understand the structure of a form and the underlying kernel classes

• Make decisions of where to place the code

• Use the top-ten methods in forms

• Dynamically modify the fetch of data

Chapter 5: Reports

This chapter will teach the student how to fetch data into reports based on queries or X++ code.

Sections

• Architecture

• AOT (general methods, data sources, design)

• Kernel classes and object model

• Top ten methods to use

• Handles to the objects in reports

• The RunBaseReportStd framework

• Fetch data by Query and X++

• Templates / Autodesign / Design

• Use of temporary tables for consolidation

• Calculation on (sub)totals

• Report Wizard

Exercises

• Create a report using aggregate functions.

• Create a report using a temporary table to consolidate date from multiple sources.

• Create a report which dynamically modifies of some controls.

• Create a report with calculations on totals.

After completing this chapter, students will be able to:

• Understand the structure of a report and the underlying kernel classes

• Make decisions of where to place the code

• Implement a dialog using the RunBaseReportStd framework

• Understand the principles of fetching data in a reports

• Make dynamically changes to the design

• Use temporary tables for consolidation

Appendix A: Solutions

This Appendix contains all the answers to the chapter exercises, Test Your Knowledge, and Test Your Skills sections.