This chapter will explain some of the not-so-obvious features of the language and RTL that every Delphi programmer should know. Anonymous methods, enumerable types, extended RTTI, and class helpers are powerful tools for every Delphi developer, but usually they are not mastered as they should be. In this chapter, there are ready-to-use recipes that use these concepts to implement something really useful.

Since version 2009, the Delphi language (or better, its Object Pascal dialect) supports anonymous methods. What's an anonymous method? Not surprisingly, an anonymous method is a procedure or a function that does not have an associated name. An anonymous method treats a block of code just like a value so that it can be assigned to a variable, used as a parameter to a method, or returned by a function as its result value. In addition, an anonymous method can refer to variables and bind values to them in the context scope in which the anonymous method is defined. Anonymous methods are similar to closures defined in other languages, such as JavaScript or C#. An anonymous method type is declared as a reference to a function:

type 
  TFuncOfString = reference to function(S: String): String; 

Anonymous methods (or...

When the for...in loop was introduced in Delphi 2005, the concept of enumerable types was also introduced into the Delphi language.

As you know, there are some built-in enumerable types; however, you can create your own enumerable types using a very simple pattern.

To make your container enumerable, implement a single method called GetEnumerator, which must return a reference to an object, interface, or record that implements the following two methods and one property (in the example, the element to enumerate is TFoo):

function GetCurrent: TFoo; 
function MoveNext: Boolean; 
property Current: TFoo read GetCurrent; 

There are a lot of samples related to standard enumerable types, so in this recipe you'll look at some not-so-common utilizations...

Enumerable types, thanks to their versatility, are one of the most amazing language features in Delphi. In the previous recipe, we saw what they are and how they are used; now I want to introduce them in another way. They make the impossible possible as enumerables iterate over infinite ranges you need!

Did I stimulate your curiosity enough? Well, let's proceed!

Suppose you have to solve a Project Euler Problem 10 (https://projecteuler.net/problem=10); that is, to find the sum of all the primes below 2 million. How can you iterate through an infinite container like prime numbers?

Since Delphi 2010, the Delphi RTTI has been greatly expanded. Now, it is comparable to what is called reflection in other languages, such as C# or Java. A much-improved RTTI can dramatically change the way you write or even think about your code and your architecture. Now, it is possible to write highly flexible code without too much effort.

What we want to do in this recipe is to dynamically create a class by looking for it by name among the classes that have been linked in the executable (or loaded from dynamic packages). The goal is to change the behavior of the program using only an external file, without relying on a lot of parameters and complex...

Clear, isn't it? What may not be so clear is that this approach can also be used in computer programming. Yes, even without an actual duck!

Referring to duck typing, Wikipedia (http://en.wikipedia.org/wiki/Duck_typing) gives the following explanation :

What does Business Object (BO) mean?

If we fine-tune our applications, we are dealing with BOs—TCustomer, TOrder, and TInvoice are classic examples. In the end we always go to meet the same necessity: their validation; that is, to verify their validity through appropriate procedures. Regardless of whether you use an ORM, a data access framework such as FireDAC, or another, it is always a good idea to develop the BO layer to remain independent of them and respect separation of concerns (SoC).

In this recipe, we'll learn about RTTI Attributes, and we'll see how...

As you know (and if you don't know, you can read the documentation about it), a class helper is a type that can be associated to a class. When a class helper is associated with another class, all the methods and properties defined in the helper are also available in the other class and in its descendants. Helpers are a way to extend a class without using inheritance; however, it is not the same thing as inheritance. In other words, if the TFooHelper helper is in the same scope as TFoo, the compiler's resolution scope then becomes the original type (TFoo), plus the helper (TFooHelper). So, if the TFoo class defines the DoSomething method and the TFooHelper (the TFoo class helper) defines DoAnotherThing, when TFoo is used in the same scope as the TFooHelper, the TFoo instances, and all its descendants, also have the DoAnotherThing method...