Membervariablen zur Laufzeit erzeugen

[Manfred]

Hi,

unter Clipper habe ich aus den DB Feldnamen während der Laufzeit gleichlautende Speichervariablen erzeugt. Das hatte ich zu Anfang auch unter Xbase++ versucht, aber irgendwie klappt es nicht.

Andreas hatte mir auf der Fahrt nach Berlin, (oder war es auf dem Rückweg? Keine Ahnung) gesagt, das würde gehen und zwar mit dynamischen Klassen und diese dann erben lassen von der eigentlichen Klasse. Hm, ich habe gerade mal kurz nachgelesen. Das mit den dynamischen Klassen und dem Erben ist ja ganz gut, aber ich hätte dann unterschiedliche Objektnamen, mit denen ich dann für 1 DB arbeiten müßte.

Hat jemand eine Idee, wie man das Problem lösen könnte? (Wie gesagt und auch auf dem letzten XUGOS Treffen gezeigt) Ich habe derzeit alle Feldnamen, der DB auch als Membervar, die ich dann dazu benutze die Feldinhalte zu puffern um damit dann in den Eingabemasken zu arbeiten. Was für mich bedeutet, dass ich immer darauf achten muß, dass auch alle Feldnamen als Memerbervar vorhanden sind, sonst knallt es, wenn ich den Record durchlaufe und einlese, oder abspeicher.

[Martin Altmann]

Hallo Manfred,
wenn Du immer darauf achtest, MEMVAR-> vor die Speichervariable zu schreiben und vor den Feldnamen immer FIELD-> (bzw. den Aliasnamen der geöffneten Datei), dann sollte eigentlich nichts durcheinanderkommen...

Viele Grüße,
Martin

[Manfred]

Öhm, jetzt verwirrst Du mich,

ich meinte das anders:

Ich habe derzeit in der Klasse die Feldnamen der entsprechenden DB als Membervar angelegt, sodaß ich diese benutze um aus der DB die Werte des Felder, das zu dem Namen der Membervar gehört, zwischenzuspeichern. Dieser Vorgang wird über eine Schleife gemacht, der dann verkürzt sowas macht:

objekt:feld1 := db->feld1

und umgekehrt bei der Speicherung.

Jetzt war es früher so:

m->feld1 := db->feld1

Den Namen feld1 z.B. habe ich über eine Schleife, die die DBstruktur durchlief als Privat erzeugt und ein M davor gesetzt, also so

M->mFeld1 := db->feld1

Somit mußte ich die Variablenname nicht vorher wissen, sondern habe sie mir aus den Feldnamen der DB erzeugt, zur Laufzeit.

Das geht wohl nur mit Speichervariablen und nicht mit Membervariablen.

Ich möchte einfach der Klasse die Möglichlichkeit geben, ohne die Membervar vorher zu deklarieren, diese während der Laufzeit aus der DB zu erzeugen. Das scheint aber mit Objekten nicht zu gehen. Entweder die werden sofort im Quelltext deklariert, oder über dynamische Klassen. Und da sind wir dann beim Problem, was ich Eingangs aufgelistet habe.

[Martin Altmann]

Aah, OK!
Sorry. Das geht so sicherlich nicht.
Du könntest aber folgendes machen (ob es sinnvoll ist, sei mal dahingestellt):
In Deiner Klasse definierst Du Dir eine Variable. Diese enthält in Form eines Arrays die jeweilgen Feldinhalte.
Natürlich kannst Du diese dann nicht direkt über die Feldnamen ansprechen, sondern mußt mit fieldpos() arbeiten. Die Größe des Arrays dimensionierst Du Dir über FCount() und der Zugriff wäre dann z.B. folgendermaßen möglich:
Array dimensionieren:

Code: Alles auswählen

::aData := Array( ( Alias() )->( FCount() ) )

Felder in das Array einlesen:

Code: Alles auswählen

LOCAL n
FOR n:=1 TO len( ::aData )
  ::aData[ n ] := FieldGet( n ) 
NEXT 

Und zurückschreiben:

Code: Alles auswählen

LOCAL n
FOR n:=1 TO len( ::aData )
  FieldPut( n, ::aData[ n ] ) 
NEXT 

Einen einzelnen Wert lesen:

Code: Alles auswählen

FieldPut( FieldPos( "Name" ), ::aData[ FieldPos( "Name" ) ] ) 

Viele Grüße,
Martin

[Manfred]

Hi Martin,

das wäre nicht das was ich haben wollte. Ich möchte gerne die Membervar mit den gleichen Namen ansprechen wie die Feldnamen heißen, um so immer zu wissen, was ich gerade wo anpacke.

