Gibt es ein Objekt das eine "Zeile" einer DB kapselt?

[Der schöne Günther]

Klar, ein vernünftiges ORM zaubert man sich wirklich nicht in einer Viertelstunde aus dem Hut.

Ich wollte jetzt wirklich keinen Hibernate-Klon erschaffen, sondern einer einfachen Klasse eher für Debug-Zwecke eine Art myObject.toXML(): TStringStream und myObject.toDB(): TFields verpassen die dann von einem entsprechenden Persistierer (was für ein Wort )entgegengenommen und gespeichert werden können.

Probleme mit NULL-Werten oder Prüfen auf Gleichheit sehe ich weniger. Ersteres hätte ich über DB-Constraints geregelt, zweites erst auf Objekt-Ebene, also nach der Deserialisierung.


Da ich (zum Glück) nie allzu viel Zeit mit J2EE-Entwicklung verbracht habe, hänge ich bei so etwas natürlich schon wieder an Grundsatzfragen ("Sollte die Klasse selbst sich überhaupt mit ihrem Ziel-Serialisierungsformat herumplagen müssen?"), aber das packe ich wohl besser in ein eigenes, allgemeineres Thema

[Uwe Raabe]

Es gibt verschiedene prinzipielle Ansätze:

1. Die Klasse kann sich in ein TDataSet schreiben
2. Eine Hilfklasse kann die Klasse in ein TDataSet schreiben
3. Eine Implementation des Visitor Pattern (ähnlich wie 2. aber flexibler)

[Der schöne Günther]

Das Visitor Pattern habe ich mir nie genauer angesehen, in freier Wildbahn ist es mir bislang nie über den Weg gelaufen. Ich habe heute Abend zumindest angefangen, es mir genauer anzuschauen, und von allen Artikeln ist deiner mit Abstand der beste den ich spontan auftreiben konnte

Nach den ersten zwei von vier Teilen habe ich wohl den Grundgedanken verstanden: Das ist so ziemlich genau das, was ich wollte.

[Sir Rufo]

Der Visitor von Uwe hat ein paar Beschränkungen hinsichtlich der Generics (z.B. TList<T> ) oder bei gleichlautenden Klassennamen aus unterschiedlichen Units.

Hier meine Visitor-Interpretation

Delphi-Quellcode:

unit View.Main;

interface

  uses
    Visitor,

    Winapi.Windows,
    Winapi.Messages,
    System.SysUtils,
    System.Variants,
    System.Classes,
    Vcl.Graphics,
    Vcl.Controls,
    Vcl.Forms,
    Vcl.Dialogs,
    Vcl.StdCtrls;

  type
    TMainView = class( TForm )
      Button1 : TButton;
      Edit1 : TEdit;
      Label1 : TLabel;
      Memo1 : TMemo;
      procedure Button1Click( Sender : TObject );
    private
      procedure PrepareVisitor( AVisitor : TVisitor );
    public

    end;

  var
    MainView : TMainView;

implementation

{$R *.dfm}

  procedure TMainView.Button1Click( Sender : TObject );
    var
      LVisitor   : TVisitor;
      LIdx       : Integer;
    begin
      LVisitor := TVisitor.Create;
      try
        PrepareVisitor( LVisitor );

        for LIdx := 0 to ComponentCount - 1 do
        begin
          LVisitor.Visit( Components[LIdx] );
        end;

      finally
        LVisitor.Free;
      end;
    end;

  procedure TMainView.PrepareVisitor( AVisitor : TVisitor );
    begin
      AVisitor.Clear;

      AVisitor.RegisterType<TButton>(
        procedure( Instance : TButton )
          begin
            Instance.Caption := 'a button';
          end );

      AVisitor.RegisterType<TEdit>(
        procedure( Instance : TEdit )
          begin
            Instance.Text := 'an edit';
          end );

      AVisitor.RegisterType<TLabel>(
        procedure( Instance : TLabel )
          begin
            Instance.Caption := 'a label';
          end );

      AVisitor.RegisterType<TMemo>(
        procedure( Instance : TMemo )
          begin
            Instance.Clear;
            Instance.Lines.Add( 'a memo' );
          end );
    end;

end.

Delphi-Quellcode:

unit Visitor;

interface

  uses
    System.SysUtils,
    System.Generics.Collections;

  type
    IVisitorHandler = interface
      ['{7C5BA846-6286-406A-AC87-3BC89F2E9F21}']
      procedure Visit( const Instance : TObject );
    end;

    IVisitorHandler<T : class> = interface( IVisitorHandler )
    end;

    TVisitor = class
    private
      FVisitorDict : TDictionary<TClass, IVisitorHandler>;
    public
      constructor Create;
      destructor Destroy; override;

      procedure RegisterType<T : class>( AVisitor : IVisitorHandler<T> ); overload;
      procedure RegisterType<T : class>( AVisitor : TProc<T> ); overload;

      procedure Clear;
      procedure Visit( Instance : TObject );
    end;

    TVisitorHandler = class abstract( TInterfacedObject, IVisitorHandler )
    protected
      procedure Visit( const Instance : TObject ); virtual; abstract;
    end;

    TVisitorHandler<T : class> = class abstract( TVisitorHandler, IVisitorHandler<T> )
    end;

    TAnonVisitorHandler<T : class> = class( TVisitorHandler<T> )
    private
      FVisitor : TProc<T>;
    protected
      procedure Visit( const Instance : TObject ); override;
    public
      constructor Create( AVisitor : TProc<T> );
    end;

implementation

    { TVisitor }

  procedure TVisitor.Clear;
    begin
      FVisitorDict.Clear;
    end;

  constructor TVisitor.Create;
    begin
      inherited;
      FVisitorDict := TDictionary<TClass, IVisitorHandler>.Create;
    end;

  destructor TVisitor.Destroy;
    begin
      FVisitorDict.Free;
      inherited;
    end;

  procedure TVisitor.RegisterType<T>( AVisitor : TProc<T> );
    begin
      RegisterType<T>( TAnonVisitorHandler<T>.Create( AVisitor ) );
    end;

  procedure TVisitor.RegisterType<T>( AVisitor : IVisitorHandler<T> );
    begin
      FVisitorDict.AddOrSetValue( T, AVisitor );
    end;

  procedure TVisitor.Visit( Instance : TObject );
    var
      LClass : TClass;
    begin
      LClass := Instance.ClassType;
      while Assigned( LClass ) do
      begin
        if FVisitorDict.ContainsKey( LClass )
        then
        begin
          FVisitorDict[LClass].Visit( Instance );
          Break;
        end;
        LClass := LClass.ClassParent;
      end;
    end;

  { TAnonVisitorHandler<T> }

  constructor TAnonVisitorHandler<T>.Create( AVisitor : TProc<T> );
    begin
      inherited Create;
      FVisitor := AVisitor;
    end;

  procedure TAnonVisitorHandler<T>.Visit( const Instance : TObject );
    begin
      FVisitor( Instance as T );
    end;

end.