Ich habe geposteteine Frage vor ein paar Tagen und die Antworten sagten mir, meine eigenen Klassen zu erstellen.

Ich bin ein Programmierer der alten Schule aus der Zeit vor OOP. Meine Programmierung ist gut strukturiert, effizient und organisiert, aber es fehlt mir an jeglichem benutzerdefinierten OOP, außer der Verwendung von Delphi und Objekten von Drittanbietern.

Ich hatte mir angesehen, wie Delphis objektorientierte Klassen funktionieren, als ich mit Delphi 2 anfing, aber sie schienen meinem Programmierhintergrund fremd zu sein. Ich verstehe, wie sie für Entwickler, die Komponenten entwerfen, und für visuelle Kontrollen auf der Benutzeroberfläche ausgezeichnet waren und sind. Aber ich habe nie die Notwendigkeit gefunden, sie in der Codierung meines Programms selbst zu verwenden.

Jetzt, 15 Jahre später, schaue ich mir noch einmal Delphis Kurse und das OOPing an. Wenn ich zum Beispiel eine Struktur nehme, die ich habe, wie:

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

Dann wird mir ein OOP-Befürworter wahrscheinlich sagen, dass ich dies zu einer Klasse machen soll. Logischerweise würde ich annehmen, dass dies eine Klasse ist, die von der generischen TList geerbt wurde. Ich würde vermuten, dass dies so geschehen würde:

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

Aber da stecke ich fest und habe keine guten Anweisungen, wie ich den Rest machen soll.

Wenn ich mir eine Klasse ansehe, die Delphi als Beispiel in der Unit Generics.Collections hat, sehe ich:

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;

und dann sind ihre Definitionen der Konstruktoren und Prozeduren:

{ 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;

Lassen Sie mich Ihnen sagen, dass diese "einfache" Klassendefinition für diejenigen von Ihnen offensichtlich ist, die OOP in Delphi seit Jahren verwenden, aber für mich bietet sie nur Hunderte von unbeantworteten Fragen dazu, was ich verwende und wie ich es verwende .

Für mich scheint dies keine Wissenschaft zu sein. Es scheint eine Kunst zu sein, wie Sie Ihre Informationen am besten in Objekte strukturieren können.

Diese Frage, und ich hoffe, sie wird nicht geschlossen, weil ich dabei wirklich Hilfe brauche, ist, wo oder wie ich die beste Anleitung zum Erstellen von Klassen mit Delphi erhalte - und wie man es auf die richtige Delphi-Weise macht.