Naja, hätte ja sein können. Als ich aber gerade ein wenig in den dynamischen Klassen im Handbuch gelesen hatte, kam mir wieder die Aussage von Steffen in den Kopf, dass es wohl bald ein Datenbankobjekt eben wird. Und so wie ich es verstanden und somit in Erinnerung habe, wird das dann wohl alles erledigen, was ich mir jetzt als eigene Klasse gebaut habe. Also warte ich noch ein Weilchen.

[Martin Altmann]

Hallo Manfred,
das geht dann nur so, wie in meinem letzten Beispiel beschrieben! FieldPos() bekommt ja den Namen des Feldes als Parameter.

Viele Grüße,
Martin

[andreas]

Hallo Manfred,

siehe nach Befehl ClassCreate(). Da ist auch das passende Beispiel, was dich interessieren würde.

[Martin Altmann]

Hallo Andreas,
schon wieder was dazugelernt - vielen Dank! =D>

Viele Grüße,
Martin

[Manfred]

Hi Andreas,

da hatte ich reingeschaut. Es ist doch aber so, (verbessere mich bitte, wenn ich Unrecht habe)

Ich erzeuge meine Klasse, für das DB-Objekt in der die Struktur und die Methoden für die Bearbeitung stehen. Dann erzeuge ich zur Laufzeit eine dynamische Klasse, die von oben genannter erbt!? So, ab da habe ich dann 2 Klassen, die ich zur Benutzung der DB brauche.

Nee, eigentlich Quatsch. Die dynamische erbt ja alles von den höherstehenden und damit brauche ich ja nur noch die aufzurufen und darüber alles zu machen. Hm, muß ich mal durchlesen, ob ich das kapiere.

Nee, doch richtig, ich habe zunächst das Objekt, mit der ich die Db öffne usw. dann müßte ich die dynamische erzeugen um an die Felder zu kommen um daraus die Membervars zu bauen. Naja, ab da wäre dann nur noch die dynamische aufzurufen, aber ich habe 2 Objekte für eine DB. Und das dann multipliziert mit den DB.......

Hm, muß ich mal eine halbe Stunde drüber schlafen.

[Manfred]

Hi Martin,

warst wohl gestern nicht so ganz ausgeschlafen? Ich hatte das Eingangs in meinem Posting schon erwähnt, nur dass ich eben dynamische Klassen und nicht ClassCreate() gesagt hatte.

Es war halt eine harte Nacht.....

[Martin Altmann]

Hallo Manfred,

So, ab da habe ich dann 2 Klassen, die ich zur Benutzung der DB brauche.

nö - wieso?
In der Hilfe wird doch ein Besipiel gezeigt. Dort wird in einer Funktion die Information gesammelt und die Klasse erzeugt, die danach genutzt wird.

Viele Grüße,
Martin

[Manfred]

Ich bin ganz ehrlich:

das ist mir im Moment zu kompliziert und ich möchte deshalb nicht Gefahr laufen hier einen Thread aufzublähen, weil ich eure Tipps und Tricks nicht kapiere.

Ich habe es jetzt erstmal gesehen und hingenommen, das es irgendwie gehen könnte, aber ich kann es nicht umsetzen. Muß ich halt noch etwas warten, bis der Geistesblitz kommt und mich trifft.

Trotzdem Danke bis hier hin

[Sören]

Hallo Manfred,

gib nicht so schnell auf!!!

Ich glaube das ist es, was Du suchst:

Code: Alles auswählen

#include "class.ch"

PROCEDURE Main

  LOCAL oRecSet

  USE Customer EXCL NEW

  oRecSet := RecSet():New()

  ? oRecSet:LastName
  oRecSet:LastName := "Otto"
  ? oRecSet:LastName

  oRecSet:GoTo( 3 )
  ? oRecSet:FirstName
  ? oRecSet:LastName

  wait

  oRecSet:Close()

RETURN


CLASS RecSet

  EXPORTED:
    VAR Alias, FieldNames
    CLASS METHOD New
    METHOD Init, Close
    INLINE METHOD FieldGet( nFieldPos )
    RETURN (::Alias)->( FieldGet( nFieldPos ) )
    INLINE METHOD FieldPut( nFieldPos, xValue )
    RETURN (::Alias)->( FieldPut( nFieldPos, xValue ) )
    INLINE ACCESS METHOD Struct()
    RETURN (::Alias)->( dbStruct() )
    INLINE ACCESS METHOD RecNo()
    RETURN (::Alias)->( RecNo() )
    INLINE ACCESS METHOD Bof
    RETURN (::Alias)->( Bof() )
    INLINE ACCESS METHOD Eof
    RETURN (::Alias)->( Eof() )
    INLINE METHOD Skip( n )
    RETURN (::Alias)->( dbSkip( n ) )
    INLINE METHOD GoTo( n )
    RETURN (::Alias)->( dbGoTo( n ) )
    INLINE METHOD GoTop
    RETURN (::Alias)->( dbGoTop() )
    INLINE METHOD GoBottom()
    RETURN (::Alias)->( dbGoBottom() )

    // weitere Methoden wie Seek, Append, Replace, Delete ...

