eu posteiuma pergunta alguns dias atrás, e as respostas me disseram para criar minhas próprias aulas.

Eu sou um programador old-school dos tempos pré-OOP minha programação é bem estruturada, eficiente e organizada, mas falta em qualquer OOPing personalizado que não seja usando Delphi e objetos de terceiros.

Eu tinha visto como as classes orientadas a objetos do Delphi funcionavam quando comecei a usar o Delphi 2, mas elas pareciam estranhas ao meu histórico de programação. Eu entendo como eles eram e são excelentes para desenvolvedores projetando componentes e para controles visuais na interface do usuário. Mas nunca achei a necessidade de usá-los na codificação do meu programa em si.

Então, agora eu olho novamente, 15 anos depois, nas aulas e no OOPing do Delphi. Se eu pegar, por exemplo, uma estrutura que tenho como:

type
  TPeopleIncluded = record
    IndiPtr: pointer;
    Relationship: string;
  end;
var
  PeopleIncluded: TList<TPeopleIncluded>;

Então um defensor da OOP provavelmente me dirá para fazer disso uma aula. Logicamente, eu pensaria que isso seria uma classe herdada do TList genérico. Eu acho que isso seria feito assim:

TPeopleIncluded<T: class> = class(TList<T>)

Mas é aí que fico preso e não tenho boas instruções sobre como fazer o resto.

Quando olho para alguma classe que o Delphi tem como exemplo na unidade Generics.Collections, vejo:

TObjectList<T: class> = class(TList<T>)
private
  FOwnsObjects: Boolean;
protected
  procedure Notify(const Value: T; Action: TCollectionNotification); override;
public
  constructor Create(AOwnsObjects: Boolean = True); overload;
  constructor Create(const AComparer: IComparer<T>; AOwnsObjects: Boolean = True); overload;
  constructor Create(Collection: TEnumerable<T>; AOwnsObjects: Boolean = True); overload;
  property OwnsObjects: Boolean read FOwnsObjects write FOwnsObjects;
end;

e então suas definições dos construtores e procedimentos são:

{ TObjectList<T> }

constructor TObjectList<T>.Create(AOwnsObjects: Boolean);
begin
  inherited;
  FOwnsObjects := AOwnsObjects;
end;

constructor TObjectList<T>.Create(const AComparer: IComparer<T>; AOwnsObjects: Boolean);
begin
  inherited Create(AComparer);
  FOwnsObjects := AOwnsObjects;
end;

constructor TObjectList<T>.Create(Collection: TEnumerable<T>; AOwnsObjects: Boolean);
begin
  inherited Create(Collection);
  FOwnsObjects := AOwnsObjects;
end;

procedure TObjectList<T>.Notify(const Value: T; Action: TCollectionNotification);
begin
  inherited;
  if OwnsObjects and (Action = cnRemoved) then
    Value.Free;
end;

Deixe-me dizer-lhe que esta definição de classe "simples" pode ser óbvia para aqueles que usaram OOP no Delphi durante anos, mas para mim isso só me fornece centenas de perguntas não respondidas sobre o que eu uso e como usá-lo .

Para mim, isso não parece ser uma ciência. Parece ser uma arte de como melhor estruturar suas informações em objetos.

Então essa pergunta, e eu espero que não seja fechada porque eu realmente preciso de ajuda com isso, é onde ou como eu obtenho as melhores instruções sobre como usar o Delphi para criar classes - e como fazê-lo da maneira apropriada do Delphi.