Delphi – class helper to add for … in support for TComponent.Components / ComponentCount

You might have discovered that I’m a fan of Delphi class helpers.

This is another case where I’d like to use the for … in statement: accessing the Components of a TComponent instance.

So I wanted to end up with this:

procedure MyForm.FormCreate(Sender: TObject);
var
  Component: TComponent;
begin
  for Component in Self do
  begin
  // business logic goes here
  end;
end;

in stead of this:

procedure MyForm.FormCreate(Sender: TObject);
var
  Component: TComponent;
  ComponentIndex: Integer;
begin
  for ComponentIndex := 0 to ComponentCount - 1 do
  begin
    Component := Components[ComponentIndex];
    // business logic goes here
    end;
  end;
end;

As the core explanation is in my post on Delphi – adding for … in support to TPageControl I’ll just explain the main difference compared to that post:

function TComponentEnumerator.MoveNext: Boolean;
begin
  Assert(FMaxValue = FComponent.ComponentCount - 1, 'ComponentCount changed during enumeration');
  // ...
end;

This extra assertion (which I forgot in the TPageControlEnumerator) is to protect against changes in the underlying components.

So this is the full code:

unit ComponentHelperUnit;

interface

uses
Classes;

type
TComponentEnumerator = class(TObject)
strict private
FMinValue: Integer;
FMaxValue: Integer;
FValue: Integer;
FComponent: TComponent;
public
constructor Create(const Component: TComponent);
function GetCurrent: TComponent;
function MoveNext: Boolean;
property Current: TComponent read GetCurrent;
end;

TComponentHelper = class helper for TComponent
public
function GetEnumerator: TComponentEnumerator;
end;

implementation

{ TComponentHelper }

function TComponentHelper.GetEnumerator: TComponentEnumerator;
begin
Result := TComponentEnumerator.Create(Self);
end;

{ TComponentEnumerator }

constructor TComponentEnumerator.Create(const Component: TComponent);
begin
Assert(Assigned(Component), ‘cannot enumerate nil FComponent’);

inherited Create();

Self.FComponent := Component;
FMinValue := 0;
FMaxValue := Component.ComponentCount – 1;
FValue := FMinValue – 1;
end;

function TComponentEnumerator.GetCurrent: TComponent;
begin
Result := FComponent.Components[FValue];
end;

function TComponentEnumerator.MoveNext: Boolean;
begin
Assert(FMaxValue = FComponent.ComponentCount – 1, ‘ComponentCount changed during enumeration’);
Inc(FValue);
Result := FValue <= FMaxValue; end; end. [/sourcecode] What you probably have guessed from my posts so far, is that I usually have small units. This is to keep myself focussed, and to make reuse easier. --jeroen