ENDCLASS

METHOD RecSet:init()
RETURN self

METHOD RecSet:Close()
  dbSelectArea( ::Alias )
  dbCloseArea()
  ClassDestroy( ::className() )
RETURN self

// - Class-Methode der RecSet-Klasse
// - mittels dieser Methode wird dynamisch eine neue Klasse, abgeleitet von der RecSet-Klasse,
//   also von sich selbst, erzeugt
// - anschl. wird das Object der neuen Klasse erzeugt und die Init()-Methode aufgerufen 
// - die Methode gibt das Object der Klasse zurueck, mit dem gearbeitet wird
// - dieser Methode habe ich den Namen ::New() gegeben, um das Erzeugen einer statischen Klasse
//   nachzubilden (sie koennte genauso gut auch ::ClassCreate() heissen)
CLASS METHOD RecSet:New()

  LOCAL n, nMax
  LOCAL aMethod, cBlock, cName, nType
  LOCAL aFieldNames
  LOCAL cClassName := "RecSet", oClass

  cClassName := GetDynamicClassName( cClassName )

  nType := CLASS_EXPORTED + METHOD_INSTANCE + ;
           METHOD_ACCESS  + METHOD_ASSIGN

  aFieldNames := FieldNames()

  nMax:= Len( aFieldNames )

  aMethod := Array( nMax )

  FOR n := 1 TO nMax

    cName := aFieldNames[n]

    cBlock := "{ |o,x| iif( x == NIL," + ;
                       "o:FieldGet(" + Var2Char(n) + ")," + ;
                       "o:FieldPut(" + Var2Char(n) + ",x) ) }"

    aMethod[n] := { cName, nType, &(cBlock), cName }

  NEXT

  // Klasse wird dynamisch erzeugt
  oClass := ClassCreate( cClassName, { Self }, {}, aMethod )

  oClass := oClass:New()

  oClass:Alias := Alias()
  oClass:FieldNames := AClone( aFieldNames )

RETURN oClass


// - Namen fuer dynamische Klassen ermitteln, so dass keine doppelten Namen bei
//   erneuter Erzeugung und somit ein Laufzeitfehler entsteht, indem ein Zaehler an den Namen
//   angehaengt wird
FUNCTION GetDynamicClassName( cClassName )

  LOCAL nCounter := 0
  LOCAL cNewClassName := cClassName
  LOCAL oClass := ClassObject( cNewClassName )

  while oClass != NIL
    nCounter++
    cNewClassName := cClassName + AllTrim( Str( nCounter ) )
    oClass := ClassObject( cNewClassName )
  enddo

RETURN cNewClassName


// Feldnamen der aktuellen DB in ein Array schreiben
FUNCTION FieldNames()
  LOCAL n, nTo := FCount()
  LOCAL aFields := Array( nTo )
  FOR n := 1 TO nTo
    aFields[n] := FieldName( n )
  NEXT 
RETURN aFields

Tschüs,
Sören

[Manfred]

Hi Sören,

so wie ich das auf die Schnelle überschaue, sind die Felder in einem Array. Wenn ich die Felder direkt anspreche, als Membervariablen, dann muß ich das Array nebst "Satznummer" des Array ansprechen. Ich habe es aber jetzt so gemacht, dass ich die Var über das Objekt anspreche direkt mit dem Namen und somit weiß, was ich gerade womit tue. In dem Fall müssen aber die Namen vorher in der Klassendeklaration als VAR hinterlegt und somit doppelt geführt werden. 1x als VAR und 1x noch in meinem Strukturarray, aus dem ich die Db erzeuge, bzw. über das ich nachher die Felder anspreche. Es geht mir nur darum, später in dem Strukturarray die Änderung vorzunehmen und nicht immer noch daran zu denken auch die entsprechende Membervar anzulegen, damit bei der Schleife, die über die Feldnamen die Membervar Namen erwartet, nicht ein Fehler erzeugt wird, weil ich vergessen habe diese vorher zu deklarieren.

[Sören]

Hallo Manfred,

sieh Dir das Beispiel, das ich gepostet habe, noch mal etwas genauer an!
Die Member-Variable ::FieldNames, über die Du gestolpert bist, ist nur Zugabe; Du kannst die 2 Programmzeilen, in denen Sie auftaucht, aus dem Code löschen, ohne die Funktionalität zu beeinträchtigen.

Betrachte die Main-Prozedur:

? oRecSet:LastName
gibt den Inhalt des Feldes "LastName" zurück.

