Home Page Icon
Home Page
Table of Contents for
Microsoft Dynamics NAV
Close
Microsoft Dynamics NAV
by Mark Brummel, Christopher Studebaker, David Studebaker, David Roys, Vjekoslav Ba
Microsoft Dynamics NAV
Microsoft Dynamics NAV
Table of Contents
Microsoft Dynamics NAV
Microsoft Dynamics NAV
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example code
Errata
Piracy
Questions
1. Module 1
1. Exploring Microsoft Dynamics NAV – An Introduction
Understanding Microsoft Dynamics NAV
The functional areas within Dynamics NAV
History of Dynamics NAV
Functional areas
Financial Management
General Ledger
G/L budgets
Account Schedules
Cash Management
Fixed Assets
VAT reporting and intrastat
Sales tax
Intercompany transactions
Consolidation
Multicurrency
Sales and marketing
Customers
Order processing
Approvals
Pricing
Marketing
Purchase
Vendors
Order processing
Approvals
Pricing
Planning
Warehouse
Items
Locations
Transfer orders
Assembly
Pick and put-away
Inventory
Manufacturing
Product design
Capacities
Planning
Execution
Costing
Subcontracting
Job
Job card
Phases and tasks
Planning
Time sheet
Invoice jobs
Work in process (WIP)
Resource planning
Resource card
Pricing
Service
Service items
Contracts
Price management
Service orders
Service tasks
Fault reporting
Human resources
Employees
Absence registration
Country localizations
Vertical and horizontal solutions
Accessing Dynamics NAV
Windows client
Web client
Tablet client
SharePoint client
Web Services
Development Environment
Summary
2. What's New in NAV 2016?
Application changes
Improvements for the application users
Cues with color indicator
Mandatory fields
Simplified user interface for small businesses
Tablet client
New application features
Automatic payment and bank reconciliation
Signing up for the Bank Data Conversion Service
Reconciling payments automatically
Reconciling bank statements automatically
Social Listening
Power Business Intelligence
RapidStart services
Schedule reports
E-mailing documents
Document exchange service (OCR Services)
Exchange rates update
Native integration with Dynamics CRM
Universal app
Workflow management
Posting Preview
Deferrals
Development changes
Document reporting
Upgrade automation – an overview
Upgrade automation – the application code
Upgrade automation – data
Enhancement in security and encryption
Changes to C/AL functions, data types, properties, and triggers
.NET interoperability
Enhancements in RoleTailored client control add-ins
IT changes
Dynamics NAV Server administration
Windows PowerShell cmdlets
Summary
3. Dynamics NAV – General Considerations
The data model
Master data
Documents
Journals
Entries
Creating ledger entries
Combining all concepts
No save button
The main advantage
When is the data verified?
The main drawback
The posting routines
Posted data cannot be modified (or deleted)
Navigating through your data
The Navigate functionality
Other ways to browse data
Sorting on list pages
Filtering for the data you need
Saving views for the filters you've set
Real-time data gathering – the SIFT technology
Everything leads to accounting
The Dynamics NAV database
The TableRelation property
Coded data rules
Summary
4. The Implementation Process – From the Reseller
What is an implementation?
Methodology
The Waterfall approach
The Agile approach
Using the best of both
Microsoft Dynamics Sure Step
Project types based on the Waterfall approach
The Rapid project type
The Standard project type
The Enterprise project type
The Upgrade project type
The Agile project type
Roles
Salesperson
Project manager
Business consultant
Key users
Analyst
Developer
Implementer
End users
Summarizing the roles
Phases
Presales
Getting the project requirements
Designing the solution
Configuration
Modifying standard Dynamics NAV functionality
New functionalities
Data migration
Development
Deployment
Software and hardware installation
Configuration
Data migration
User-acceptance test
End users' training
Go-live!
Post Implementation Support
Summary
5. The Implementation Process on the Customer Side
Definition of goals
Measuring goals
Defining the internal processes
Questions to be asked
Improve before automating
Getting the requirements
Change management
Get involved in testing the system
Involve end users
Summary
6. Migrating Data
Tools to migrate data
RapidStart Services
Creating a new company using PowerShell
Changing the profile to RapidStart Services Implementer
Using the configuration wizard
Creating a data conversion package
Creating a configuration package
Applying a configuration package
Configuration worksheet
Creating the migration structure
Copying related tables
Using Excel templates
Configuration templates
Creating a configuration template
Using configuration templates
Configuration questionnaire
Creating a configuration questionnaire
Completing the configuration questionnaire
Summarizing RapidStart Services
Using XMLports to migrate data
The XMLport structure
Running the XMLport
Writing code inside the XMLport
The document structure
Filling data not included in the XML file
Validation order may change our data
Writing your own tools
Converting data from the old system to Dynamics NAV's needs
Fields particular to Microsoft Dynamics NAV
Master data
Open entries
Customer entries
Vendor entries
Bank entries
Item entries
Fixed-asset entries
General Ledger balances
Historical data
Open documents
Choosing a go-live date
Going live at the beginning of the fiscal year
What cons do we have?
Going live in the middle of a fiscal year
Summary
7. Upgrading Microsoft Dynamics NAV
Upgrading philosophy
Upgrades prior to Dynamics NAV 2013
Upgrades from Dynamics NAV 2013 forward
Upgrading process checklist
Upgrading from 2013, 2013 R2, or 2015
Technical upgrade (converting the database)
Connecting the Dynamics NAV Server
Application code upgrade
Merging the code
Importing the merged code
Upgrading the application data
Automating upgrading using PowerShell
Upgrading from 2009, 2009 SP1, or 2009 R2
Upgrading the 2009 application code
Upgrading the 2009 data
Upgrading from 5.0 or 5.0 SP1
Upgrading the 5.0 application code
Upgrading the 5.0 data
Upgrading from 4.0, 4.0 SP1, 4.0 SP2, or 4.0 SP3
Upgrading the 4.0 application code
Upgrading the 4.0 data
Upgrading from 3.60 or 3.70
Upgrading the 3.60 or 3.70 application code
Upgrading the 3.60 or 3.70 data
Upgrading steps to NAV 2013
Preparing to upgrade
Migrating to SQL Server
Testing the database
Upgrading the application code
Getting object versions
Converting objects to the Dynamics NAV 2013 format
Carrying out customizations to the new version
Transforming forms to pages
Transforming reports
Upgrading the data
Upgrading tools
Upgrade toolkit
Text format upgrade
Form transformation
Report transformation
Upgrading hybrid reports
Upgrading classic reports
Comparing text tools
MergeTool
Downloading MergeTool
Installing MergeTool
Using MergeTool
Importing the old base version
Importing the old custom version
Importing the new base version
Comparing the old base and new base versions
Merging all versions
Exporting the new custom version
Importing the new custom version to a Dynamics NAV 2013 database
Summary
8. Development Considerations
Setup versus customization
Data model principles
Basic objects
Object elements
How tables are structured
Understanding table structures
Master tables
Secondary tables
Setup tables
Document tables
Entry tables
Journal tables
The final picture
The structure of pages
Understanding page structures
Role center pages
Card pages
List pages
Document pages
ListPart pages
Worksheet pages
ConfirmationDialog pages
NavigatePage pages
The posting process
The codeunit structure for sales posting
The codeunit structure for General Journal posting
Where to write customized code
Validating fields
Batch jobs
Formatting customized code
Summary
9. Functional Changes on Existing Implementations
General guidelines
What is a functional change?
The Requisition Worksheet
Fixed Assets
Item Tracking
Extending a customized functionality
Interactions with other functionalities
The Requisition Worksheet
Fixed Assets
Item Tracking
Creating a new item
Creating and posting a purchase order for the new item
Creating and posting a sales order for the new item
Turning on Item Tracking for the new item
Extending a customized functionality
Writing a to-do list to implement a change
The Requisition Worksheet
Fixed Assets
Item Tracking
Extending a customized functionality
Choosing the right time
The Requisition Worksheet
Fixed Assets
Item Tracking
Extending a customized functionality
Planning the change
The Requisition Worksheet
Fixed Assets
Item Tracking
Extending a customized functionality
Summary
10. Data Analysis and Reporting
Using filters and FlowFilters
Creating views
Statistics
Charts
The Show as Chart option
Adding charts to the Role Center page
Creating and configuring charts
Using reports
Finding reports
Running reports
Types of reports
List reports
Test reports
Posting reports
Transaction reports
Document reports
Report selection
Other reports
Account schedules
Analysis views
Understanding dimensions
Setting up new dimensions
Categorizing dimensions
Accessing dimensions
Creating an analysis view
Updating analysis views
Using analysis views
Analysis by dimensions
Analysis views as a source for account schedules
Extracting data
Sending data to Microsoft Office applications
Sending data to Microsoft Word
Sending data to Microsoft Excel
Extracting data through web services
Other ways to extract Dynamics NAV data
Understanding report development
Reports anatomy
Defining the dataset
Designing the visual layout
Summary
11. Debugging
The art of debugging
Debugging in Dynamics NAV 2016
Break Rules
Placing breakpoints
From the Object Designer
In the current statement of the debugger
Conditional breakpoint
Debugger Breakpoint List
Line-by-line execution
The Step Into option
The Step Over option
The Step Out option
The Continue option
The Call Stack FactBox
The Watches FactBox
Adding variables from the Debugger Variables List window
Adding variables from the code viewer
Summary
12. Popular Reporting Options with Microsoft Dynamics NAV
What is a query?
Query Designer
Defining our first query
Adding additional data to the query
Charts
Web services
External applications
Excel and PowerPivot
Power BI
Jet Reports Express
Downloading Jet Reports Express
Installing Jet Reports Express
Report pack for Jet Reports Express
Summary
2. Module 2
1. An Introduction to NAV 2015
NAV 2015 – an ERP system
Financial Management
Manufacturing
Supply Chain Management
Business Intelligence and reporting
Relationship Management
Human Resource management
Project Management
Significant changes in NAV 2015
Application changes
Client enhancements
Development tools
Other areas
A developer's overview of NAV 2015
NAV object types
The C/SIDE integrated development environment
Object Designer tool icons
The C/AL programming language
NAV object and system elements
NAV functional terminology
User interface
Hands-on development in NAV 2015
The NAV 2015 development exercise scenario
Getting started with application design
Application tables
Designing a simple table
Creating a simple table
Pages
Standard elements of pages
List pages
Card pages
Document pages
Journal/Worksheet pages
Creating a List page
Creating a Card page
Creating some sample data
Creating a List Report
Other NAV object types
Codeunits
Queries
MenuSuites
XMLports
Development backups and documentation
Summary
Review questions
2. Tables
An overview of tables
Components of a table
Naming a table
Table numbering
Table properties
Table triggers
Keys
SumIndexFields
Field Groups
Enhancing our sample application
Creating and modifying tables
Assigning a Table Relation property
Assigning an InitValue property
Adding a few activity-tracking tables
New tables for our WDTU project
New list pages for our WDTU project
Keys, SumIndexFields, and table relations in our examples
Secondary keys and SumIndexFields
Table relations
Modifying a standard table
Version list documentation
Types of tables
Fully Modifiable tables
Master
Journal
Template
Ledger
Reference tables
Register
Posted Document
Setup
Temporary
Content modifiable tables
System
Read-only tables
Virtual
Summary
Review questions
3. Data Types and Fields
Basic definitions
Fields
Field properties
Field triggers
Data structure examples
Field numbering
Field and Variable naming
Data types
Fundamental data types
Numeric data
String data
Date/Time data
Complex data types
Data structure
Objects
Automation
Input/Output
DateFormula
References and other data types
Data type usage
FieldClass property options
FieldClass – Normal
FieldClass – FlowField
FieldClass – FlowFilter
FlowFields and a FlowFilter for our application
Filtering
Experimenting with filters
Accessing filter controls
Development Environment filter access
Role Tailored Client filter access
Summary
Review questions
4. Pages – The Interactive Interface
Page design and structure overview
Page design guidelines
The NAV 2015 page structure
Types of pages
Role Center page
List page
Card page
Document page
FastTab
ListPlus page
Worksheet (Journal) page
ConfirmationDialog page
StandardDialog page
NavigatePage
Navigate page 344
Special pages
Request page
Departments page
Page parts
FactBox Area
CardParts and ListParts
Charts
Chart part
Chart Control Add-in
Page names
Page Designer
New Page Wizard
Page components
Page Triggers
Page properties
Page Preview tool
Inheritance
WDTU Page Enhancement – part 1
Page controls
Control types
Container controls
Group controls
Field controls
Page Part controls
Page control triggers
Bound and Unbound Pages
WDTU Page Enhancement – part 2
Page Actions
Page Action Types and Subtypes
Action Groups
Action properties
Navigation Pane Button actions
Actions Summary
Learning more
UX (User Experience) Guidelines
Creative plagiarism and patterns
Experimenting on our own
Experimentation
Summary
Review questions
5. Queries and Reports
Queries
Building a simple Query object
Query and Query component properties
Query properties
The DataItem properties
Column properties
Reports
What is a report?
Four NAV report designers
NAV report types
Report types summarized
Report naming
Report components – overview
Report structure
Report data overview
Report Layout overview
Report data flow
Report components – detail
C/SIDE Report properties
SQL Server Report Builder – Report properties
Report triggers
Request Page Properties
Request page triggers
DataItem properties
DataItem triggers
Creating a Report in NAV 2015
Learn by experimentation
Report building – phase 1
Report building – phase 2
Report building – phase 3
Modifying an existing report with Report Designer or Word
Runtime rendering
Inheritance
Interactive report capabilities
Interactive sorting
Interactive visible/not visible
Request page
Add a Request Page option
Processing-Only reports
Creative report plagiarism and patterns
Summary
Review questions
6. Introduction to C/SIDE and C/AL
Understanding C/SIDE
Object Designer
Starting a new object
Accessing the Table Designer
Accessing the Page Designer
Accessing the Report Dataset Designer
Accessing the Codeunit Designer
Query Designer
XMLport Designer
MenuSuite Designer
Object Designer Navigation
Exporting objects
Importing objects
Import Table object changes
Text objects
Some useful practices
Changing data definitions
Saving and compiling
Some C/AL naming conventions
Variables
C/AL Globals
C/AL Locals
Function local identifiers
Other local identifiers
Special working storage variables
Temporary tables
Arrays
Initialization
System-defined variables
C/SIDE programming
Non-modifiable functions
Modifiable functions
Custom functions
Create a function
C/AL syntax
Assignment and punctuation
Expressions
Operators
Arithmetic operators and functions
Boolean operators
Relational operators and functions
Precedence of operators
Frequently used C/AL functions
The MESSAGE function
The ERROR function
The CONFIRM function
The STRMENU function
Record functions
The SETCURRENTKEY function
The SETRANGE function
The SETFILTER function
GET function
FIND functions
FIND ([Which]) options and the SQL Server alternates
Conditional statements
The BEGIN–END compound statement
The IF–THEN–ELSE statement
Indenting code
Some simple coding modifications
Adding field validation to a table
Adding code to a report
Lay out the new Report Heading
Save and test
Lookup Related table data
Layout the new report body
Save and test
Handling User-entered report options
Defining the Request Page
Finishing the processing code
Test the completed report
Output to Excel
Summary
Review questions
7. Intermediate C/AL
C/AL Symbol Menu
Internal documentation
Validation functions
TESTFIELD
FIELDERROR
INIT
VALIDATE
Date and Time functions
TODAY, TIME, and CURRENTDATETIME functions
WORKDATE function
DATE2DMY function
DATE2DWY function
DMY2DATE and DWY2DATE functions
CALCDATE function
Data conversion and formatting functions
ROUND
FORMAT function
EVALUATE function
FlowField and SumIndexField functions
CALCFIELDS function
SETAUTOCALCFIELDS function
CALCSUMS function
CALCFIELDS and CALCSUMS comparison
Flow control
REPEAT-UNTIL
WHILE-DO
FOR-TO or FOR-DOWNTO
CASE-ELSE statement
WITH-DO statement
QUIT, BREAK, EXIT, and SKIP functions
QUIT function
BREAK function
EXIT function
SKIP function
Input and Output functions
NEXT function with FIND or FINDSET
INSERT function
MODIFY function
Rec and xRec
DELETE function
MODIFYALL function
DELETEALL function
Filtering
SETFILTER function
COPYFILTER and COPYFILTERS functions
GETFILTER and GETFILTERS functions
FILTERGROUP function
MARK function
CLEARMARKS function
MARKEDONLY function
RESET function
InterObject communication
Communication via data
Communication through function parameters
Communication via object calls
Enhancing the WDTU application
Modifying Table Fields
Add Validation logic
Playlist Header Validations
Creating the Playlist Subform page
Playlist Line Validations
Creating a function for our Factbox
Creating a Factbox page
Summary
Review questions
8. Advanced NAV Development Tools
NAV process flow
Initial setup and data preparation
Transaction entry
Testing and posting the Journal batch
Utilizing and maintaining the data
Data maintenance
Role Center pages
The Role Center structure
The Role Center activities page
Cue Groups and Cues
Cue source table
Cue Group Actions
System Part
Page Parts
Page Parts not visible
Page Part Charts
Page Parts for user data
The Navigation Pane and Action menus
Action Designer
Create a WDTU Role Center Ribbon
Promoted Actions Categories
Action Groups
Configuration/Personalization
The Navigation Pane
The Navigation Home Button
The Navigation Departments Button
Other Navigation Buttons
XMLports
XMLport components
XMLport properties
XMLport triggers
XMLport data lines
XMLport line properties
SourceType as Text
SourceType as Table
SourceType as Field
The Element or Attribute
NodeType of Element
NodeType of Attribute
XMLport line triggers
DataType as Text
DataType as Table
DataType as Field
XMLport Request Page
Web services
Exposing a web service
Publishing a web service
Enabling web services
Determining what was published
XMLport – a web services integration example for WDTU
Summary
Review questions
9. Successful Conclusions
Creating new C/AL routines
Callable functions
Codeunit 358 – Date FilterCalc
Codeunit 359 – Period Form Management
Codeunit 365 – Format Address
Codeunit 396 – NoSeriesManagement
Function models to review and use
Management codeunits
Multi-language system
Multi-currency system
Navigate
Modifying for Navigate
Debugging in NAV 2015
Text Exports of Objects
Dialog function debugging techniques
Debugging with MESSAGE and CONFIRM
Debugging with DIALOG
Debugging with text output
Debugging with ERROR
The NAV 2015 Debugger
Activating the Debugger
Attaching the Debugger to a Session
Creating Break Events
The Debugger window
Changing code while debugging
C/SIDE Test-driven development
Other Interfaces
Automation Controller
Linked Data Sources
NAV Application Server (NAS)
Client Add-ins
Client Add-in construction
WDTU Client Add-in
Client Add-in comments
Customizing Help
NAV development projects – general guidance
Knowledge is the key
Data-focused design
Defining the needed data views
Designing the data tables
Designing the user data access interface
Designing the data validation
Data design review and revision
Designing the posting processes
Designing the supporting processes
Double-check everything
Design for efficiency
Disk I/O
Locking
Updating and upgrading
Design for updating
Customization project recommendations
One change at a time
Testing
Database testing approaches
Testing in production
Using a testing database
Testing techniques
Deliverables
Finishing the project
Plan for upgrading
Benefits of upgrading
Coding considerations
Good documentation
Low-impact coding
Supporting material
Summary
Review questions
3. Module 3
1. Introducing Dynamics NAV Patterns and Software Architecture
What do we mean by 'patterns'?
Software design patterns
The Procedural software design patterns
Microsoft Dynamics NAV Design Patterns
The object-oriented patterns
Non-object-oriented patterns
The functional oriented patterns
Patterns elements and hierarchy
Architectural patterns
Design patterns
Structuring code
The coding standards
Anti-patterns
Code cloning
Legacy code
Upgradability
The upgrade frequency
Design patterns and upgrades
Delta files
Repeatability
Design patterns and repeatability
Lifecycle of a design pattern
Technology changes
Old habits die hard
New design patterns
Software architecture in Microsoft Dynamics NAV
Metadata
Building blocks
Table
Page
Report
Codeunit
Query
XMLPort
MenuSuite
Metadata
Flowfields
Flowfilters
Base application
Functional processes
Summary
2. Architectural Patterns
The Singleton Pattern
Technical description
Company-Initialize
Implementations
Examples
Enhancements
The Supplemental and Subsidiary Pattern
Technical description
Implementations
Examples
The Compound Pattern
Technical description
Implementation
Examples
The Rules Pattern
Technical description
Implementations
Examples
The Master Data Pattern
Technical description
Implementations
Examples
The Journal Template-Batch-Line Pattern
Technical description
The Journal Template table
The Journal Batch table
The Journal Line table
Recurring Journals
Pages
Codeunits
Implementations
Hierarchy
Journals as contracts
Examples
The Entry Pattern
Technical description
The Entry Table types
Historical entries
Temporary entries
Entries that can be deleted
Temporary tracking buckets
Implementations
Examples
Document Pattern
Technical description
The Header table
The Line table
Posting and archiving
Implementations
Examples
The Argument table
Technical description
Implementations
Summary
3. Design Patterns
The Entity State Pattern
Technical description
Setting the State
Testing the State
Implementations
Examples
The Select Pattern
Technical description
Implementations
Examples
The Number Series Pattern
Technical description
The Table reference field
Setup reference
C/AL functions and variables
Implementations
Examples
Address Integration Pattern
Technical description
Fields
Copying the address
Printing addresses
Implementations
Examples
Multi-Level Setup
Technical description
Implementations
Examples
Document History
Technical description
The naming conventions
Codeunit Structure
Test Near, Test Far
Do it
Clean up
An Example
TRANSFERFIELDS
Implementations
Examples
Copy Document Pattern
Technical description
Validation logic
Implementations
Examples
Job Queue Entry Pattern
Technical description
Preprocessing
Getting records
The Main function
Post-processing
Error handling
Implementations
Examples
Dismissible dialogs and save preferences
Technical description
Dismissible dialog
Implementations
Examples
Setup Update Pattern
Technical description
Restrictions
Implementations
Example
Model-View ViewModel Pattern
Technical description
Implementations
Examples
Summary
4. Building an Example Application Using Patterns
The design elements
The Pattern dependencies
Step one – Foundation
Example setup
Which Patterns to use
The implementation
The Multi-Level Setup Pattern
Step two – Master Data
Example Person
The Example Product
Number Series
Adding Setup fields
Adding variables
Adding the No. Series field
Code snippets
Entity State
Implementing the Address Integration Pattern
Step three – Journals & Entries
Creating your own Journal and Entry
Validation in Journals
Step four – Documents
Implementing a Document
Document history
Selecting a Pattern
Other Patterns
Posting
The ThrowErrorIfNoSelection function
The TestNear function
The TestFar function
The PostExampleOne/PostExampleTwo function
The PostExJnlLine function
The DeleteExampeDocument function
The layered model
Summary
5. Coding Best Practices
Coding guidelines
Code design
Variable capacity
The Cyclomatic Complexity
The function size
Using complex data types
Localizability
Date formulas
Code readability
Variable naming
Self-explaining
Suffix versus prefix
Approved abbreviations
Class-Method-Property
The Table as a class
A Codeunit as a method
Function libraries and interfaces
Natural Language Programming
Pitfalls
Bonus – debugging
Encapsulation
Override Functions
Façade
Hooks
Disabling the original source code
Predefined hooks
Variant variables
Managing DLL
Summary
6. Anti-patterns and Handling Legacy Code
Anti-patterns
Code cloning
Forking
Templating
Customizing
Exact match
Examples
Transaction mirroring
Code normalization and writing clean code
The Document type normalization
The small business application
The VAT and Sales Tax calculation
Avoiding code cloning
Boat anchors
Other anti-patterns and context
Programming language capabilities
Legacy code
Refactoring the C/AL Code
Refactoring tables
Renaming
Normalization
Code refactoring
Finding the process owner
Moving to Codeunit
Breaking down the code into functions
Encapsulating functions
Normalizing the code
The boy scout rule
Summary
7. Building Solutions Using Patterns
Building blocks
Applying Architectural Patterns
The application setup
Guests
Room
Season
Price
Reservation
Stay
Check-in
Check-out
Clean
Evaluation
Invoice
Creating the Table objects
Applying Design Patterns
The Bed and Breakfast setup
Bed and Breakfast season
Bed and Breakfast room
Bed and Breakfast price
Bed and Breakfast clean entry
Bed and Breakfast stay
Bed and Breakfast journal and entry
The Bed and Breakfast evaluation header and evaluation line
Defining the methods
Writing the Code and Link methods
Creating the cleaning entries
Refactoring
The new class members
The new function library
Room members
The room price calculation
Testing the application
Test isolation
Analyzing the results
Upgrading the application
Creating a Delta file
The steps of creating a Delta file
Inside the Delta file
Building our application
Building the result
Managing the source code
Creating the workspace
Setting up Visual Studio
Uploading the files
Summary
Bibliography
Index
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Microsoft Dynamics NAV
Next
Next Chapter
Microsoft Dynamics NAV
Microsoft Dynamics NAV
Implementing ERP Systems
A course in three modules
BIRMINGHAM - MUMBAI
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset