NaturalX-Anwendungen entwickeln

Dieses Dokument beschreibt, wie eine Anwendung durch Definition und Benutzung von Klassen entwickelt wird.

Es umfasst die folgenden Themen:


Entwickungsumgebungen

  • Klassen auf Windows-Plattformen entwickeln
    Auf Windows-Plattformen stellt Natural den Class Builder als Werkzeug zur Entwicklung von Natural-Klassen zur Verfügung. Der Class Builder präsentiert eine Natural-Klasse in einer strukturierten hierarchischen Reihenfolge und ermöglicht es dem Benutzer, die Klassen und ihre Komponenten effizient zu verwalten. Wenn Sie den Class Builder benutzen, sind überhaupt keine Vorkenntnisse oder auch nur Grundkenntnisse der unten beschriebenen Syntax-Elemente erforderlich.

  • Klassen mit SPoD entwickeln
    In einer Natural Single Point of Development-Umgebung (SPoD), der zentralen Umgebung für Entwicklungen einschließlich eines Großrechners und/oder UNIX Remote Development Servers (DFÜ-Entwicklungsserver) können Sie den Class Builder benutzen, der zusammen mit der Natural Studio-Benutzeroberfläche zur Entwicklung von Klassen auf Großrechnern und/oder UNIX-Plattformen zur Verfügung steht. In diesem Fall sind keine Vorkenntnisse oder auch nur Grundkenntnisse der im Folgenden beschriebenen Syntax-Elemente erforderlich.

  • Klassen auf Großrechner- oder UNIX-Plattformen entwickeln
    Wenn Sie SpoD nicht benutzen, entwickeln Sie mittels des Natural-Programm-Editors Klassen auf diesen Plattformen. In diesem Fall sollten Sie die Syntax der unten beschriebenen Klassen-Definition kennen.

Klassen definieren

Wenn Sie eine Klasse definieren, müssen Sie ein Natural-Klassenmodul definieren, innerhalb dessen Sie ein DEFINE CLASS-Statement erstellen. Mittels des DEFINE CLASS-Statements können Sie der Klasse einen extern verwendbaren Namen zuweisen und ihre Schnittstellen, Methoden und Eigenschaften definieren. Der Klasse kann auch ein Objekt-Datenbereich zugewiesen werden, der das Layout einer Instanz der Klasse beschreibt.

Dieser Abschnitt umfasst die folgenden Themen:

Natural-Klassenmodul erstellen

Beginn der Anweisungsliste Um ein Natural-Klassenmodul zu erstellen

  • Benutzen Sie das CREATE OBJECT-Statement zur Erstellung eines Natural-Objekts des Typs Klasse.

Klasse spezifizieren

Das DEFINE CLASS-Statement definiert den Namen der Klasse, die Schnittstellen, die die Klasse unterstützt, und die Struktur ihrer Objekte.

Beginn der AnweisungslisteUm eine Klasse zu spezifizieren

  • Benutzen Sie das DEFINE CLASS-Statement, das in der Statements-Dokumentation beschrieben ist.

Schnittstelle definieren

Jede Schnittstelle einer Klasse wird mit einem INTERFACE-Statement innerhalb der Klassen-Definition angegeben. Ein INTERFACE-Statement gibt den Namen der Schnittstelle und eine Anzahl von Eigenschaften und Methoden an. Für Klassen, die als COM−Klassen registriert werden sollen, gibt es auch die Globally Unique ID der Schnittstelle an.

Eine Klasse kann eine oder mehrere Schnittstellen haben. Für jede Schnittstelle wird ein INTERFACE-Statement in der Klassen-Definition kodiert. Jedes INTERFACE-Statement enthält eine oder mehrere PROPERTY- und METHOD-Klauseln. Gewöhnlich stehen die in einer Schnittstelle enthaltenen Eigenschaften und Methoden miteinander in einem technischen oder betriebswirtschaftlichen Zusammenhang.

Die PROPERTY-Klausel definiert den Namen einer Eigenschaft und weist der Eigenschaft eine Variable vom Objekt-Datenbereich zu. Diese Variable wird zum Speichern des Wertes der Eigenschaft benutzt.

Die METHOD-Klausel definiert den Namen einer Methode und weist der Methode ein Subprogramm zu. Dieses Subprogramm wird zum Implementieren der Methode benutzt.

Beginn der AnweisungslisteUm eine Schnittstelle zu definieren

  • Benutzen Sie das INTERFACE-Statement (siehe Statements-Dokumentation).

Objekt-Datenvariable einer Property zuweisen

Das PROPERTY-Statement wird nur benutzt, wenn mehrere Klassen dieselbe Schnittstelle auf verschiedene Art und Weise implementieren sollen. In diesem Fall benutzen die Klassen dieselbe Schnittstellen-Definition gemeinsam und beziehen sie von einem Natural-Copycode ein. Das PROPERTY-Statement wird dann benutzt, um außerhalb der Schnittstellen-Definition eine Variable vom Objekt-Datenbereich einer Eigenschaft zuzuweisen. Wie die PROPERTY-Klausel des INTERFACE-Statements definiert das PROPERTY-Statement den Namen einer Eigenschaft und weist eine Variable vom Objekt-Datenbereich der Eigenschaft zu. Diese Variable wird zum Speichern des Wertes der Eigenschaft benutzt.

