1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

var
  AutoFree: IAutoFree;
begin
  // ...
  ResultSet := ...;
  AutoFree := TAutoFree.Create(ResultSet)

  // work with ResultSet, is freed at the end of Method

end;					

1:
2:
3:
4:

type
  TMyObj = object
    // .... hier weiter fast wie bei einer Klasse
  end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

type
  TResRecord = record
    FResult: TDatenklasse;
    FAutoFree: IAutoFree;
  end;

function EineDatenbankabfrage: TResRecord;
begin
  Result.FResult := ... irgendwie zuweisen


  Result.FAutoFree := TAutoFree.Create(Result.FResRecord);
end;

var
  Res: TResRecord;
begin
  Res := EineDatenbankabfrage;
  // irgendwas mit dem Ergebnis in Res.FResult machen
end;
// hier endet die Gueltigkeit des Records Res und damit die
// des darin gespeicherten FAutoFree Interfaces, welches damit
// automatisch FResult freigibt.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:

type
  IAutoFree = IInterface;

  PAutoObj = ^TAutoObj;
  TAutoObj = object
  private
    FAutoFree: IAutoFree;
  public
    constructor Init;
    destructor Done; virtual;
  end;

  TObjAutofree = class(TInterfacedObject, IAutoFree)
  private
    FObj: PAutoObj;
  public
    constructor Create(_Obj: PAutoObj);
    destructor Destroy; override;
  end;

  TDatenObj = object(TAutoObj)
  private
    // Datenfelder hier
  public
    constructor Init;
    destructor Done; virtual; // ja, virtual, nicht override
    // Zugriffsmethoden hier
  end;

constructor TAutoObj.Init;
begin
  inherited Init;
  FAutoFree := TAutoFree.Create(@Self);
end;

destructor TAutoObj.Done;
begin
  // nix tun, aber virtual, damit er von TAutoFree aufgerufen werden kann
  inherited Done;
end; 

constructor TObjAutofree.Create(_Obj: PAutoObj);
begin
  inherited Create;
  FObj := _Obj;
end;

destructor TObjAutofree.Destroy;
begin
  FObj^.Done;
  inherited;
end;

constructor TDatenObj.Init;
begin
  // wichtig: Inherited Init aufrufen, sonst
  // wird FAutoFree nicht initialisiert!
  inherited Init;
end;

destructor TDatenObj.Done;
begin
  // irgendwelche Aufraeumarbeiten fuer die Felder
  inherited Done;
end;

// sonstige Methoden von TDatenObj

function EineDatenbankabfrage: TDatenObj;
begin
  Result.Init; // hier wird das FAutoFree Inteface erzeugt
  Result.Datenfeld1 := Datenbankwert;
  // usw.
end;

var
  Res: TDatenObj;
begin
  Res := EineDatenbankabfrage;
  // irgendwas mit dem Ergebnis in Res machen
end;
// hier endet die Gueltigkeit des Objeks Res (welches auf dem Stack liegt)
// und damit die des darin gespeicherten FAutoFree Interfaces, welches damit
// automatisch Res freigibt.					

1:
2:
3:
4:
5:
6:
7:
8:

var
  Obj: TDatenObj;
begin
  Obj.Init; // dies ist keine Objektreferenz sondern ein Objekt auf dem Stack!
  // ...
  FreeAndNil(Obj); // dies fuehrt nicht zu einem Compile Fehler aber
  // vermutlich zu einer Access Violation beim Ausfuehren.
end;