Chris Rolliston - Delphi XE2 Foundations - Part 3

Copyright 2012 Chris Rolliston Updated 30 June 2012 Delphi is a trademark of Embarcadero Technologies. Windows is a trademark of Microsoft. Other trademarks are of the respective owners. The author makes no representation or warranties of any kind with regard to the completeness or accuracy of the contents herein and accepts no liability of any kind including but not limited to performance, merchantability, fitness for any particular purpose, or any losses or damages of any kind caused or alleged to be caused directly or indirectly from this book. Delphi is a complete software development environment for Windows, having its own language, libraries and RAD Studio IDE. Now in its XE2 incarnation, Delphi continues to evolve.

Most notably, XE2 supports writing applications for Mac OS X, an ability added in the context of numerous other extensions and improvements across recent releases. Centred upon XE2, this book aims to provide a comprehensive introduction to the fundamentals of Delphi programming as they stand today. A contemporary focus means it has been written on the assumption you are actually using the newest version. Since a traditional strength of Delphi is how new releases rarely require old code to be rewritten, much of the text will apply to older versions too. However, the book does not explicitly highlight what will and what will not. Conversely, a focus on fundamentals means a subject-matter of the Delphi language and wider runtime library (RTL).

Topics such as the RAD Studio IDE and Visual Component Library (VCL Delphis longstanding graphical user interface framework) are therefore covered only incidentally. Instead, coverage spans from basic language syntax the way Delphi code is structured and written in other words to the RTLs support for writing multithreaded code, in which a program performs multiple operations at the same time. If you are completely new to programming, this book is unlikely to be useful on its own. Nonetheless, it assumes little or no knowledge of Delphi specifically: taking an integrated approach, it tackles features that are new and not so new, basic and not so basic. In the process, it will describe in detail the nuts and bolts useful for almost any application you may come to write in Delphi.

Delphi XE2 Foundations is available in both printed and eBook versions.

In eBook form, it is split into three parts; the part you are reading now is part three. All parts share the same general introduction, but beyond that, their content differs.

The first chapter of both the complete book and part one of the eBook set gives an account of the basics of the Delphi language. This details the structure of a programs source code, an overview of the typing system, and the syntax for core language elements. The later parts of the chapter also discuss the mechanics of error handling and the syntax for using pointers, a relatively advanced technique but one that still has its place if used appropriately. Chapter two turns to consider simple types in more detail, covering numbers, enumerations and sets, along with how dates and times are handled in Delphi.

The third and fourth chapters look at classes and records, or in other words, Delphis support for object-oriented programming (OOP). Chapter three considers the basics, before chapter four moves on to slightly more advanced topics such as metaclasses and operator overloading.

The first chapter of part two chapter five of the complete book considers string handling in Delphi. It begins with the semantics of the string type itself, before providing a reference for the RTLs string manipulation functionality, including Delphis regular expressions (regex) support. Chapter six discusses arrays, collections and custom enumerators, providing a reference for the first and second, and some worked-through examples of the third. Chapter ten the first chapter of part three introduces packages, a Delphi-specific form of DLLs (Windows) or dylibs (OS X) that provide a convenient way of modularising a monolithic executable. Chapter ten the first chapter of part three introduces packages, a Delphi-specific form of DLLs (Windows) or dylibs (OS X) that provide a convenient way of modularising a monolithic executable.

The bulk of this chapter works through a FireMonkey example that cross compiles between Windows and OS X. Chapters eleven and twelve look at Delphis support for dynamic typing and reflection runtime-type information (RTTI) in the language of Delphi itself. The RTTI section is aimed primarily as a reference, however example usage scenarios are discussed. Chapter thirteen looks at how to interact with the native application programming interfaces (APIs). A particular focus is given to using the Delphi to Objective-C bridge for programming to OS Xs Cocoa API. Chapter fourteen looks at the basics of writing and using custom dynamic libraries (DLLs on Windows, dylibs on OS X), focussing on knobbly issues like how to exchange string data in a language independent fashion.

Examples are given of interacting with both Visual Basic for Applications (VBA) and C#/.NET clients. Finally, chapter fifteen discusses multithreaded programming in Delphi, with a particular focus on providing a reference for the threading primitives provided by the RTL. This is then put to use in the final section of the book, which works through a futures implementation based on a custom thread pool.

Unless otherwise indicated, the code snippets in this book will assume a console rather than GUI context. This is to focus upon the thing being demonstrated, avoiding the inevitable paraphernalia had by GUI-based demos. To try any code snippet out, you will therefore need to create a console application in the IDE.

If no other project is open, this can be done via the Tool Palette to the bottom right of the screen. Alternatively, you can use the main menu bar: select File|New|Other... , and choose Console Application from the Delphi Projects node. This will then generate a project file with contents looking like the following: program Project1; {$APPTYPE CONSOLE} {$R *.res} uses System.SysUtils; begintry{ TODO -oUser -cConsole Main : Insert code here }excepton E: Exception do Writeln(E.ClassName, ': ', E.Message); end; end. Unless the context indicates otherwise, the uses to the final end should be overwritten with the code snippet. By default, the console window will close when a debugged application finishes, preventing you from inspecting any output first.

To avoid this, you can amend the final part of the code added to look like the following: //code... Write('Press ENTER to exit...', ReadLn; end. Alternatively, you can add a breakpoint at the end of the source code. Do this by clicking in the leftmost part of gutter beside the end. : This will cause the IDE to regain control just before the program closes, allowing you to switch back to the console window to view the output.

Code for the more substantive examples in the book can be found in a Subversion repository hosted on Google Code. Code for the more substantive examples in the book can be found in a Subversion repository hosted on Google Code.

An easy way to download it is to use the RAD Studio IDE: 1. Choose File|Open From Version Control... from the main menu bar. 2. Enter http://delphi-foundations.googlecode.com/svn/trunk/ for the URL, and a local folder of your choosing for the destination.