Beginn der Anweisungsliste Um eine Objekt-Datenvariable einer Eigenschaft zuzuweisen

  • Benutzen Sie das PROPERTY-Statement (siehe Statements-Dokumentation).

Subprogramm einer Methode zuweisen

Das METHOD-Statement wird nur benutzt, wenn mehrere Klassen dieselbe Schnittstelle auf verschiedene Arten implementieren sollen. In diesem Fall benutzen die Klassen dieselbe Schnittstellen-Definition gemeinsam und beziehen sie von einem Natural-Copycode ein. Das METHOD-Statement wird dann benutzt, um außerhalb der Schnittstellen-Definition der Methode ein Subprogramm zuzuweisen. Wie die METHOD-Klausel des INTERFACE-Statements definiert das METHOD-Statement den Namen einer Methode und weist der Methode ein Subprogramm zu. Dieses Subprogramm wird zum Implementieren der Methode benutzt.

Beginn der AnweisungslisteUm einer Methode ein Subprogramm zuzuweisen

  • Benutzen Sie das METHOD-Statement (siehe Statements-Dokumentation).

Methoden implementieren

Eine Methode wird in der folgenden allgemeinen Form als ein Natural-Subprogramm implementiert:

DEFINE DATA
*
* Implementation code of the method
*
END

Informationen zum DEFINE DATA-Statement siehe Statements-Dokumentation.

Alle Klauseln des DEFINE DATA-Statements sind optional.

Um die Daten-Konsistenz sicherzustellen, empfiehlt es sich, dass Sie keine Inline-Datendefinitionen, sondern Data Areas benutzen.

Wenn eine PARAMETER clause-Klausel angegeben wird, kann die Methode Parameter und/oder einen Rückgabewert haben.

Mit BY VALUE in der Parameter Data Area markierte Parameter sind Eingabe-Parameter der Methode.

Nicht mit BY VALUE markierte Parameter werden "By Reference" übergeben und sind Eingabe/Ausgabe-Parameter. Dies ist die Voreinstellung.

Der erste mit BY VALUE RESULT markierte Parameter wird als Rückgabewert für die Methode zurückgegeben. Wenn mehr als ein Parameter auf diese Art markiert wird, werden die anderen als Eingabe/Ausgabe-Parameter behandelt.

Als OPTIONAL markierte Parameter brauchen nicht angegeben zu werden, wenn die Methode aufgerufen wird und Sie die nX-Notation im SEND METHOD-Statement benutzen.

Um sicherzustellen, dass das Methoden-Subprogramm genau dieselben Parameter akzeptiert, wie in dem entsprechenden METHOD-Statement in der Klassen-Definition angegeben, benutzen Sie eine Parameter Data Area anstatt von Inline-Datendefinitionen. Benutzen Sie dieselbe Parameter Data Area wie in dem betreffenden METHOD-Statement.

Um dem Methoden-Subprogramm Zugriff auf die Objektdaten-Struktur zu geben, kann die OBJECT-Klausel angegeben werden. Um sicherzustellen, dass das Methoden-Subprogramm korrekt auf die Objektdaten zugreifen kann, benutzen Sie eine Local Data Area anstatt von Inline-Datendefinitionen. Verwenden Sie dieselbe Local Data Area, wie in der OBJECT-Klausel des DEFINE CLASS-Statements angegeben.

Die Klauseln GLOBAL, LOCAL und INDEPENDENT können wie in jedem anderen Natural-Programm benutzt werden.

Obwohl es technisch möglich ist, macht es gewöhnlich keinen Sinn, eine CONTEXT-Klausel in einem Methoden-Subprogramm zu benutzen.

In dem folgenden Beispiel werden Daten über eine vorgegebene Person von einer Tabelle eingelesen. Der Suchschlüssel wird als ein BY VALUE-Parameter übergeben. Die sich daraus ergebenden Daten werden über “by reference”-Parameter zurückgegeben ("By Reference" ist die Standard-Definition). Der Rückgabewert der Methode wird durch die Spezifikation BY VALUE RESULT definiert.

Example

Klassen und Objekte benutzen

Auf in einer lokalen Natural-Session erstellte Objekte kann von anderen Modulen aus in derselben Natural-Session zugegriffen werden.

Das Statement CREATE OBJECT wird benutzt, um ein Objekt (auch als Instance bezeichnet) einer gegebenen Klasse zu erstellen.

Um Objekte in Natural-Programmen zu referenzieren, müssen Object-Handles im DEFINE DATA-Statement definiert werden. Methoden eines Objekts werden mit dem Statement SEND METHOD aufgerufen. Objekte können Eigenschaften haben, auf die mit der normalen Zuweisungssyntax zugegriffen wird.

Diese Schritte sind im Folgenden beschrieben:

Objekt-Handles definieren

Um Objekte in Natural-Programmen zu referenzieren, müssen Object-Handles im DEFINE DATA-Statement wie folgt definiert werden:

DEFINE DATA
   level-handle-name [(array-definition)] HANDLE OF OBJECT
   ...
END-DEFINE

Beispiel:

DEFINE DATA LOCAL
1 #MYOBJ1 HANDLE OF OBJECT
1 #MYOBJ2 (1:5) HANDLE OF OBJECT
END-DEFINE

Instanz einer Klasse erstellen

Beginn der Anweisungsliste Um eine Instanz einer Klasse zu erstellen

  • Benutzen Sie das CREATE OBJECT-Statement (siehe Natural Statements-Dokumentation).

Bestimmte Methode eines Objekts aufrufen

Beginn der Anweisungsliste Um eine bestimmte Methode eines Objekts aufzurufen

  • Benutzen Sie das SEND METHOD-Statement (siehe Natural Statements-Dokumentation).

Properties aufrufen

Auf Properties kann mit dem Statement ASSIGN (oder COMPUTE) wie folgt zugegriffen werden:

ASSIGN operand1.property-name = operand2
ASSIGN operand2 = operand1.property-name

Object Handle — operand1

Operand1 muss als eine Object-Handle definiert werden und identifiziert das Objekt, dessen Eigenschaft aufgerufen werden soll. Das Objekt muss bereits vorhanden sein.

operand2

Als operand2 geben Sie einen Operanden an, dessen Format datenübertragungskompatibel zu dem Format der Eigenschaft sein muss. Weitere Informationen siehe Kompatibilitätsregeln zur Datenübertragung.

property-name

Der Name einer Property des Objekts.

Stimmt der Name der Property mit der Natural Identifier Syntax überein, kann er wie folgt angegeben werden:

create object #o1 of class "Employee"
  #age := #o1.Age

Wenn der Name der Property nicht mit der Natural Identifier Syntax übereinstimmt, muss er in spitze Klammern gesetzt werden:

create object #o1 of class "Employee"
  #salary := #o1.<<%Salary>>

Der Name der Property kann auch mit einem Schnittstellen-Namen qualifiziert werden. Dies ist erforderlich, wenn das Objekt mehr als eine Schnittstelle hat, die eine Property mit demselben Namen enthält. In diesem Fall muss der qualifizierte Name der Property in spitzen Klammern stehen:

create object #o1 of class "Employee"
  #age := #o1.<<PersonalData.Age>>

Beispiel:

define data
  local
  1 #i         (i2)
  1 #o         handle of object
  1 #p         (5) handle of object
  1 #q         (5) handle of object
  1 #salary    (p7.2)
  1 #history   (p7.2/1:10)
  end-define
  * ...
  * Code omitted for brevity.
  * ...
  * Set/Read the Salary property of the object #o.
  #o.Salary := #salary
  #salary := #o.Salary
  * Set/Read the Salary property of
  * the second object of the array #p.
  #p.Salary(2) := #salary
  #salary := #p.Salary(2)
  *
  * Set/Read the SalaryHistory property of the object #o.
  #o.SalaryHistory := #history(1:10)
  #history(1:10) := #o.SalaryHistory
  * Set/Read the SalaryHistory property of
  * the second object of the array #p.
  #p.SalaryHistory(2) := #history(1:10)
  #history(1:10) := #p.SalaryHistory(2)
  *
  * Set the Salary property of each object in #p to the same value.
  #p.Salary(*) := #salary
  * Set the SalaryHistory property of each object in #p
  * to the same value.
  #p.SalaryHistory(*) := #history(1:10)
  *
  * Set the Salary property of each object in #p to the value
  * of the Salary property of the corresponding object in #q.
  #p.Salary(*) := #q.Salary(*)
  * Set the SalaryHistory property of each object in #p to the value
  * of the SalaryHistory property of the corresponding object in #q.
  #p.SalaryHistory(*) := #q.SalaryHistory(*)
  *
  end

Um Arrays von Objekt-Handles und Eigenschaften mit Arrays als Werte korrekt benutzen zu können, ist es wichtig, Folgendes zu wissen:

Eine Eigenschaft einer Array-Ausprägung von Objekt-Handles wird mit der folgenden Index-Notation adressiert:

#p.Salary(2) := #salary

Auf eine Eigenschaft, die ein Array als Wert hat, wird stets als Ganzes zugegriffen. Deshalb ist keine Index-Notation mit dem Namen der Eigenschaft erforderlich:

#o.SalaryHistory := #history(1:10)

Eine Eigenschaft einer Array-Ausprägung von Objekt-Handles, die ein Array als Wert hat, wird deswegen wie folgt adressiert:

#p.SalaryHistory(2) := #history(1:10)