defer — limpeza junto de quem abre

program Defer;
// Demo: `defer` adia um comando até a saída do bloco atual.
// Várias saídas possíveis (fim normal, Exit, Continue, Break, exceção) -> a limpeza roda sempre.

// Os defers rodam em ordem inversa (LIFO): o último registrado roda primeiro.
// Isso casa com "abrir A, abrir B ... fechar B, fechar A".
procedure Process(AFail: Bool8);
begin
  WriteLn('abre recurso A');
  defer WriteLn('fecha recurso A');   // registrado primeiro, roda por último
  WriteLn('abre recurso B');
  defer WriteLn('fecha recurso B');   // registrado depois, roda primeiro
  if AFail then
    raise 'falhou no meio';           // mesmo com exceção, os dois defers rodam
  WriteLn('trabalho feito');
end procedure;

// O defer roda DEPOIS de Result ser gravado: o valor devolvido já foi decidido.
function Value: Int32;
var
  LValue: Int32;
begin
  LValue := 1;
  defer LValue := 99;                 // não altera o que Exit devolve
  Exit(LValue);
end function;

var
  I: Int32;
begin
  WriteLn('--- sem falha');
  Process(False);
  WriteLn('--- com falha');
  try
    Process(True);
  except
    on E: Exception do WriteLn('capturou: ', E.Message);
  end try;
  WriteLn('--- Result já gravado: ', Value);
  WriteLn('--- defer em laço (roda a cada volta, inclusive no Continue)');
  for I := 1 to 3 do
  begin
    defer WriteLn('  fim da volta ', I);
    if I = 2 then
      Continue;
    WriteLn('  volta ', I);
  end for;
end.

program Defer;
// Demo 36: defer - "faça isto quando o bloco terminar", junto de onde abriu.
//
// Em vez de separar "abrir" e "fechar" por dezenas de linhas (ou usar um
// try/finally aninhado para cada recurso), escreva o fechamento logo depois
// da abertura. Os defer rodam em ordem INVERSA (o último registrado roda
// primeiro) e rodam mesmo se uma exceção ou Exit interromper o bloco.

type
  TResource = class
  private
    FName: UString;
  public
    constructor Create(const AName: UString);
    destructor Destroy; override;
  end class;

constructor TResource.Create(const AName: UString);
begin
  FName := AName;
  WriteLn('  abriu ', FName);
end constructor;

destructor TResource.Destroy;
begin
  WriteLn('  fechou ', FName);
  inherited;
end destructor;

procedure Work(AFail: Bool8);
var
  LFile, LSocket: TResource;
begin
  WriteLn('início (falhar = ', AFail, ')');
  LFile := TResource.Create('arquivo');
  defer WriteLn('  defer 1: registrado primeiro, roda por último');
  LSocket := TResource.Create('conexão');
  defer WriteLn('  defer 2: registrado depois, roda primeiro');
  if AFail then
    raise 'algo deu errado no meio';
  WriteLn('  corpo terminou normalmente');
  // ao sair: primeiro rodam os defer (2, depois 1); só então as variáveis
  // locais são soltas e os objetos (ARC) fecham.
end procedure;

var
  I: Int32;
begin
  Work(False);
  try
    Work(True);
  except
    on E: Exception do WriteLn('capturou: ', E.Message);
  end try;

  // em laços, o defer roda ao fim de CADA volta (também com Continue/Break)
  for I := 1 to 3 do
  begin
    defer WriteLn('  fim da volta ', I);
    if I = 2 then
      Continue;
    WriteLn('volta ', I);
  end for;
end.