This is not a book about the theory behind patterns; rather, this book focuses on the aspects of their implementation. Before I scare you all off with all this talk about design patterns, their history, modern advances, anti-patterns, and so on, I have decided to present a very simple pattern using an example. A few lines of code should explain why a pattern—based approach to problem solving can be a good thing.

In the code archive for this chapter, you'll find a simple console application called DesignPatternExample. Inside, you'll find an implementation of a sparse array, as shown in the following code fragment:

type
  TSparseRec = record
  IsEmpty: boolean;
  Value : integer;
end;

TSparseArray = TArray<TSparseRec>;

Each array index can either be empty (in which case IsEmpty will be set to True), or it can contain a value (in which case IsEmpty will be set to False and Value contains the value).

If we have a variable of the data: TSparseArraytype, we can iterate over it with the following code:

for i := Low(data) to High(data) do
  if not data[i].IsEmpty then
    Process(data[i].Value);

When you need a similar iteration in some other part of the program, you have to type this short fragment again. Of course, you could also be smart and just copy and paste the first two lines (for and if). This is simple but problematic, because it leads to the copy and paste anti-pattern, which I'll discuss later in this chapter.

For now, let's imagine the following hypothetical scenario. Let's say that at some point, you start introducing nullable types into this code. We already have ready to use nullable types available in the Spring4D library (https://bitbucket.org/sglienke/spring4d), and it was suggested that they will appear in the next major Delphi release after 10.2 Tokyo, so this is definitely something that could happen.

In Spring4D, nullable types are implemented as a Nullable<T> record, which is partially shown in the following code:

type
  Nullable<T> = record
    ...
    property HasValue: Boolean read GetHasValue;
    property Value: T read GetValue;
 end;

As far as we know, Delphi's implementation will expose the same properties: HasValue and Value. You can then redefine TSparseArray as an array of Nullable<integer>, as the following code:

type
  TSparseArray = TArray<Nullable<integer>>;

This is all well and good, but we now have to fix all the places in the code where IsEmpty is called and replace it with HasValue. We also have to change the program logic in all of these places. If the code was testing the result of IsEmpty, we would have to use not HasValue and vice versa. This is all very tedious and error prone. When making such a change in a big program, you can easily forget to insert or remove the not, and that breaks the program.

Wouldn't it be much better if there were only one place in the program when that for/if iteration construct was implemented? We would only have to correct code at that one location and— voila!—the program would be working again. Welcome to the Iterator pattern!

We'll discuss this pattern at length in Chapter 7,Iterator, Visitor, Observer, and Memento. For now, I will just give you a practical example.

The simplest way to add an iterator pattern to TScatteredArray is to use a method that accepts such an array and an iteration method, that is, a piece of code that is executed for each non empty element of the array. As the next code example shows, this is simple to achieve with Delphi's anonymous methods:

procedure Iterate(const data: TSparseArray; const iterator: TProc<integer>);
var
  i: Integer;
begin
  for i := Low(data) to High(data) do
  if not data[i].IsEmpty then
  iterator(data[i].Value);
end;

In this example, data is the sparse array that we want to array over, and iterator represents the anonymous method that will be executed for each non null element. The TProc<integer> notation specifies a procedure accepting one integer argument (TProc<T> is a type declared in System.SysUtils).

In the following code, we call Iterate and pass it the array to be iterated upon (data), and an anonymous method will be executed for each non empty element:

Iterate(data,
  procedure (value: integer)
  begin
    Process(value);
  end);

If we had to adapt this code to a nullable-based implementation, we would just edit the Iterate method and change not data[i].IsEmpty into data[i].HasValue—simple, effective, and, most importantly, foolproof!

Delphi also offers us a nice idiom that we can implement in an iterator pattern: enumerators and the for..in language construct. Using this idiom we can iterate over our sparse array with the following elegant code:

for value in data.Iterator do
  Process(value);

I will leave the implementation details for Chapter 7, Iterator, Visitor, Observer, and Memento. You are, of course, welcome to examine the demonstration project DesignPatternExample to see how data.Iterator is implemented (hint: start at TSparseArrayHelper).

var
  obj1, obj2: TObject;

obj1 := TObject.Create;
try
  // some code
finally
  FreeAndNil(obj1);
end;

obj1 := TObject.Create;
try
  obj2 := TObject.Create;
  try
    // some code
  finally
    FreeAndNil(obj2);
  end;
finally
  FreeAndNil(obj1);
end;

try
  obj1 := TObject.Create;
  obj2 := TObject.Create;
  // some code
finally
  FreeAndNil(obj1);
  FreeAndNil(obj2);
end;

try
  obj1 := TObject.Create;
  // some code
finally
  FreeAndNil(obj1);
end;

obj1 := nil;
try
  obj1 := TObject.Create;
  // some code
finally
  FreeAndNil(obj1);
end;

procedure TObject.Free;
begin
  if Self <> nil then
    Destroy;
end;

obj1 := nil;
obj2 := nil;
try
  obj1 := TObject.Create;
  obj2 := TObject.Create;
  // some code
finally
  FreeAndNil(obj1);
  FreeAndNil(obj2);
end;