Table of Contents | Delphi XE2 Foundations

Delphi XE2 Foundations by Chris Rolliston is organised into three parts, progressing from core language concepts through to advanced runtime-library topics. Each chapter builds on the material before it.

Delphi XE2 Foundations provides a thorough grounding in the Delphi language for developers working with Embarcadero's development environment. The book begins by establishing the fundamental building blocks of the language, covering identifiers, variables, constants, and the overall structure of a Delphi program. Readers are guided through essential programming concepts such as loops, conditionals, procedures, functions, and error handling from the outset. Memory management and pointers are also addressed early on, ensuring developers understand how Delphi handles resources under the hood. This structured approach to the language basics creates a solid platform for exploring more advanced topics later in the text.

The book progresses naturally into Delphi's type system, examining simple types in detail including enumerations, numbers, and date and time handling. Developers gain insight into how Delphi's strong typing system works with integers, floating-point numbers, and enumerated types that make code more readable and maintainable. Sets are another powerful feature explored in this section, allowing developers to work with collections of values in an efficient manner. Understanding these foundational type concepts is essential before moving on to more complex structures such as arrays, collections, and the object-oriented features that Delphi is known for in the development community.

Object-oriented programming forms a major pillar of the Delphi XE2 Foundations material, with dedicated coverage of classes and records. The book explains how Delphi's OOP implementation supports encapsulation, inheritance, and polymorphism through its class-based architecture. Records are also examined as lightweight data structures that offer some OOP capabilities without the overhead of full classes. String handling receives thorough treatment given its importance in application development, while arrays and collections provide the data structuring tools needed for real-world programming. Enumerators and basic console applications round out the practical skills developers need to begin building functional Delphi programs.

Advanced topics in the runtime library receive substantial attention in the later portions of the book, including streams, XML processing, and registry and INI file support. The coverage extends to runtime packages, which allow for modular application design and code sharing across projects. Type information and runtime type introspection are explored in depth, giving developers tools for working with types dynamically. Native API interfacing and library development are covered for those needing to integrate with system-level functionality or create reusable components. Multithreading support rounds out the advanced material, equipping developers to build responsive applications that leverage modern hardware capabilities.

Part One

Chapter 1 – Language Basics — What sort of language is Delphi? The basic structure of a Delphi program. Identifiers, typing, variables, constants, loops, conditionals, procedures, functions, units, error handling, pointers, and memory management.
Chapter 2 – Simple Types: Enumerations, Numbers and Date/Times — Enumerated types, sets, integers, floating-point types, dates, times, timings, and numerical conversions.
Chapter 3 – OOP Fundamentals — Classes and objects, inheritance, and polymorphism basics in Delphi.
Chapter 4 – Going Further with Classes and Records — Advanced class usage, record structures, and class methods.

Part Two

Chapter 5 – String Handling — The string type as a reference type, TStringBuilder, TStringList/TStrings, regular expressions, and advanced Unicode support.
Chapter 6 – Arrays, Collections and Enumerators — Array structures, collection types, and enumerators.
Chapter 7 – Basic I/O — Writing console applications and working with the file system.
Chapter 8 – Advanced I/O: Streams — Working with streams for flexible data input and output.

Part Three

Chapter 9 – ZIP, XML, Registry — Working with compressed archives, XML documents, and the Windows Registry.
Chapter 10 – Packages — Building and using Delphi packages.
Chapter 11 – Dynamic Typing and RTTI — Runtime type information and dynamic typing techniques.
Chapter 12 – Native APIs — Interfacing with native operating-system APIs from Delphi.
Chapter 13 – Dynamic Libraries — Creating and consuming DLLs.
Chapter 14 – Multithreading — Writing concurrent and parallel code in Delphi.
Chapter 15 – Putting It All Together — A capstone chapter drawing on techniques from across the book.

The book is available in printed and eBook editions. Individual chapter pages include detailed topic breakdowns for the first six chapters.