Dataset als Parameter mit OOP oder wie ?

[Lemmy]

Hi Hansa,


muss mich entschuldigen! Ich übergebe dem Konstruktor kein DataSet, sondern die Datenbankverbindung mittels der IBDatabase oder der IBTransaction:

also hier mal ein Beispiel (mit IBX, was aber nichts zur Sache tut):

Delphi-Quellcode:

type TDBObject=class(TObject)
     private
     protected
       iID:Int64;
       IBDataSet:TIBDataSet;
       sSQL, sSaveSQL:String;
       bSave, bExpicitTransaction:Boolean;
       Transaction:TIBTransaction;


       procedure SetSQLStatement;  virtual;
       procedure SaveValues;       virtual;
       procedure SelectValues;     virtual; abstract;
       procedure SetValues;     virtual; 

     public
       constructor create(DefaultDataBase:TIBDataBase);  overload;
       constructor create(DefaultTransaction:TIBTransaction);  overload;

       procedure Free; virtual;

       procedure Save;

       property SaveDB:Boolean read bSave write bSave;
       property ID:Int64 read iID;
     end;

und hier die abgeleitete Klasse:

Delphi-Quellcode:

type TAdresse=class(TDBObject)
     private
       sName, sStrasse, sOrt, sTelefon, sFax, sAnrede, sTitel, sAnschrift:String;
     protected
       procedure SelectValues;  override;
     public
       constructor create(DefaultDataBase:TIBDataBase; AdresseID:Int64);
       property Name:String read sName write sName;
       property Strasse:String read sStrasse write sStrasse;
       property Ort:String read sOrt write sOrt;
       property Telefon:String read sTelefon write sTelefon;
       property Fax:String read sFax write sFax;
       property Anrede:String read sAnrede write sAnrede;
       property Titel:String read sTitel write sTitel;
       property Anschrift:String read sAnschrift;
     end;

Im Konstruktor der Klasse TDBObject wird je nach aufgerufenen Konstruktor eine IBDataSet oder eine IBTransaction + IBDataSet erzeugt und natürlich beim Destruktor wieder freigegeben. Ich habe so einige Klassen erzeugt, teilweise auch mit Enkeln (wie nennt man das, wenn man eine Klasse ableitet und von dieser wieder ableitet?).

Die Übergabe der IBDataSet bzw. Transaction mache ich deshalb, um zum einen bei der IBDataset innerhalb der Klasse die Transaktionssteuerung zu machen, oder wenn ich die Transaction-Instanz übergebe wird die Transaktionssteuerung außerhalb der Klasse vorgenommen (wenn das Objekt der Klasse z.B. von einem anderen Objekt (z.B: Auftrag) aufgerufen wird).



Grüße
Lemmy

[Hansa]

Lemmy, das ist ja schon gut, aber ich kann doch nicht auf niedriger Objekt-Ebene schon solch komplizierte Gebilde einbauen. Ich will doch nur ein Dataset haben, welches ich nach Bedarf durch ein geeignetes und auch schon definiertes ersetze. Sogar die Feldnamen sind fast identisch, aber nicht alle.

[Sprint]

Zitat von Hansa:

wie teile ich meinem Programm mit, daß es sich an einer Stelle bei Dataset um den Lagerbestand handelt und woanders z.B. um eine Adresse ?

Stichwort: Eigenschaften.

[Lemmy]

Guten Morgen,

was heißt hier niedrige Objektebene? Wieviele Nachfahren von TDBObject willst Du denn erzeugen? Die Klasse TAdresse ist mein Ziel, dort steckt alles drin, was ich in dieser Anwendung benötige. Neben TAdresse gibts noch ein paar andere. Lediglich bei einer Klasse habe ich mich zu ner weiteren Vererbung entschlossen, da ich diese universell einsezten muss:

Delphi-Quellcode:

type THoaiAnsatz=Class(TDBObject)
     protected
       sHoaiAnsatzNr, sAuftragNr, sBeschreibung, sBearbeiter, sStrasse, sOrt, sTeilort,
       sSonstiges, sPLZ:String;
       cSchaetzung, cBerechnung, cAnschlag, cFeststellung:Currency;
       cSchaetzungHonorar, cAnschlagHonorar, cFeststellungHonorar, cBerechnungHonorar:Currency;
       cMwst, cBesondereLeistungen, cLeistungsbild, cNebenkosten, cAbschlag:Currency;
       cNebenPauschale, cBLWiederholungen:Currency;

       iHoaiZone, iHoaiZuschlag:SmallInt;
       iHoaiTeilID:SmallInt;

       dtDatum:TDate;

       iAuftraggeberID, iHoaiVorlageID, iAuftragID:Int64;
       adrAuftraggeber:TAdresse;
       sHoaiVorlage:String;

       AnrechenbareKost:THoaiAnrechenbareKosten;
       IBDatabase:TIBDatabase;

       cGrundhonorar:Currency;

       iObjektID:Int64;

       sBegruendung:TStringList;

       procedure SelectValues;  override;
       procedure SetValues; override;
       function GetNebenkostenHonorar:Currency;  virtual;
       procedure SetSQLStatement; 

     public
       constructor create(DefaultTransaction: TIBTransaction; HOAIAnsatzID:Int64);
       procedure free;   override;

       procedure saveValues; override;

       property AnsatzNummer:String read sHoaiAnsatzNr;
       property AuftragNummer:string read sAuftragNr;
       property Beschreibung:String read sBeschreibung;
