Setter mehrfach überschreiben.

[DeddyH]

Ableiten ginge auch, dann prüft man eben nicht, ob ein bestimmtes Interface imlpementiert, sondern ob das Objekt von einem bestimmten Klassentyp ist.

[Bjoerk]

Ich hab diese fürchterliche Basisklasse geschreddert (nicht nur gelöscht). Die bringt überhaupt nichts null nothing gar nichts. Ich habe 3 Kategorien von geometrischen Objekten, die ich eh immer abfragen muß?

Beispiel:

Delphi-Quellcode:

procedure TDrawPadProperties.SetProperties(Item: TWerkzeug0);
var
  Item1: TWerkzeug1;
  Item2: TWerkzeug2;
  Item3: TWerkzeug3;
begin
  SetProperties0(Item);
  if Item is TWerkzeug1 then
  begin
    Item1 := TWerkzeug1(Item);
    SetProperties1(Item1);
  end
  else
    if Item is TWerkzeug2 then
    begin
      Item2 := TWerkzeug2(Item);
      SetProperties2(Item2);
    end
    else
    begin
      Item3 := TWerkzeug3(Item);
      SetProperties3(Item3);
    end;
end;

[Mikkey]

Nö, so wird ein Schuh draus:

Delphi-Quellcode:

Procedure TWerkzeug0.SetProperties();
begin
    ...
end;

Procedure TWerkzeug1.SetProperties();
begin
    inherited SetProperties();
    ...
end;
...

Sonst baust Du ja die Logik nach, die Dir durch OOP zur Verfügung gestellt wird.

[Dejan Vu]

Wieso schreibst Du dir keinen WerkzeugPropertySetter und eine Factory, die Dir zu dem Werkzeug ('Item') die passende Klasse liefert, welche dann die Daten setzt. Wenn bei deinem Ansatz nämlich noch ein TWerkzeug4 hinzukommt, musst Du deinen Code anpassen, und das wäre dann so gar nicht OCP.

Delphi-Quellcode:

Type
  IWerkzeugPropertySetter = interface
    SetProperties(Item : TWerkzeug0);
  end;

procedure TDrawPadProperties.SetProperties(Item: TWerkzeug0);
var
  propertySetter : IWerkzeugPropertySetter;

begin
  propertySetter := WerkzeugPropertySetterFactory.Create(Item);
  propertySetter.SetProperties(Item);
end;

Leider musst Du in den einzelnen Setterklassen dann dein 'Item' immernoch konkret auf TWerkzeugX casten, aber da Du keine Generics benutzt, bleibt dir hier dann wohl nichts anderes übrig. Mit Generics würde das so aussehen (so ungefähr jedenfalls)

Delphi-Quellcode:

Type
  IWerkzeugPropertySetter<T : TWerkzeug0> = interface
    SetProperties(Item : T);
  end;

  WerkzeugPropertySetterFactory = class
    Function Create<T : TWerkzeug0> (Item : T) : IWerkzeugPropertySetter<T>;
  End;

procedure TDrawPadProperties.SetProperties<T:TWerkzeug0>(Item: T);
var
  propertySetter : IWerkzeugPropertySetter<T>;

begin
  propertySetter := WerkzeugPropertySetterFactory.Create<T>(Item);
  propertySetter.SetProperties(Item);
end;

Und das wäre dann typsicher. Wenn nun ein 4. Werkzeug hinzukommst, schreibst Du eine neue Klasse dafür und registrierest diese in der Factory.

[Bjoerk]

Weil der Typ TWerkzeug0 so was Ähnliches wie TCustomControl ist. Wirklich viel macht TWerkzeug0 noch nicht. Ich hab jetzt mal das vorbereitet. Ist an manchen Stellen eine Arbeitserleichterung. Wobei mich immer wundert daß man in Delphi "Bauer := TDame.Create" machen kann.

Delphi-Quellcode:

  TWerkzeugFactory = class
  private
    FTyp: TGraphicTyp;
    FWerkzeug: TWerkzeug0;
    procedure SetTyp(const Value: TGraphicTyp);
    procedure DoCreate;
    procedure DoDestroy;
    function GetWerkzeug1: TWerkzeug1;
    function GetWerkzeug2: TWerkzeug2;
    function GetWerkzeug3: TWerkzeug3;
    function GetIsWerkzeug1: boolean;
    function GetIsWerkzeug2: boolean;
    function GetIsWerkzeug3: boolean;
  public
    property Typ: TGraphicTyp read FTyp write SetTyp;
    property Werkzeug: TWerkzeug0 read FWerkzeug;
    property Werkzeug1: TWerkzeug1 read GetWerkzeug1;
    property Werkzeug2: TWerkzeug2 read GetWerkzeug2;
    property Werkzeug3: TWerkzeug3 read GetWerkzeug3;
    property IsWerkzeug1: boolean read GetIsWerkzeug1;
    property IsWerkzeug2: boolean read GetIsWerkzeug2;
    property IsWerkzeug3: boolean read GetIsWerkzeug3;
    destructor Destroy; override;
  end;

{ TWerkzeugFactory }

destructor TWerkzeugFactory.Destroy;
begin
  DoDestroy;
  inherited;
end;

procedure TWerkzeugFactory.DoCreate;
begin
  if Util_IsWerkzeug1(FTyp) then
    FWerkzeug := TWerkzeug1.Create
  else
    if Util_IsWerkzeug2(FTyp) then
      FWerkzeug := TWerkzeug2.Create
    else
      if Util_IsWerkzeug3(FTyp) then
        FWerkzeug := TWerkzeug3.Create
      else
        FWerkzeug := TWerkzeug0.Create;
end;

procedure TWerkzeugFactory.DoDestroy;
begin
  if Assigned(FWerkzeug) then
  begin
    FWerkzeug.Free;
    FWerkzeug := nil;
  end;
end;

procedure TWerkzeugFactory.SetTyp(const Value: TGraphicTyp);
begin
  DoDestroy;
  FTyp := Value;
  DoCreate;
end;

function TWerkzeugFactory.GetIsWerkzeug1: boolean;
begin
  Result := FWerkzeug is TWerkzeug1;
end;

function TWerkzeugFactory.GetIsWerkzeug2: boolean;
begin
  Result := FWerkzeug is TWerkzeug2;
end;

function TWerkzeugFactory.GetIsWerkzeug3: boolean;
begin
  Result := FWerkzeug is TWerkzeug3;
end;

function TWerkzeugFactory.GetWerkzeug1: TWerkzeug1;
begin
  if IsWerkzeug1 then
    Result := TWerkzeug1(FWerkzeug)
  else
    Result := nil;
end;

function TWerkzeugFactory.GetWerkzeug2: TWerkzeug2;
begin
  if IsWerkzeug2 then
    Result := TWerkzeug2(FWerkzeug)
  else
    Result := nil;
end;

function TWerkzeugFactory.GetWerkzeug3: TWerkzeug3;
begin
  if IsWerkzeug3 then
    Result := TWerkzeug3(FWerkzeug)
  else
    Result := nil;
end;

[DeddyH]

Den Sinn dieser Factory verstehe ich ehrlich gesagt nicht. Kommt noch eine Ableitung hinzu, muss auch die Factory geändert werden, damit sie die entsprechende Klasseninstanz liefern kann, das bringt irgendwie nix.

[Bjoerk]

Ei, ich hann gemennt..

[stahli]

Schreib doch mal, was Du da vor hast.
Willst Du nur eine Werkzeuginstanz?

Sollen das sichtbare Controls werden?

Was soll das Projekt machen und was die Fabrik?