Und:
? oRecSet:LastName := "Otto"
ersetzt den Feldinhalt des Feldes "LastRec" mit "Otto".

Das ist es doch, wonach Du gefragt hat?!

Compiliere das Beispiel einfach mal und starte es ("Customer.dbf/dbt" muss sich im Programmverzeichnis befinden).

Sören

[Manfred]

Hi Sören,

da war ich wohl doch zu voreilig. Ich habe mir das Alaska Beispiel einmal kurz angesehen und im Debugger die Klasse geprüft. Es scheint wohl doch in die Richtung zu gehen, die ich mir vorstelle.

[Markus Walter]

Hallo Manfred,

ich habe mir auch eine DBclasse geschrieben, bin aber einen ganz anderen Weg gegangen:

ich verwende für den Feldzugriff die Methoden getNoIVar/setNoIvar. Diese werden gerufen, wenn eine Ivar aufgerufen wird, die es nicht gibt.

Das ganze läuft im wesentlichen so ab:
- beim Init der Klasse wird die Struktur der DBF gelesen und ich erzeuge ein Array mit zwei Spalten: 1. Spalte Feldname, 2. Spalte Inhalt (zunächst leer)
- bei allen Navigationsaufrufen (goto, skip, ...) wird der Inhalt der Felder des aktuellen Datensatzes in die 2. Spalte geladen
- Methoden getNoIVar/setNoIvar werden genutzt, um auf die Werte zuzugreifen (d. h. bei getNoIVar wird der entsprechende Eintrag aus dem Array gelesen und zurückgegeben, bei setNoIvar wird das Array-Element gesetzt)

So läuft das dann in der Praxis:

Code: Alles auswählen

//Lesen
oDB := mydbclass():New(dbname,......)

? oDB:Nachname   (-> Pan)
? oDB:Vorname (->Peter)

oDB:skip()
//usw.

//Schreiben
oDB:Name := "Müller"
oDB:Vorname := "Max"

oDB:Update()
// Update übernimmt das übertragen aus dem Array in die Tabelle (wollte ich so...)

Funktioniert bisher prima...

Damit bin ich auch völlig unabhängig von Struktur-Änderungen, d. h. ich muss keine Veränderungen an der Klasse vornehmen...

[Manfred]

Hi Markus,

ich glaube, wir beide haben eine ähnliche Lösung. Aber ich denke einmal Du hast mich da auf eine Idee gebracht.....

[Markus Walter]

Na denn, wenn Du willst kann ich Dir meine Klasse zur Verfügung stellen, ich müsste Dir da aber das ein oder andere erklären...

[Manfred]

also mich würde diese "Umwandlung" der Feldnamen interessieren. Da hatte ich wohl vorhin ein wenig zu schnell geschossen.

[Manfred]

So,

nach unserem gestrige Treffen, ist es m.E. Zeit dieses Thema nochmals aufzugreifen. Ich bin davon überzeugt, dass es nicht so klappt, bzw. das die Lösungsvorschläge hier und aus der Anleitung nicht MEIN Problem lösen. Aber auch hier: Ich lerne gerne dazu.

[Martin Altmann]

Warum nicht?
Schau Dir mal oben das Beispiel von Sören an - mit dem ClassCreate()!

Viele Grüße,
Martin

[Manfred]

Hab ich gemacht,

auch das Beispiel aus dem Handbuch. Aber die Var stehen nachher in einem Array. Damit kann ich nichts anfangen. ich muß dann die Nummer der Stelle wissen, an dem die Var im Array erscheint. Ich möchte aber die Namen direkt aufrufen.

Sollte das jetzt nicht so sein, dann verstehe ich die Beispiele nicht.

[Martin Altmann]

Dem ist nicht so und Du verstehst die Beispiele nicht!
Die Feldnamen stehen nur in einem Array, das als Parameter an die ClassCreate() übergeben wird!!!
Und diese macht aus den übergebenen Parameter eine Klasse!
Erster Parameter: Name der zu erstellenden Klasse (also in Deinem Fall: Alias())
Zweiter Parameter: Name der Superklasse (in Deinem Fall Datenbank - glaube ich)
Dritter Parameter: Array der Feldnamen Membervariablen
Vierter Parameter: Array der Methoden (in Deinem Fall leer, da alle Methoden bereits in Deiner Superklasse drin sind).

Viele Grüße,
Martin

[Manfred]

Hi Martin,

stimmt ihr habt Recht. Ich hätte doch direkt ein Programm bauen und anschauen sollen. Ich habe das Beispiel von Sören kompiliert und es scheint so zu sein, wie ich es haben will. Jetzt muß ich nur erstmal durchblicken, was da genau passiert und wie ich es umsetzen kann in meinem Source.