....

und deren Ableitungen:

Delphi-Quellcode:

type THoai2Ansatz=Class(THoaiAnsatz)
     protected

       IBDataSetDetail:TIBDataSet;
       cVorplanungen, cEntwurfsplanungen:Currency;

       iWiederholungen:Integer;
       iVorplanung, iEntwurfsplanung:Integer;
       cUmbauzuschlag:Currency;
       cWiederholungenHonorar,cWiederholungenLB, cVorhandeneBausubstanz:Currency;

       sSQLDetail, sSaveSQLDetail:String;


       procedure SelectValues;  override;
       procedure SaveValues; override;
       procedure SetValues; override;
       function GetNebenkostenHonorar:Currency; override;
       procedure SetSQLStatement; 

     public
       constructor create(DefaultTransaction: TIBTransaction; HOAIAnsatzID:Int64);
       procedure free;   override;
...

Von den Ableitungen gibts derzeit 2, im Endausbau werden es wohl um die 12 werden.

Ein "allgemeingültiges" Objekt wirst Du nie erzeugen können, wenn Du durch das Objekt (z.B. Adresse:TAdresse) die Eigenschaften auslesen willst (Adresse.Name) Da kannst Du nicht einmal ne Adresse auslesen und ein anderes mal den Lagerbestand! Dazu brauchst Du spezielle Klassen, die sich der Gegebenheit der Tabelle anpassen.

Holger Klemt geht in seinem Artikel allerdings etwas neutraler an die Sache ran, was aber wieder bedeutet, dass schon bei der Erstellung der Datenbank auf diese Art des Datenbankzugriffs eingegangen werden muss!

Grüße
Lemmy

[Hansa]

Ich glaube keiner versteht mich. Sprint vielleicht, aber das andere ist wohl viel komplizierter als überhaupt gebraucht. Also gut, ich bringe ein ausführlicheres Beispiel :

2 Ausgabe-Grids. Eines für Lager, das andere für Preise. In beiden Fällen brauche ich zuerst mal die Artikel und da fängts an. Die sind etwas kompliziert. Sie können 1-3 Zeilen für die Bezeichnung haben. Sie werden je nach Eigenschaften farblich gekennzeichnet usw. Jetzt habe ich das alles in einer separaten Unit. Die Anzeige sieht dann so aus :

Delphi-Quellcode:

ZeigePosition;
ZeigeDetailposition;

ZeigePosition zeigt die Artikel mit allem drum und dran an. ZeigeDetailposition dient zum Anzeigen entweder des Lagerbestandes oder des Preises.

ZeigeDetailPosition bleibt erst mal leer, weil erst später feststeht was jetzt angezeigt wird (also Lager oder Preis). Nun habe ich in den abgeleiten Klassen 2 Datasets PreisDS und LagerDS. Mit 2 verschiedenen Joins einmal über Lager und einmal über Preise. Die Ursprungsklasse kann davon aber noch nichts wissen. Meine Überlegung war, die Logik so in der Ursprungsklasse beizubehalten, aber eben mit einem leeren Dataset, daß erst später konkret besetzt wird.

Mit der Property ging das wohl schon so, bis auf die Tatsache, daß kein Zugriff darauf möglich ist. Es sieht also so aus, daß die Feldnamen bzw. die Daten für die Artikel in beiden Fällen gleich sind (das ganze läuft über einen Join (ARTIKEL JOIN LAGER bzw. ARTIKEL JOIN PREIS) und ich eben im Vorfeld alles was mit den Artikeln zu tun hat erledigen will. Würde das gelingen, so müßte ich nur noch in ZeigeDetaildaten die entsprechende Lagerdaten/Preise anzeigen.

ZeigePositionen ist nun gedacht zur Anzeige der immer gleichen Artkeldaten und das kann ich nicht nutzen, weil zum Schluß diese Daten in den Datasets LagerDS bzw. PreisDS drin stecken. Davon weiß eben die Grundklasse noch nichts. 8)

[Hansa]

Tja, so ist Delphi. Phänomenal ! Es ist schon sehr erstaunlich, was da alles möglich ist, sofern man sich nur tief genug in die Problematik eingräbt, sucht und auch mal experimentiert. Um es vorwegzunehmen : vergesst die properties und den ganzen Rest.

Das geht so einfach, daß ich mich nicht traue zu sagen wie. Das ganze ist reproduzierbar und getestet anhand zweier Tabellen. Leider weiß ich noch nicht genau, worauf es letztendlich ankommt, aber im Großen und Ganzen ist es ziemlich klar.

Die grundlegende Programm- und Datenbankarchitektur spielt allerdings eine gewaltige Rolle. Ich schätze mal, daß sich der Aufwand, ein komplexes Ausgabe-Formular zu entwerfen (wie im konkreten Fall) auf 10 % der veranschlagten Zeit reduzieren läßt. Ich kann also im Laufe eines einzigen Tages 20 in Frage kommende Formulare so gestalten, daß alles paßt. Vom Wartungsaufwand dafür ganz zu schweigen. 8)

[Sprint]

Hättest du hier eine richtige Frage gestellt, dann hättest du auch eine passende Antwort bekommen.