WWS Synergie-Analyse

Werbung
Best Practices
Entwicklung mit VisualRPG.NET
Version 2.9 vom 16.6.2008
Autor:
Christian Neißl
-1Dokument D:\75878992.doc
INHALTSVERZEICHNIS
1.
Ziel ....................................................................... 9
2.
Einstellungen in VS.......................................... 10
2.1.
Zeilennummern ............................................................. 10
2.2.
Herausheben von Strings und Schriftgröße einstellen . 10
3.
Einführung in DataGate ................................... 11
3.1.
Anlegen einer Datenbank ............................................. 11
3.2.
Arbeiten mit der Datenbank .......................................... 12
3.3.
Anlegen einer Bibliothek ............................................... 13
3.4.
Anlegen von Physischen Files ...................................... 13
3.4.1. Automatisches Generieren von DDS......................................... 14
3.5.
Anlegen von Logischen Files ........................................ 14
3.6.
Erfassen/Bearbeiten von Daten .................................... 15
3.7.
Einrichten der Bibliotheksliste ....................................... 15
4.
Windows-Projekte ............................................ 16
4.1.
Anlegen eines Projekts ................................................. 16
4.2.
Einstellen des Startprogramms .................................... 17
4.3.
Bearbeiten der Oberfläche ........................................... 19
4.3.1. Hauptmenü erstellen ................................................................. 19
4.3.2. Funktionstasten zuordnen ......................................................... 19
4.3.3. Eigenschaften der Seuerelemente einstellen ............................ 20
4.4.
Der Einstieg in den ProgrammCode ............................. 20
4.5.
Start des Programms im Debug-Modus ....................... 21
4.6.
Treiben wir’s bunt ......................................................... 22
4.7.
Bunt ist gut aber … ....................................................... 23
5.
Ein Projekt planen ............................................ 24
-2Dokument D:\75878992.doc
INHALTSVERZEICHNIS
5.1.
Konzepte....................................................................... 24
5.1.1. Schichtenmodell........................................................................ 24
5.1.2. Klassen ..................................................................................... 24
5.1.3. Namespaces ............................................................................. 24
5.2.
Programmieren ............................................................. 25
5.2.1. Dokumentation .......................................................................... 25
5.2.2. Coderegionen ........................................................................... 25
5.2.3. Programmparameter ................................................................. 26
5.2.4. Datenbankverbindung zur Laufzeit erstellen ............................. 26
5.2.5. Gültigkeit und Lebensdauer von Objekten ................................ 27
5.3.
Übergabe von Parametern, Pointer in .NET ................. 29
5.4.
Funktionen und Subroutinen ........................................ 30
5.4.1. Funktionsaufruf ......................................................................... 30
5.4.2. Aufruf einer Subroutine ............................................................. 31
5.4.3. Wann verwende ich Funktionen, wann Subroutinen ................. 31
6.
Ein Projekt umsetzen ....................................... 32
6.1.
Hinzufügen einer Klasse zu einem Projekt ................... 32
6.2.
Design von Klassen ...................................................... 33
6.2.1. Organisation ............................................................................. 33
6.2.2. Benennung ............................................................................... 34
6.3.
Organisieren des Programmcodes ............................... 34
6.4.
Eine Klasse codieren .................................................... 35
6.5.
Datenbankverbindung und Klassen deklarieren ........... 38
6.6.
Objekte im UserInterface programmatisch erzeugen ... 40
6.7.
Die TAG-Eigenschaft .................................................... 40
6.8.
Casten eines Objekts ................................................... 41
6.9.
Startzeit des Programms optisch verkürzen ................. 41
6.9.1. AssemblyInfo ............................................................................ 42
-3Dokument D:\75878992.doc
INHALTSVERZEICHNIS
6.9.2. Integration des SplashScreens ................................................. 42
6.10. Application.DoEvents ................................................... 43
6.11. Grids füllen.................................................................... 43
6.12. Grids abfragen .............................................................. 44
6.13. MemoryFile – der neue Subfile ..................................... 45
6.14. Die RANGE-Befehle ..................................................... 46
6.15. Eigene Ereignisse erstellen und abfragen .................... 47
6.16. Inhalte in Grids selektieren ........................................... 48
6.17. Contextmenü erstellen und abfragen ........................... 49
6.18. Formulare aufrufen ....................................................... 49
6.19. Combobox- WertListe füllen ......................................... 50
6.20. Defaultwerte in Comboboxen ....................................... 51
6.21. Cursorreihenfolge festlegen ......................................... 53
6.22. Komfortable Datenerfassung ........................................ 53
6.23. Steuerung aktive TabPage ........................................... 54
6.24. DefaultButton für Eingabetaste festlegen ..................... 54
6.25. Tastencode abfragen .................................................... 55
6.26. Array mit Werten füllen ................................................. 55
6.27. Array aus String füllen .................................................. 55
6.28. DataGridView oder DataRow mit Werten füllen ........... 56
6.29. Werte in DataGridView berechnen ............................... 56
6.30. Combo- und Checkboxen als DataGridView-Spalten ... 57
6.31. Felder an MemoryFile anhängen .................................. 59
6.32. Daten in einer DataTable sortieren ............................... 59
6.33. Das TreeView ............................................................... 60
6.34. Kalenderwochenberechnung, Rekursionen .................. 62
6.35. Überladen von Funktionen (OO-Technik) ..................... 63
-4Dokument D:\75878992.doc
INHALTSVERZEICHNIS
6.36. Programmaufrufe .......................................................... 64
6.37. AS/400-API’s aufrufen .................................................. 64
6.37.1.
Benutzer des DG-Servicejobs auslesen ................................. 64
6.37.2.
DTAQ auslesen ..................................................................... 64
6.38. Datenstrukturen als iSeries-Programmparameter ........ 64
6.38.1.
Lösungsbeispiel Schnittstellenprogramme ............................. 65
6.39. Datenzugriff .................................................................. 67
6.40. Routinen aus iSeries-Programmen .............................. 67
6.41. F-Spec’s........................................................................ 68
6.42. Feld- und KeyDeklarationen ......................................... 68
6.43. Datenstrukturen ............................................................ 68
6.44. Datenstrukturen als Key – Teilkeys mit %KDS ............. 69
6.45. Datenstrukturen als Programmparameter .................... 71
6.46. Hilfsfunktionen .............................................................. 74
6.47. Gültigkeitsprüfungen ..................................................... 75
6.48. Drucken ........................................................................ 76
6.48.1.
RPG.NET – Printfiles ............................................................. 76
6.48.2.
Druckschleife ......................................................................... 77
6.49. Einbinden von 3rd-Party Komponenten ........................ 77
6.49.1.
Grafikdarstellung .................................................................... 78
6.50. Embedded SQL und offener Datenzugriff .................... 81
6.50.1.
Namespaces und Deklarationen ............................................ 82
6.50.2.
Event-Subroutinen ................................................................. 82
6.50.3.
ODBC .................................................................................... 83
6.50.4.
SQL-Server ............................................................................ 84
6.50.5.
OLEDB .................................................................................. 85
7.
Microsoft Office einbinden .............................. 86
-5Dokument D:\75878992.doc
INHALTSVERZEICHNIS
7.1.
Einfache Excel-Ausgabe .............................................. 86
7.2.
Performante Ausgabe einer Tabelle in Excel ............... 88
7.3.
Excel automatisieren .................................................... 88
7.4.
Beispielanwendung mit Excel ....................................... 89
7.5.
Lassen wir uns von Excel helfen .................................. 90
7.6.
Excel sieht Daten anders .............................................. 90
7.7.
Der Standard von Office-Produkten ............................. 90
7.8.
XML in Office ................................................................ 91
7.9.
Beispielanwendung mit Excel ....................................... 91
7.9.1. Verarbeitungsschritte ................................................................ 91
7.9.1.1.
Einlesen .................................................................................................. 91
7.9.1.2.
Prüfen ..................................................................................................... 92
7.9.1.3.
Update .................................................................................................... 92
7.9.2. Programmcode ......................................................................... 92
7.9.2.1.
Referenzen ............................................................................................. 92
7.9.2.2.
Deklarationen.......................................................................................... 92
7.9.2.3.
Constructor ............................................................................................. 94
7.9.2.4.
Events ..................................................................................................... 95
7.9.2.5.
Logik ....................................................................................................... 96
7.10. Office-Funktionen herausfinden ................................. 105
7.10.1.
Makro einsetzen................................................................... 105
7.10.2.
Vorsicht bei Formeln ............................................................ 106
7.11. Integration von Word und iSeries mit RPG.NET ........ 107
7.11.1.
Konzept ............................................................................... 107
7.11.2.
Umsetzung........................................................................... 108
7.11.2.1.
Kopf- und Fussinformationen ................................................................ 108
7.11.2.2.
Artikelpositionen ................................................................................... 109
7.11.3.
Das Ergebnis ....................................................................... 113
7.11.4.
Technische Voraussetzungen .............................................. 114
-6Dokument D:\75878992.doc
INHALTSVERZEICHNIS
7.11.5.
Programmcode Word ........................................................... 114
7.11.6.
Text in RTF-Box formatieren ................................................ 117
8.
Webseiten ....................................................... 122
8.1.
Anlegen eines Projekts ............................................... 122
8.2.
Anlegen einer Masterpage ......................................... 123
8.3.
Anlegen von Webseiten .............................................. 124
8.4.
Startseite festlegen ..................................................... 125
8.5.
Seitengröße festlegen ................................................ 125
8.6.
Seiten zeichnen .......................................................... 126
8.7.
Projektorganisation ..................................................... 126
8.8.
Programmierung ......................................................... 127
8.9.
Gestaltung .................................................................. 129
8.10. Global.ASAX ............................................................... 130
9.
WebServices erstellen ................................... 130
9.1.
Programmierung ......................................................... 131
9.2.
Bilder in XML-übertragen ............................................ 132
10.
WebServices nutzen ...................................... 133
11.
ASNA-Datagate Bibliotheksfunktionen ........ 135
11.1. DG-Datenbanken auslesen ........................................ 135
11.2. iSeries-Bibliotheksliste auslesen ................................ 136
11.3. Objektliste der iSeries-Bibliotheken auslesen ............ 137
11.4. Dateifeldbeschreibung auslesen ................................ 138
12.
Windows-Dienste programmieren ................ 140
12.1. Was ist ein Windows-Dienst ? .................................... 140
12.2. PROGRAM.VR - Basis des Dienstes ......................... 141
-7Dokument D:\75878992.doc
INHALTSVERZEICHNIS
12.3. ProcessInstaller.VR – Constructor ............................. 142
12.4. EnCryption.VR – Hier wird gearbeitet ......................... 143
12.5. MD5EnCryption.VR – Crypt nach MD5 ...................... 144
12.6. Den Windows-Dienst installieren / deinstallieren ........ 145
13.
Hintergrundverarbeitung ............................... 147
13.1. Start des BackGroundWorker-Jobs ............................ 148
13.2. Der Programmaufruf für den Worker-Job ................... 149
13.3. Der Programmende des Worker-Job’s ....................... 149
14.
DataGate aus VB oder C# verwenden .......... 150
14.1.1.
Deklarationen in VB – Vergleich RPG .................................. 150
14.1.2.
Sequentieller Zugriff in VB – Vergleich RPG ........................ 151
14.1.3.
Direktzugriff in VB – Vergleich RPG ..................................... 153
14.2. WinDialog – Aufruf von iSeries-Programmen ............. 154
14.2.1.
Deklaration von iSeries-Programmen in VB ......................... 154
14.2.2.
Aufruf von iSeries-Programmen in RPG............................... 155
14.2.3.
Aufruf von iSeries-Programmen in VB ................................. 155
15.
Die Beispielanwendung WinDialog in C#.NET ...... 156
16.
Programminstallation .................................... 159
16.1. Versionskonflikte zwischen DLL-Versionen lösen ...... 159
17.
Interfaces ........................................................ 160
17.1. Beispielanwendung UseInterfaces ............................. 161
17.2. Referenzstrukturen ..................................................... 163
-8Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
1. Ziel
Dieser Leitfaden hat das Ziel Entwickler mit Beispielen und Empfehlungen zu
unterstützen.
In DotNet haben wir alle das Problem aus den vielfältigen Lösungsansätzen zu einer
Aufgabenstellung den bestmöglichen Weg zu finden. Wie in RPG auch, gibt es nicht
immer ‚den besten Weg’ oder ‚die ideale Lösung’ sondern ein Spektrum an Ansätzen.
Neben grundlegenden Informationen finden Sie auch Anregungen und Empfehlungen
die Ihnen helfen mit RPG.NET in kurzer Zeit produktiv zu werden.
Die Beispiele stammen aus verschiedenen Projekten sind aber zum Thema in sich
abgeschlossen.
Gerne stehe ich für weitere Informationen zur Verfügung, ich freue mich aber auch über
Ihre Kritik und Verbesserungsvorschläge.
-9Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
2. Einstellungen in VS
2.1. Zeilennummern
Menü EXTRAS – OPTIONEN – TEXTEDITOR – ALLE
SPRACHEN.
Hier
Zeilennummern
anhaken.
2.2. Herausheben von Strings und Schriftgröße einstellen
Unter SCHRIFTARTEN und FARBEN – für String Farbe ROT einstellen. Auch die
Schriftart und die Größe wird hier eingestellt.
-10Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
3. Einführung in DataGate
DataGate ist die Datenbankschicht
die zwischen RPG.NET und den
Datenbanken der iSeries, SQLServer und der ASNA-eigenen
Windows-Datenbank Acceler8DB
liegt.
Wir werden in diesem Projekt auf
DataGate und der Acceler8DB
aufbauen da sie ebenso arbeitet
wie die iSeries-DB.
Es kann somit lokal entwickelt
werden, die Anwendung kann dann
per Definition gegen iSeries, SQLServer oder Acceler8DB gefahren
werden.
3.1. Anlegen einer Datenbank
Mit den DB-Wizard legen wir uns eine Projektdatenbank an.
Mithilfe des Browserfensters kann
Verzeichnis für die DB gewählt werden.
ein
-11Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Das Verzeichnis muss ANGELEGT und LEER sein.
3.2. Arbeiten mit der Datenbank
Mit
‚DATABASE-OPEN’
werden die vorhandenen
Datenbanken angezeigt.
Im
Fenster
‚Select
Database Names’ finden
wir die Datenbanknamen.
Hier können iSeries-DB,
SQL-Server und lokale DB
ausgewählt werden. Es gibt
für den DB-Manager keinen
Unterschied da er sich über
alle Datenbanken legt und
sie alle verwalten kann.
Mit Hilfe der Optionen wird beim ersten Öffnen die
Standardeinstellung für die Sicht gewählt. Die neue DB
enthält nur die QTEMP.
-12Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
3.3. Anlegen einer Bibliothek
Über ‚Objekt – Create Library’ wird eine Bibliothek angelegt.
3.4. Anlegen von Physischen Files
Über
‚Definition
–
Create
Database File – Physical’ werden
physische Dateien angelegt.
Die Arbeit mit den Datenfeldern ist in der WorkArea des DB-Managers zu machen.
ACHTUNG – AS/400 und Acceler8DB – Datenbanken erlauben keine NULL-Felder.
Mit ADD werden die Felder hinzugefügt,
gespeichert wird mit DONE. Keyfelder werden mit
ADDKEY bestimmt.
-13Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Um den File in der Bibliothek zu
erstellen genügt es die Datei mit der
Maus von der WORKAREA in die
gewünschte Bibliothek zu ziehen und
die Erstellung zu bestätigen.
3.4.1.
Automatisches Generieren von DDS
ACHTUNG – für Files die Sie auf der iSeries erstellen kann automatisch eine DDS
generiert werden. Beachten Sie die Einstellung in VIEW – OPTIONS.
3.5. Anlegen von Logischen Files
Logische Files werden über Physischen erstellt.
Die Bearbeitung von Keyfeldern erfolgt wie bei
den PF in der WorkArea.
-14Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
3.6. Erfassen/Bearbeiten von Daten
Unter der Bibliothek wird der File dargestellt,
innerhalb des Files finden wir die Members.
Durch Links-Klick auf Member wird eine
Browser-Übersicht angezeigt, mit Rechts-Klick
öffnet sich ein KontextMenü über das die
Bearbeitung der Daten ausgewählt werden
kann.
3.7. Einrichten der Bibliotheksliste
Bei geöffneter Datenbank
eingerichtet werden.
kann
die
Bibliotheksliste
Unter der Karte INITIAL
die Bibliotheksliste Zeile
für Zeile eingeben und
OK drücken.
-15Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
4. Windows-Projekte
4.1. Anlegen eines Projekts
Nach
Start
von
VisualStudio2005
das Menü DATEINEU-PROJEKT
auswählen.
Das Verzeichnis ‚Workshop* unter
Laufwerk C anlegen.
Projekttyp ‚WindowsApplication’
Name ‚WWS’ angeben und
drücken.
und
OK
Das Ergebnis ist ein leeres Projekt.
-16Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
4.2. Einstellen des Startprogramms
Wir wollen ein Projekt mit mehreren Formularen
erstellen. Das Hauptformular soll nicht wie
Standardmäßig angelegt ‚Form1’ heißen sondern
‚frmMain’.
Deswegen löschen wir das Form1 per MausklickRechts mit ENTFERNEN und LÖSCHEN.
Damit wird das Formular unwiderruflich entfernt.
Danach legen wir mit HINZUFÜGEN eine neue
Windows-Form mit dem Namen ‚frmMAIN’ an.
-17Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Das
Startformular
für
das
Projekt
wird
in
PROJEKTEIGENSCHAFTEN festgelegt. Wir stellen
Formular WWS.frmMAIN ein.
Der Text wird auf ‚WWSHauptprogramm
festgelegt.
Unter ICON wählen wir
die DISC aus dem ICONVerzeichnis.
(Liegt auf CD bei)
-18Dokument D:\75878992.doc
den
das
RPG.NET BESTPRACTICES
4.3. Bearbeiten der Oberfläche
4.3.1.
Hauptmenü erstellen
Durch KLICK und Ziehen des
Symbols wird das Control auf
der Oberfläche des Formulars
erstellt.
Unsere Menüstruktur sollte am Ende so
aussehen wie hier gezeigt.
Den Unterstreichungsstrich, zugleich auch
der Tastencode wird durch ein ‚&’ vor dem
gewünschten Zeichen erreicht.
Den Strich zwischen EINSTELLUNGEN
und ENDE bekommt man durch Eingabe
eines ‚-‚ im Text.
4.3.2.
Funktionstasten zuordnen
Jedes Windows-Programm
sollte auch ohne Maus
problemlos bedienbar sein.
Darum werden wir in den
Eigenschaften unseren
Menüeinträgen F-Tasten
zuordnen.
Der Menüeintrag bietet dazu
die Eigenschaft
SHORTCUTKEYS.
Für ENDE stellen wir F3 ein
-19Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
4.3.3. Eigenschaften der Seuerelemente einstellen
Jedes Steuerelement bekommt einen eindeutigen
Namen wie ein Feld in einem Bildschirmformat.
Der Name wird von VS generiert, wir möchten natürlich
die Namen selbst festlegen.
Neben dem Namen können jede Menge Eigenschaften
eingestellt werden. Jedes Steuerelement hat auf Grund
seiner Eigenheiten auch bestimmte Eigenschaften die
in dem EIGENSCHAFTEN-Dialog von VS zur
ENTWICKLUNGSZEIT eingerichtet werden.
Alle Eigenschaften können auch während der Laufzeit
des Programms festgelegt werden. Beispiele folgen.
Wir fahren mit der Benennung der Steuerelemente
und benennen die horizontal angelegten Einträge
dem Prefix ‚mnu’ und Ihrem Namen da sie
Hauptmenü, die vertikalen Einträge als ‚itm’ da
einen Eintrag darstellen.
fort
mit
ein
sie
Also: mnuDatei, mnuBelege, mnuHilfe,
itmEinstellungen, itmEnde.
Im DropDown des Eigenschaften-Editors
finden
wir
alle
Controls
unseres
Formulars.
4.4. Der Einstieg in den ProgrammCode
Jedes Steuerelement hat nicht nur Eigenschaften sondern auch Ereignisse. VS stellt uns
ein ‚Default’-Ereignis zur Verfügung. Durch DoppelKlick auf das Steuerelement kommen
wir in den Code und werden in eine sog. Ereignis-Subroutine befördert.
Der ‚Blitz’ in den Steuerelementen wechselt
von der Eigenschaften- in die Ereignissicht.
Wie wir sehen hat VS die Ereignissubroutine
bereits erstellt und zeigt sie als itmEnde_Click
in den Ereignissen an.
-20Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
In diese
Programmroutine
tragen wir den Befehl
*this.Close()
ein.
Damit haben wir für
den Menüeintrag eine
Anweisung zum
schließen des
Programms
festgelegt.
4.5. Start des Programms im Debug-Modus
Das Programm ist nun ausführbar. Wir starten mit F5 oder dem Pfeil wie in den
Symbolen vom guten alten Kassettenrekorder.
Das Programm fährt hoch, das Menü lässt sich
bedienen, durch Menüklick oder F3 endet das
Programm
Wir haben ja auch sonst noch nichts
programmiert, aber immerhin fragen wir bereits F3
ab.
Vergleichen Sie das mit dem Aufwand den Sie haben um das in einem iSeriesRPGProgramm zu machen.
-21Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
4.6. Treiben wir’s bunt
Was wären Windows-Programme ohne Icons? Gar Nichts.
Wir werden nun den Menüs möglichst sinnige Icons zuordnen. Auf der CD ist ein
Verzeichnis mit Icons, wir nehmen für die Menüeinträge die im Verzeichnis 16x16.
Im Eigenschaften-Editor klicken wir auf die
Eigenschaft IMAGE.
Mit dem Auswahlbutton öffnen wir ein Fenster in
dem
wir
auf
LokaleRessource
und
IMPORTIEREN drücken.
Wir
kommen
in
einen
OpenFileDialog und öffnen dort das
Verzeichnis mit den Icons 16x16
für ENDE wählen wir das Icon
DELETE_16.ico
ACHTUNG – im Dropdown des ÖffnenDialogs zuerst ‚ALLE DATEIEN’
einstellen.
Weisen Sie den Menüelementen Icons nach Ihrem
Geschmack zu.
-22Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
4.7. Bunt ist gut aber …
Bedenken Sie bei Ihren Projekten dass Sie sich in der Windows-Welt befinden in der
sich Moden und Zeitgeist widerspiegeln.
Sie können mit VS jedes Programm einfärben wie es Ihnen gefällt, sie verlieren aber
dadurch die Möglichkeit den Look&Feel von Betriebssystemversionen zu erben.
Windows-Programme passen sich im Erscheinungsbild dem Betriebssystem automatisch
an. Wenn nun ein Benutzer ein besonderes Farbschema oder ein neues Betriebssystem
eine besondere Standardfarbe für Steuerelemente wählt bleibt die Darstellung Ihres
Programms auf dem von Ihnen gesetzten Standard.
Die Konsequenz davon ist dass Ihre Programme in kürzeren Abständen überarbeitet
werden müssen als vom Programmcode her nötig.
Halten Sie folgende Regeln für Bildschirmdialoge ein:




Weisen Sie Farben für Steuerelemente nur im Ausnahmefall zu
Orientieren Sie sich an der Optik von Microsoft-Programmen
Geben Sie Standard-Microsoft-Steuerelementen den Vorzug vor zugekauften
oder geschenkten 3rd-Party Tools
Umso einfacher und selbsterklärender ein Programm ist umso weniger Probleme
haben Sie
-23Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
5. Ein Projekt planen
5.1. Konzepte
5.1.1.
Schichtenmodell
Die wichtigste Regel ist dass die Anwendung in Schichten aufzubauen ist. Es geht
darum die Zugriffe auf die Daten von der Dialogschicht zu trennen.
Der Vorteil ist dass die Logik als Basis erhalten bleibt während die Dialoge dem Wandel
der Zeiten stärker Rechnung tragen müssen und kürzeren Veränderungszyklen
unterworfen sind.
Ein weiterer Vorteil dieses Schichtenmodells unter DotNet ist dass die Anwendungen die
Logik in RPG.NET verwenden nicht zwingend in RPG geschrieben sein müssen.
Sehr oft werden in RPG.NET nur die Logikmodule erstellt, die Dialoge werden in VB oder
C# geschrieben.
In diesem Modell sehen Sie wie eine Windows- und eine Webanwendung ein
Logikmodul verwenden.
Logikmodul
Datenbank
5.1.2.
Klassen
In DotNet ist alles ‚Klasse’ – dem entsprechend muss auch unsere Anwendung ein
sauberes Klassenmodell mitbringen.
Das Verstehen des Klassenmodells ist für den RPG-Programmierer kein Problem sofern
er mit strukturierter Programmierung vertraut ist.
5.1.3.
Namespaces
Die Funktionsbibliotheken werden in DotNet in ‚Namespaces’ organisiert. Um eine gute
Anwendungsarchitektur zu entwickeln werden unsere Programme auch mit Namespaces
arbeiten.
-24Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
5.2. Programmieren
5.2.1.
Dokumentation
Wie allgemein üblich sollte
man
Programme
beschreiben.
In RPG.NET wird mit // eine
Zeile auskommentiert.
Ich habe mir angewöhnt
meine
Dokumentationen
mit /// zu markieren da sie
dadurch
von
einer
auskommentierten
Programmzeile
unterschieden
werden
kann.
5.2.2.
Coderegionen
VS bietet mit den Coderegionen eine sehr praktische Möglichkeit Code der nicht
gebraucht wird aus der Optik zu nehmen.
Mit den Coderegionen werden Bereiche im Sourcecode thematisch gegliedert. Durch
Klick auf den Knoten werden die Bereiche angezeigt oder versteckt.
-25Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
5.2.3. Programmparameter
DotNet bietet ein organisiertes Umfeld, dazu gehört auch dass mit Programmparametern
in einer bestimmten Art und Weise umgegangen wird.
Die APP.CONFIG ist eine XML-Datei die für den Zweck vorgesehen ist, die Parameter
werden mit dem AppSettingsReader eingelesen, siehe nächstes Kapitel.
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<!--
Eigene Einstellungen
Platz für Programmparameter
-->
<appSettings>
<!-<add
<add
<add
<add
<add
<add
<add
<add
Parameter für DB-Verbindung zur Laufzeit -->
key="DBName" value="*Public/MAC"/>
key="Server" value="192.168.1.6"/>
key="Label" value="DB2"/>
key="Port" value="5042"/>
key="User" value="MAC"/>
key="PW" value="MAC"/>
key="Description" value="for demonstration purposes"/>
key="Libl" value="ZMODERN;"/>
<!-<add
<add
<add
<add
<add
ProgrammParameter -->
key="Fehlermail" value="mailto:[email protected]?Subject=Fehlermeldung-MT800Win"/>
key="WartungsTimeOutSek" value="30"/>
key="PicturePath" value="C:\NiceWare\ASNA\Interessenten\MACSchweiz\Bilder\"/>
key="PictureExtension" value=".jpg"/>
key="Vertrag" value="C:\NiceWare\ASNA\Interessenten\MACSchweiz\Vorlagen\Vertrag.doc"/>
<add key="ListenTitelBild" value="C:\NiceWa..\ASNA\Intere..\MACSch..\Graf..\Mac-Logo.bmp"/>
</appSettings>
</configuration>
5.2.4.
Datenbankverbindung zur Laufzeit erstellen
Um am Client möglichst wenig installieren zu müssen kann man das Programm so
konzipieren dass die DB-Verbindung die zur Laufzeit aus Parametern erstellt wird.
Diese DB-Verbindung wird dann an die Logikmodule weitergegeben dass die
Anwendungsprogramme nur mehr die Logikmodule benötigen und sich nicht um die DBVerbindung kümmern müssen.
Die Parameter werden bei Programmstart aus der APP.CONFIG eingelesen, dann wird
die DB-Verbindung aufgebaut.
Wenn unter dem Usernamen der Sonderwert *PROMPT eingestellt ist muss sich der
Benutzer in einem Login-Fenster anmelden. Es kann natürlich ein Standarduser
festgelegt werden.
/// wird bei Programmstart ausgeführt
BegSr Form1_Load Access(*Private) Event(*this.Load)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
/// Hilfsfelder für Bibliotheksliste
DclFld cSplit Type(*Onechar) Inz(";")
DclFld strLibl *string
-26Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
/// DB-Verbindungsparameter aus APP.CONFIG einlesen
With dbSession
.DBName
= asrApp.GetValue("DBName", Type.GetType("System.String")) *as String
.Server
= asrApp.GetValue("Server", Type.GetType("System.String")) *as String
.Label
= asrApp.GetValue("Label", Type.GetType("System.String")) *as String
.Port
= asrApp.GetValue("Port", Type.GetType("System.String")) *as String
.User
= asrApp.GetValue("User", Type.GetType("System.String")) *as String
.Password
= asrApp.GetValue("PW", Type.GetType("System.String")) *as String
.Text
= asrApp.GetValue("Description", Type.GetType("System.String")) *as String
strLibl
= asrApp.GetValue("Libl", Type.GetType("System.String")) *as String
/// Bibliotheksliste aufbereiten
.InitialLibl= strLibl.Split(cSplit)
EndWith
/// DB-Verbindung aufbauen mit strukturierter Fehlerbehandlung
Try
stb.Text = "Baue Verbindung mit " + dbSession.DBName + " auf ..."
Connect dbSession
Catch Name(dgEx) Type(ASNA.DataGate.Common.dgException)
MsgBox Msg("Datagate meldet: " + %Unicode(13) + dgEx.Message) +
Icon(*Stop) Title("Datenbankverbindung zu " + dbSession.DBName + " fehlerhaft")
LeaveSr
Catch Err Type(System.Exception)
MsgBox Msg(Err.Message) Icon(*Stop) Title ("Verbindung zu Datenbank " +
bSession.DBName + " fehlerhaft")
LeaveSr
EndTry
…
EndSr
5.2.5.
Gültigkeit und Lebensdauer von Objekten
Grundregeln:
o Objekte nur so lange bestehen zu lassen solange es unbedingt nötig ist
o je weniger ein Benutzer einer Klasse über die internen Abläufe wissen muss umso
besser ist es
Die Lebensdauer des Objekts beginnt mit der Instanzierung und endet mit dem
Programmende bzw. Verlassen des Gültigkeitsbereiches des Objekts.
Die Gültigkeit von Objekten kann über die Eigenschaft Access eingestellt werden.
Es gibt hier folgende Möglichkeiten:
Access
Optional. The type of access to the field. *PRIVATE is the default.

*PRIVATE (default) - access to the field is accessible only from within their declaration
context, including from members of any nested types, for example from within a nested
procedure or from an assignment expression in a nested enumeration.

*PUBLIC - access to the field is accessible from anywhere within the same project, from other
projects that reference the project, and from an assembly built from the project.

*PROTECTED - access to the field is accessible only from within the same class, or from a
class derived from this class.

*INTERNAL - access to the field is accessible from within the same project, but not from
outside the project.
*PRIVATE
-27Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Gilt im Kontext der Deklaration und darunter.
Wird ein Objekt mit *PRIVATE deklariert ist es von außen nicht sichtbar. Wird ein Objekt
an oberster Ebene einer Klasse deklariert ist es innerhalb dieser Klasse überall
verfügbar. Wird es einer Subroutine deklariert so lebt das Objekt (im Normalfall) von der
Instanzierung bis zum Ende der Subroutine.
*PUBLIC
Gilt überall, ist auch aus jeder Klasse die das Objekt verwendet sichtbar.
*PROTECTED
Objekt ist nur in dieser Klasse oder einer abgeleiteten Klasse sichtbar.
*INTERNAL
Objekt ist nur in dieser Assembly sichtbar, ähnlich wie *PUBLIC, aber nicht von außen.
Gelten in ganzer Klasse
da sie mit *PRIVATE
(Default) an oberster
Ebene in der Klasse
deklariert sind.
Gelten nur in dieser Subroutine und
werden bei nächstem Aufruf wieder
neu initialisiert.
-28Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
5.3. Übergabe von Parametern, Pointer in .NET
Es gibt wie in jeder modernen Entwicklungsumgebung die Möglichkeit Parameter als
Wert oder Verweis (Pointer auf ein Objekt) zu übergeben.
Diese Vorgangsweise nennt man Call by Value (Wertübergabe) oder Call by Reference
(Verweis mit Pointer).
Hier sei angemerkt dass es .NET keine Pointeroperationen anbietet da es gegen die
Plattformunabhängigkeit ist. Natürlich arbeitet .NET intern mit Pointer.
In unserem Beispiel sieht der Aufruf der Logon-Methode so aus:
If cUser.Logon(*ByRef cUserDaten, txtKennwort.Text)
Hier werden also 2 Parameter übergeben, das Objekt cUserDaten per Reference und
das Kennwort per Value.
Auf der Empfänger-Seite werden die Parameter so übernommen:
BegFunc Logon Type(*boolean) Access(*Public)
DclSrParm
cUserDaten
Type(UserDaten)
By(*REFERENCE)
DclSrParm
cKennwort
Type(*char)
Len(20)
Das heißt dass die UserDaten nicht wirklich übertragen werden sondern über einen
Pointer das Objekt des Aufrufers direkt bearbeitet wird.
Aufrufer:
Klasse User
BegFunc Logon
UserDaten
Kennwort
Type(*boolean) Access(*Public)
DclSrParm
cUserDaten
By(*REFERENCE)
Type(UserDaten)
DclSrParm
cKennwort
Len(20)
Type(*char)
Kennwort
If cUser.Logon(*ByRef cUserDaten,
txtKennwort.Text)
Hier wird deutlich was *ByRef bewirkt. Die aufgerufene Methode arbeitet mit dem
Original-Objekt, im anderen Fall wird eine Kopie des aufrufenden Objekts erstellt.
Ale Empfehlung kann gesagt werden dass ein CallByValue zu bevorzugen ist wenn die
übergebenen Daten verändert werden und nicht an den Aufrufer zurückgegeben werden
müssen.
CallByRef verwende ich in diesem Beispiel weil ich das Objekt UserDaten bearbeite und
die Daten an den Aufrufer übergeben möchte.
Da die Funktion mir außerdem über den Rückgabewert noch mitteilt ob die Operation
erfolgreich war oder nicht verwende ich CallByRef.
-29Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
5.4. Funktionen und Subroutinen
In RPG.NET wird zwischen Funktionen und Subroutinen unterschieden. Funktionen
geben einen Wert an den Aufrufer zurück, Subroutinen nicht. Parameter können von
beiden übernommen werden.
5.4.1.
Funktionsaufruf
BegFunc Logon Type(*boolean) Access(*Public)
DclSrParm
cUserDaten
Type(UserDaten)
By(*REFERENCE)
DclSrParm
cKennwort
Type(*char)
Len(20)
Der Name der Funktion ist ‘Logon’, der Rückgabewert ist vom Typ ‘*boolean’, also Wahr
oder Falsch. In RPG wären das die Indicator (*INxx) mit ‚1’ für Wahr und ‚0’ für Falsch.
Hier werden zwei Parameter übergeben.
Der Aufruf dieser Funktion ist eigentlich eine Abfrage
If cUser.Logon(*ByRef cUserDaten, txtKennwort.Text)
…
Else
…
Endif
Da die Funktion einen Wert zurückgibt der aussagt ob die Operation erfolgreich war oder
nicht kann im aufrufenden Code direkt auf den Rückgabewert Bezug genommen werden.
Eine umständlichere aber ebenso mögliche Variante wäre:
DclFld bWarAufrufOK Type(*boolean)
bWarAufrufOK = cUser.Logon(*ByRef cUserDaten, txtKennwort.Text)
If bWarAufrufOK = *true
…
Else
…
Endif
Jeder Funktionsaufruf muss seinen Rückgabewert an den Aufrufer zurückliefern. Das
übernimmt der Befehl LeaveSr.
Im Programmcode muss der Typ deklariert und der Wert zugewiesen werden.
///-----------------------------------------------------------------/// Controller über das Einlesen der OPDaten, Übergabe per Reference
///-----------------------------------------------------------------BegFunc GetOPData
Type(*boolean) Access(*Public)
DclSrParm
cUserDaten
Type(UserDaten)
By(*REFERENCE)
DclSrParm
cOPDaten
Type(OPDaten)
By(*REFERENCE)
DclFld
bOK
Type(*boolean)
...
LeaveSr bOK
EndFunc
-30Dokument D:\75878992.doc
Inz(*false)
RPG.NET BESTPRACTICES
5.4.2. Aufruf einer Subroutine
In dieser Programmzeile wird die Subroutine ‚GetLinkTable’ aufgerufen der ein
Parameter per Reference übergeben wird.
/// Einlesen der Linktabelle
GetLinkTable(*ByRef cUserDaten)
Hier ist der Beginn der Subroutine mit der Übernahme des Parameters.
///-----------------------------------------------------------------/// Einlesen der Linktabelle für das Portal über den iSeries /// Usernamen - wird nichts gefunden bleibt die Tabelle *NOTHING
///-----------------------------------------------------------------BegSR GetLinkTable
DclSrParm
cUserDaten
Type(UserDaten)
By(*REFERENCE)
5.4.3.
Wann verwende ich Funktionen, wann Subroutinen
Muss jeder für sich entscheiden, generell verwende ich gerne Funktionen die einen
Bool’schen Wert zurückgeben damit ich im aufrufenden Programm erkenne ob der Aufruf
erfolgreich war oder nicht.
Es hängt von der Aufgabe ab ob ich Parameter übergebe oder global gültige Variable
verwende.
Generell gilt soviel wie möglich zu kapseln und eindeutige Schnittstellen zwischen den
Programmteilen festzulegen.
Umso mehr global gültige Variablen im Programm vorhanden sind umso schwieriger ist
es zu warten.
-31Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6. Ein Projekt umsetzen
6.1. Hinzufügen einer Klasse zu einem Projekt
Wie wir bereits im Beispiel mit dem
Formular gesehen haben können
verschiedenste Elemente zu einem
Projekt hinzugefügt werden.
In unserem Beispiel brauchen wir eine
Klasse die Business-Logik enthält um
den Datenzugriff von der Oberfläche zu
trennen.
Die KLASSE wird direkt angeboten,
also nehmen wir sie auch aus dem
Kontextmenü.
Wir benennen Sie
clsParameter.vr und drücken
HINZUFÜGEN.
Das Ergebnis ist die leere
Klasse.
-32Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.2. Design von Klassen
6.2.1.
Organisation
Klassen haben die Aufgabe Business-Logik zu kapseln und Ergebnisse zu liefern.
Umso weniger ein Benutzer einer Klasse über die darin enthaltene Logik wissen
muss umso besser ist es.
Klassen sollten außerdem themenbezogen und weniger datenbezogen sein. Es geht
darum einen ‚BusinessCase’ abzudecken.
Ein solcher kann das zur Verfügungstellen von Belegdaten sein die in einer Klasse
übergeben werden.
Die Datenklasse die zwischen Oberfläche und Logik hin- und her gereicht wird kann
Daten aus den unterschiedlichsten Quellen enthalten, wichtig ist dass die Daten aus
einem logischen Gesichtspunkt zusammengefasst werden.
Datenklasse
Logikmodul
Datenbank
Beispiel Belegdaten:
Die Datenklasse enthält: Belegkopf
Belegpositionen
Die Logik bietet Funktionen wie: LeseBeleg()
SchreibeBeleg()
DruckeBeleg()
Um diese Funktionen anbieten zu können müssen verschiedenste Dateien verarbeitet
werden.
Wenn Sie nun eine Datenklasse für Kopfdaten und eine weitere für Positionsdaten
anbieten würden so müsste der Benutzer der Klasse wissen welche Daten
zusammengehören um eine Funktion ausführen zu können.
Beachten Sie dass es nicht immer so sein wird dass die Oberfläche von Programmen
von Entwicklern erstellt wird denen die Funktionen des Programms klar sind und die aus
diesem Verständnis heraus arbeiten.
-33Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.2.2. Benennung
Klassen und deren Eigenschaften und Funktionen sollen sprechend benannt werden.
Auch hier gilt es daran zu denken dass einem Entwickler die Bezeichnung ‚ARIKELNR’
mehr sagt als BPATNR.
Zum einen ist dem Benutzer einer Klasse die Herkunft des Datenfeldes völlig egal da er
sich nur um die Datenklasse kümmern braucht.
Zum anderen muss er bei dieser Benennung entweder einen Entwickler fragen oder in
der Projektdokumentation nachlesen.
All das kann man sich ersparen wenn man die Schnittstellen so entwirft dass es kaum
Fragen zu Feldinhalten oder Funktionen gibt.
Hier sind die Leiter der Entwicklungsabteilungen gefordert Richtlinien auszuarbeiten an
die sich die Entwickler zu halten haben.
6.3. Organisieren des Programmcodes
Nachdem wir bereits in den Code reingesehen
haben wollen wir auch gleich mal Ordnung
machen.
Mit dem Codefenster können wir die Codesicht
auswählen.
Wir sehen dass VS in unser Projekt bereits
nach dem erstellen eines Projekts etliche
Codezeilen produziert hat.
Mit den Coderegionen können wir unser Projekt
ideal strukturieren.
Achten Sie darauf dass die Region ‚Ereignisse’
am Ende des Codes steht da VS die
Ereignisroutinen immer am Ende erstellt.
-34Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.4. Eine Klasse codieren
Die Parameterklasse hat
die Aufgabe Parameter
einzulesen. Auch hier
werden wir eine
Datenklasse als
Schnittstelle verwenden.
Wie jedes Programm
sollte auch die Klasse
eine Dokumentation im
Programmkopf haben.
Die Deklarationen für die Klasse werden direkt unterhalb der BEGCLASS gemacht.
DB-Verbindungen zur
Umwandlungszeit und zur Laufzeit
/region Deklaration der Arbeitsfelder
/// Datenbankverbindung
DclDB
Name(dbRuntime)
DclDB
Name(dbCompile)
DBName("")
DBName("*Public/Workshop")
/// iSeries-Tabellen
DclDiskFile
Name(PFINH)
Org(*Indexed) DB(dbCompile) ImpOpen(*NO)
File("*LIBL/PFINH")
Type(*Input)
/// Datenfelder für Properties
DclFld
Name(strErrorMessage) Type(*string)
/// Keylists und Keyfelder
DclKlist
k2PFINH
DclKFld kfFIRM
DclKfld kfPARM
Fehlerinfo als Datenfeld
für die Property
/// Keylists und Keyfelder
DclKlist
k3PFINH
DclKfld kfFIRM
DclKfld kfPARM
DclKfld kfKEY
KeyListen
/// Keyfelder deklarieren
DclFld kfFIRM
Like(PFFIRM)
DclFld kfPARM
Like(PFPARM)
DclFld kfKEY
Like(PFKEY)
Keyfelder von DB-Felder ableiten
/// Parameterwerte - Tabelle
DclFld dtParameterWerte
Type(DataTable)
Datentabelle für Parameterwerte
-35Dokument D:\75878992.doc
File-Deklarationen
RPG.NET BESTPRACTICES
Datenklasse für Transport der Daten
zwischen Dialog und Business-Logik
/// Parameterklasse
BegClass
clsParmData
Access(*Public)
/// Firmennummer
DclFld
Firma
DclFld
Parameter
DclFld
Key
Type(*string)
Type(*string)
Type(*string)
Access(*Public)
Access(*Public)
Schlüsselfelder
für Zugriff
Access(*Public)
auf Parameterdatei
/// Wertliste in DataTable
DclFld
ParameterWerte
Type(DataTable)
Access(*Public)
/// Anzahl der Datensätze
DclFld
Anzahl
Type(*integer4)
Access(*Public)
EndClass
Satzanzahl in Tabelle
Rückgabe der Parameter
in Form einer Tabelle
Eigenschaft ErrorMessage
deklarieren
/// Properties wie ErrorMessage
BegProp
ErrorMessage
Type(*string)
BegGet
LeaveSr strErrorMessage
EndGet
EndProp
Access(*Public)
/endregion
Der Konstruktor übernimmt die DB-Verbindung, erstellt die Parametertabelle und öffnet
die Parameterdatei. Die CLOSE-Methode schließt die Datei.
/region Konstruktor
BegConstructor Access(*Public)
DclSrParm
db
Type(ASNA.VisualRPG.Runtime.Database)
/// dbVerbindung speichern
dbRuntime = db
/// Datentabelle erstellen
dtParameterWerte = *new DataTable()
dtParameterwerte.Columns.Add("Name", Type.GetType("System.String"))
dtParameterwerte.Columns.Add("Key", Type.GetType("System.String"))
dtParameterwerte.Columns.Add("Wert", Type.GetType("System.String"))
dtParameterwerte.Columns.Add("Bezeichnung", Type.GetType("System.String"))
Try
Open
PFINH DB(dbRuntime)
Catch ex Exception
strErrorMessage = ex.Message
EndTry
EndConstructor
BegSr
Close
Try
Access(*Public)
Close PFINH
Catch ex Exception
strErrorMessage = ex.Message
EndTry
EndSr
/endregion
-36Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Die Methode ‚LESEPARAMETER’ liest Daten aus der Parameterdatei und übergibt sie in
die Tabelle der Datenklasse. ACHTUNG – die Übergabe der Datenklasse erfolgt PER
REFERENCE – d.h. es wird nur ein Verweis auf das Objekt im Speicher des
Aufrufenden Programms übergeben aber nicht das tatsächliche Objekt.
/region Subroutinen
/// Einlesen der Parameter
BegFunc LeseParameter
DclSrParm cParmData
Type(*boolean)
Access(*Public)
Type(clsParmData)
By(*reference)
/// DataRow deklarieren
DclFld dr
Type(DataRow)
/// Rückgabewert deklarieren
DclFld bOK
*boolean
/// Datentabelle immer mit leerer Tabelle überschreiben
cParmData.ParameterWerte
= dtParameterWerte.Copy()
cParmData.Anzahl
= *zero
/// Schlüssel setzen und Lesen
kfFIRM = cParmData.Firma
kfPARM = cParmData.Parameter
kfKEY = cParmData.Key
/// Fehler abfangen
Try
/// wenn Key leer ganzen Bereich einlesen
If kfKEY = *blank
ReadRange
PFINH
FirstKey(k2PFINH)
Else
Chain
PFINH
Key(k3PFINH)
Endif
LastKey(k2PFINH)
/// Schleife
DoWhile not %eof
/// Zeile in Tabelle erstellen und mit Werten fülllen
dr = cParmData.ParameterWerte.NewRow()
dr.Item("Name")
= PFPARM
dr.Item("Key")
= PFKEY
dr.Item("Wert")
= PFWERT
dr.Item("Bezeichnung") = PFBEZ
/// Zeile in Datentabelle anhängen
cParmData.ParameterWerte.Rows.Add( dr )
/// nächsten Satz lesen
Read
PFINH
EndDo
bOK = *true
Catch ex Exception
strErrorMessage = ex.Message
bOK = *false
EndTry
LeaveSr bOK
EndFunc
/endregion
-37Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.5. Datenbankverbindung und Klassen deklarieren
Im Hauptprogramm, frmMain sollten keine Dateideklarationen zu finden sein.
Die Datenbankverbindung aber muss im Hauptprogramm angelegt werden da sie
ausgehend vom Hauptprogramm an die Klassen weitergegeben werden soll.
Der DBName wird aus der Parameterdatei APP.CONFIG eingelesen.
Dafür wird auch ein Objekt, der APPSETTINGSREADER erstellt.
Damit mit der Paramerterklasse gearbeitet werden kann werden die Klasse selbst und
die Datenklasse angelegt. Dazu gehört auch eine Konstante mit dem Key für unsere
Belegtypen.
/region Eigene Deklarationen
/// Datenbankverbindung
DclDB Name(dbRuntime)
/// Objekt zum Einlesen der Parameter aus App.Config
DclFld asrApp Type(System.Configuration.AppSettingsReader) new()
/// Parameter aus DB einlesen
DclFld cParameter
Type(clsParameter)
DclFld cParamBelege
Type(clsParameter.clsParmData)
/// Konstante Felder
DclConst
conBelegtyp
Objekt deklarieren
(Objekt im Speicher
anlegen)
Value("BELEGTYP")
/endregion
Der Konstruktor eröffnet die DB-Verbindung, die Routine dazu liegt in der Region
SUBROUTINEN.
BegConstructor Access(*Public)
//
// Required for Windows Form Designer support
//
InitializeComponent()
//
// TODO: Add any constructor code after InitializeComponent call
//
/// wenn es Probleme bei der DB-Verbindung gibt Programm beenden
if not GetDBConnection()
LeaveSr
Endif
EndConstructor
/region Subroutinen
/// erstellen der DB-Verbindung
BegFunc GetDBConnection
Type(*boolean)
Auslesen DB-Name aus APP.CONFIG
und erstellen der Verbindung
/// DB-Verbindungsparameter aus APP.CONFIG einlesen
dbRuntime.DBName = asrApp.GetValue("DBName", Type.GetType("System.String"))
*as String
/// DB-Verbindung aufbauen mit strukturierter Fehlerbehandlung
Try
Connect dbRuntime
-38Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Catch Name(dgEx) Type(ASNA.DataGate.Common.dgException)
MsgBox Msg("Datagate meldet: " + %Unicode(13) + dgEx.Message) +
Icon(*Stop) Title("Datenbankverbindung zu " +
dbRuntime.DBName + " fehlerhaft")
LeaveSr *false
Catch Err Type(System.Exception)
MsgBox Msg(Err.Message) Icon(*Stop) Title ("Verbindung zu Datenbank " +
dbRuntime.DBName + " fehlerhaft")
LeaveSr *false
EndTry
/// Objekt für Parameterhandling erzeugen
cParameter
= *new clsParameter( dbRuntime )
Objekt instanzieren
(erstellen des Objekts)
/// Datenobjekt für Belegdaten erzeugen
cParamBelege
= *new clsParameter.clsParmData()
cParamBelege.Firma
= asrApp.GetValue("Firma",
Type.GetType("System.String")) *as String
cParamBelege.Parameter
= conBelegtyp
/// Parameter per Reference übergeben
If cParameter.LeseParameter(*ByRef cParamBelege)
Eigenschaften des
Objekts zuweisen
/// Schleife über die Tabelle
ForEach dr Type(DataRow) Collection(cParamBelege.ParameterWerte.Rows)
/// BelegItem erstellen
Schleife
DclFld itm
Type(ToolStripMenuItem)
itm
= *new ToolStripMenuItem()
Tabelle
itm.Text
= dr.item("Wert").tostring().trim()
itm.Tag
= dr.item("Key").Tostring().trim()
itm.Name
= "mnu" + dr.item("Key").Tostring().trim()
Try
LOADPICTURE
File(asrApp.GetValue("BelegIcon",
Type.GetType("System.String")) *as String)
Target(itm.Image)
Catch ex Exception
MenüEintrag
EndTry
Methode des Objekts
ausführen und Parameter
per REFERENCE
übergeben
(erstellen des Objekts)
/// Menühandler deklarieren
Addhandler
SourceObject(itm)
SourceEvent(Click)
MenüEintrag an
Belegmenü anhängen
/// BelegItem in Belegmenü hängen
mnuBelege.DropDownItems.Add(itm)
EndFor
Endif
LeaveSr *true
EndFunc
/endregion
Hier sind die programmatisch erzeugten
Menüeinträge.
-39Dokument D:\75878992.doc
über
programmatisch erzeugen
HandlerSr(BelegClick)
EreignisHandler
programmatisch erzeugen
RPG.NET BESTPRACTICES
6.6. Objekte im UserInterface programmatisch erzeugen
In den meisten Fällen macht es Sinn die Oberfläche mit dem Designer zu erzeugen.
Manchmal aber ist es praktisch wenn man die Oberfläche zur Laufzeit verändern kann.
In unserem Fall geht es darum eine Standard-Belegbearbeitung zu erzeugen. Die
Belegtypen sollen frei definierbar sein.
D.h. das Programm muss datengesteuert und nicht logikgesteuert arbeiten.
Wir legen daher in der Parametertabelle fest welche Belegtypen wir haben.
Das Programm muss nun diese Belege im Menü anbieten. Dazu die im vorigen Kapitel
beschriebene Routine.
Nun müssen wir noch herausfinden welchen Beleg der Benutzer gemeint hat wenn er
Click’t.
6.7. Die TAG-Eigenschaft
Jedes Objekt hat eine TAG-Eigenschaft. Der Typ des TAG ist OBJEKT.
D.h. der Entwickler kann jedes beliebige Objekt in der TAG-Eigenschaft mit einem
anderen Objekt verbinden.
Im Menüeintrag weisen wir einfach den KEY zu. D.h. im Tag-Objekt des Menüeintrags
findet sich das Kürzel für den Belegtyp.
/// BelegItem erstellen
DclFld itm
Type(ToolStripMenuItem)
itm
= *new ToolStripMenuItem()
itm.Text
= dr.item("Wert").tostring().trim()
itm.Tag
= dr.item("Key").Tostring().trim()
Beim CLICK-Ereignis müssen wir die TAG-Eigenschaft auslesen.
BegSr
BelegClick Access(*Private)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
DclFld itm
Type(ToolStripMenuItem)
itm = sender *as ToolStripMenuItem
MsgBox "Beleg " + itm.Tag
EndSr
-40Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.8. Casten eines Objekts
In dieser häufig gebrauchten Funktion geht es darum den Typ eines Objekts zuzuweisen
oder wiederherzustellen.
In jeder Ereignisroutine werden 2 Parameter übergeben, SENDER und E.
Der Sender ist vom Typ *OBJECT, d.h. es ist kein bestimmter Typ. E ist von einem
bestimmten Typ, nämlich SYSTEM.EVENTARGS.
BegSr
BelegClick Access(*Private)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
Mit der Deklaration des Feldes itm als TOOLSTRIPMENUITEM wird ein Feld mit dem
richtigen Typ erzeugt.
DclFld itm
Type(ToolStripMenuItem)
Mit der Zuweisung *AS wird das Objekt SENDER in den entsprechenden Typ
umgewandelt und zugewiesen.
itm = sender *as ToolStripMenuItem
Nachdem das Objekt den richtigen Typ hat kann die TAG-Eigenschaft verwendet
werden.
MsgBox "Beleg " + itm.Tag
6.9. Startzeit des Programms optisch verkürzen
Beim Laden eines Programms werden gezwungenermaßen Abläufe ausgeführt die Zeit
brauchen da sich das Programm ja gleich brauchbar darstellen soll. Deswegen macht es
Sinn einen sog. SPLASH-SCREEN der Anzeige des Hauptprogramms vorzuschalten.
Dadurch wird die Wartezeit für den Anwender optisch verkürzt. Generell ist es sinnvoll
den Anwender immer mit ‚einer guten Show’ zu unterhalten, so kommt er nicht auf den
Gedanken dass etwas ‚lange dauert’.
Der Screen ist eine rahmenlose
Form mit 2 PictureBoxen und 2
Labels.
Im einen Label ist ein
Informationstext, im anderen Label
werden Programm und
Versionsnummer angezeigt.
-41Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.9.1. AssemblyInfo
Über den Splash-Screen kommen wir zur Assembly-Info.
In diesem XML-File der in jedem Projekt existiert sind die Statusinformationen des
Programms enthalten.
Diese Informationen finden wir in den
Eigenschaften des Programmes in der Sicht des
Betriebssystems wieder.
6.9.2.
Integration des SplashScreens
Nach der Deklaration des Formulars wird der SplashScreen im Construktor aktiviert.
Wichtig ist die Zeile APPLICATION.DOEVENTS() da erst hier die Anzeige erfolgt.
BegConstructor Access(*Public)
//
// Required for Windows Form Designer support
//
InitializeComponent()
//
// TODO: Add any constructor code after InitializeComponent call
//
/// SplashScreen anzeigen
frmSplash.Show()
Application.DoEvents()
/// wenn es Probleme bei der DB-Verbindung gibt Programm beenden
if not GetDBConnection()
LeaveSr
Endif
EndConstructor
-42Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Die Maske wird wieder gelöscht wenn das Formular angezeigt wird.
/// wenn Dialog angezeigt wird kann der SplashScreen geschlossen werden
BegSr frmMain_Shown Access(*Private) Event(*this.Shown)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
frmSplash.Close()
EndSr
6.10.Application.DoEvents
Unter dem Application-Objekt finden wir einige wichtige Informationen zur Anwendung
und zum Umfeld und auch die Methode DOEVENTS.
Der Sinn davon ist dass andere Anwendungen (Threads) auch Prozessorzeit brauchen
und die Anwendung diese Zeit zur Verfügung stellt.
Die Anwendung die wir hier programmieren wird am Computer des Anwenders laufen
und soll sich ‚gut benehmen’.
Dazu gehört auch dass sie anderen Threads Verarbeitungszeit gibt. Die Anwendung
selbst braucht diesen DOEVENTS da ohne DOEVENTS der Splashscreen erst
angezeigt wird wenn der Programmcode bewältigt und die Hauptmaske sowieso schon
da steht.
Bedenken Sie bei zeitaufwändigen Routinen unbedingt DOEVENTS einzubauen.
6.11.Grids füllen
Unser Formular hat inzwischen ein TabControl mit TabPages erhalten.
Innerhalb jeder Page finden wir einen Menübalken mit Funktions-Auswahlen, ein Feld
zum Aufsetzen und ein Grid.
-43Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Die Inhalte für die Grids kommen aus den Klassen, die Daten werden aus Tabellen
übernommen und einfach ins Grid eingestellt.
Das Grid übernimmt automatisch alle Tabellen des Memoryfiles und stellt die
entsprechenden Spalten zur Verfügung.
Natürlich können die Spalten auch programmatisch definiert werden.
6.12.Grids abfragen
In unserem Beispiel wird die komplette Zeile
eines Grid per Click oder Cursor ausgewählt.
Das wird festgelegt durch die Einstellung des
Selection-Modes.
Nun wollen wir eine Aktion ausführen zu der wir die Lieferantennummer oder die
Teilenummer des gewählten Artikels brauchen.
Dazu müssen wir die Zelle in der sich diese Information befindet lokalisieren.
BegSr itmBearbeiten_Click Access(*Private) Event(*this.itmBearbeiten.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
DclFld dgvr
Type(DataGridViewRow)
If tabMAin.SelectedTab = tpLieferanten
dgvr = dgvLieferanten.SelectedRows(0)
MsgBox "Bearbeite Lieferant " + dgvr.Cells(2).value.Tostring()
Else
dgvr = dgvTeile.SelectedRows(0)
MsgBox "Bearbeite Teil " + dgvr.Cells(1).value.Tostring()
Endif
EndSr
Ist die Selektion auf CELLSELECT eingestellt kann mit DGV.CURRENTCELL der Wert
der aktuell geklickten Zelle abgefragt werden.
-44Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.13.MemoryFile – der neue Subfile
Der MemoryFile ist das RPG.NET-Gegenstück zum Subfile. Er übernimmt die Struktur
einer Datei, die kann aber auch aus einem XML-File abgeleitet werden.
In unserer Lieferantenklasse nehmen wir den Aufbau der Basisdatei für den MemoryFile
/// iSeries-Tabellen
DclDiskFile
Name(LISTAP)
Org(*Indexed) Addrec(*Yes)
DB(dbCompile)
File("*LIBL/LISTAP")
ImpOpen(*NO)
///
Memoryfile
DclMemoryFile Name(LISTAPm) FileDesc("*LIBL/LISTAP")
ImpOpen(*NO)
RnmFmt(memLief)
Type(*Update)
DBDesc(dbCompile)
Die Datenklasse der Lieferantenliste enthält eine Tabelle für den MemoryFile.
/// Datenklasse für Lieferantenliste
BegClass
clsLieferantenliste
Access(*Public)
/// Listendaten
DclFld
Firma
DclFld
AbNummer
/// Anzahl der Datensätze in Liste
DclFld
Anzahl
/// Kopfdaten als Tabelle
DclFld
Liste
Like(FIRNR)
Like(LIFNR)
Access(*Public)
Access(*Public)
Type(*integer4)
Access(*Public)
Type(DataTable)
Access(*Public)
EndClass
Das Auslesen erfolgt über eine einfache Schleife. Es werden alle Felder ausgegeben da
sie denselben Namen wie die Datenfelder der Inputdatei haben.
/// Einlesen der Belegliste
BegFunc LeseLieferantenliste
DclSrParm cLieferantenliste
Type(*boolean)
Type(clsLieferantenliste)
/// Rückgabewert deklarieren
DclFld bOK
*boolean
/// MemoryFile rücksetzen
LISTAPm.DataSet.Clear()
/// Schlüssel setzen und Lesen
kfFIRNR = cLieferantenliste.Firma
kfLIFNR = cLieferantenliste.AbNummer
/// Fehler abfangen
Try
/// wenn Key leer ganzen Bereich einlesen
SETLL LISTAP Key(klLISTA)
READ
LISTAP Access(*nolock)
/// Schleife
DoWhile not %eof
/// Zeile in MemoryFile ausgeben
Write LISTAPm
/// Anzahl abfragen
If
cLieferantenliste.Anzahl > *zero
If LISTAPm.DataSet.Tables(0).Rows.Count =
cLieferantenliste.Anzahl
Leave
-45Dokument D:\75878992.doc
Access(*Public)
By(*reference)
RPG.NET BESTPRACTICES
Endif
Endif
/// nächsten Satz lesen
Read
LISTAP
EndDo
/// Datentabelle übergeben
cLieferantenliste.Liste = LISTAPm.DataSet.Tables(0)
bOK = *true
Catch ex Exception
strErrorMessage = ex.Message
bOK = *false
EndTry
LeaveSr bOK
EndFunc
Mit der Zuweisung der TABLES(0) des MemoryFile-Dataset wird die Tabelle an die
Datenklasse übergeben.
6.14.Die RANGE-Befehle
In der Routine wird ein Befehl verwendet der im Standard-Befehlsumfang von
iSeriesRPG nicht existiert. READRANGE und seine Verwandten DELETERANGE,
SETRANGE wurden von ASNA entwickelt um den Netzwerkverkehr zu optimieren.
Mit den Range-Befehlen werden komplette, von Beginn- und EndeKey begrenzte
Datenblöcke eingelesen und verarbeitet.
-46Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.15.Eigene Ereignisse erstellen und abfragen
Durch die Oberfläche vorgegeben ist der Programmablauf nicht mehr wie im iSeriesRPG
prozedural sondern ereignisgesteuert.
Natürlich können wir in RPG.NET eigene Ereignisse erstellen.
Ereignisse müssen deklariert werden
/// Ereignisse
DclEvent
DclEvent
DclEvent
deklarieren
FillGrids
FillLieferanten
FillTeile
Access(*Public)
Access(*Public)
Access(*Public)
In der Startroutine werden die HANDLER erstellt die eine Ereignisbehandlung festlegen.
…
/// Lieferanten
cLieferanten
cLieferantenListe
= *new clsLieferanten( dbRuntime )
Erstellt
= *new clsLieferanten.clsLieferantenliste()
/// Teile
cTeile
cTeileListe
AddHandler
AddHandler
AddHandler
= *new clsTeile( dbRuntime )
= *new clsTeile.clsTeileliste()
SourceObject(*this)
SourceObject(*this)
SourceObject(*this)
ein Ereignis und weist eine
Subroutine zu die aufgerufen wird
wenn das Ereignis eintritt
SourceEvent(FillGrids)
HandlerSr(FillAllGrids)
SourceEvent(FillLieferanten) HandlerSr(FillLieferantenGrid)
SourceEvent(FillTeile)
HandlerSr(FillTeileGrid)
*this.FillGrids()
Die Ereignisse werden unter *THIS angeboten.
Hier die Subroutinen die die Ereignisse behandeln.
/// das Ereignis abfangen
BegSr FillAllGrids
*this.FillLieferanten()
*this.FillTeile()
Das Ereignis das alle Grids füllt löst
seinerseits die Einzelnen
Ereignisse für die Grids aus
EndSr
/// das Ereignis abfangen
BegSr FillLieferantenGrid
/// Lieferanten aktualisieren
cLieferantenListe.Firma
= asrApp.GetValue("Firma",
Type.GetType("System.String")) *as String
cLieferantenListe.Anzahl
= asrApp.GetValue("DefaultAnzahl",
Type.GetType("System.String")) *as String
Try
cLieferantenListe.AbNummer
= txtAbLieferanten.Text
Catch ex Exception
cLieferantenliste.AbNummer
= *zero
EndTry
If cLieferanten.LeseLieferantenliste(*byRef cLieferantenliste)
dgvLieferanten.DataSource
= cLieferantenliste.Liste
Endif
-47Dokument D:\75878992.doc
Zuweisen der
DataTable ans Grid
RPG.NET BESTPRACTICES
EndSr
/// das Ereignis abfangen
BegSr FillTeileGrid
/// Lieferanten aktualisieren
cTeileListe.Firma
= asrApp.GetValue("Firma", Type.GetType("System.String")) *as String
cTeileListe.Anzahl
= asrApp.GetValue("DefaultAnzahl", Type.GetType("System.String"))
*as String
Try
cTeileListe.AbNummer = txtAbTeile.Text
Catch ex Exception
cTeileListe.AbNummer = *zero
EndTry
If cTeile.LeseTeileliste(*byRef cTeileliste)
dgvTeile.DataSource
= cTeileListe.Liste
Endif
EndSr
6.16.Inhalte in Grids selektieren
DataGrids werden mit DataTable’s gefüllt. Es ist praktisch den Inhalt zu filtern ohne dass
die Daten der Tabelle neu eingelesen werden müssen. Mit der SELECT-Methode der
DataTable kann wie bei einem SQL-Select ein Filter gesetzt werden.
Der Select erzeugt ein Array von Datensätzen aus dem eine neue Tabelle erstellt wird.
/// Füllen des Grids mit Auftragsdaten
BegSr FillAuftraege
/// Abhängig von der Einstellung der Combobox - Stahlsorte
If cboStahlsorte.Text = *blank
/// alle Daten
dgv.DataSource = cAuftragsliste.dtAuftraege
Else
/// Filter auf
DclArray
DclFld dt
DclFld dr
DclFld i
DclFld strKey
Stahlsorte
foundRows
Type(DataRow)
Type(DataTable)
Type(DataRow)
*integer4
*string
Rank(1)
Array für Ergebnis des
SELECT vorbereiten
/// Stahlsorte lesen
strKey = cboStahlsorte.Text.Substring(0,2)
/// Filter auf Sätze
foundRows = cAuftragsliste.dtAuftraege.Select("S2GUET = '" + strKey + "'")
/// Tabelle clonen
dt = cAuftragsliste.dtAuftraege.clone()
dt.Clear()
Neue Tabelle mit
selbem Format
erzeugen
SELECT ausführen
/// Alle gefilterten Sätze lesen und in Tabelle übergeben
do fromval(i) toval( foundRows.GetUpperBound(0) )
/// Neuen Satz anlegen, mit Werten Füllen und in Tabelle übergeben
dr = dt.NewRow()
dr.ItemArray = foundRows(i).ItemArray
dt.Rows.Add( dr )
Enddo
/// gefilterte Daten in Grid anzeigen
dgv.DataSource = dt
endif
-48Dokument D:\75878992.doc
Schleife über
Selektionsergebnis mit
füllen der Ausgabetabelle
RPG.NET BESTPRACTICES
/// in Gridanzeige wechseln
tabMAin.SelectedTab = tpAuftraege
/// Satzanzahl in Messageline anzeigen
stbMessage.Text = dgv.Rows.Count.ToString() + " Sätze angezeigt"
EndSr
In diesem Beispiel ist die Basistabelle die dtAuftraege des Objekts cAuftragsliste.
Aus ihr wird eine neue Tabelle selektiert die dem Grid zugewiesen wird.
6.17.Contextmenü erstellen und abfragen
In der Startroutine wurden Belegtypen aus der Parameterdatei ausgelesen. Für jeden
Belegtyp wird ein Eintrag im Contextmenü gemacht, das Contextmenü wird an das Grid
gebunden.
…
/// Menühandler deklarieren
Addhandler
SourceObject(itm)
/// BelegItem in Contextmenü hängen
ctmBelege.Items.Add(itm)
SourceEvent(Click)
HandlerSr(BelegClick)
EndFor
/// Contextmenü an Grid binden
dgvLieferanten.ContextMenuStrip = ctmBelege
Hier ist die Ereignisbehandlung für das Contextmenü.
/// Ereignisse des Contextmenü's abfragen
BegSr BelegClick Access(*Private)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
/// ausgewählte Zeile im Grid einlesen
DclFld dgvr
Type(DataGridViewRow)
dgvr = dgvLieferanten.SelectedRows(0)
/// den Menüpunkt feststellen
DclFld itm
Type(ToolStripMenuItem)
itm = sender *as ToolStripMenuItem
Aus dem Menüobjekt wird der Inhalt
der TAG-Eigenschaft, aus dem Grid
wird die LieferantenNr übergeben
/// das BelegObjekt erstellen und anzeigen
DclFld myBeleg
Type(frmBeleg)
/// Parameter in den Constructor übergeben
myBeleg = *new frmBeleg( itm.Tag.ToString(), dgvr.Cells(2).Value.Tostring() )
myBeleg.Show()
EndSr
6.18.Formulare aufrufen
Im vorigen Beispiel wurde das Formular aufgerufen. In der Instanzierung wurden dem
Constructor Parameter übergeben.
/// das BelegObjekt erstellen und anzeigen
DclFld myBeleg
Type(frmBeleg)
/// Parameter in den Constructor übergeben
myBeleg = *new frmBeleg( itm.Tag.ToString(), dgvr.Cells(2).Value.Tostring() )
myBeleg.Show()
Im aufgerufenen Formular sieht das so aus:
-49Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
BegConstructor Access(*Public)
DclSRParm
strBeleg
*string
DclSRParm
strNr
*string
//
// Required for Windows Form Designer support
//
InitializeComponent()
//
// TODO: Add any constructor code after InitializeComponent call
//
*this.Text = *this.Text + " " + strBeleg + " " + strNr
EndConstructor
Der
Constructor
verlangt diese beiden
Parameter und übergibt
sie
hier
in
den
Formularkopf.
In der Menüleiste stellen sich nun beide Formulare so dar.
Wir wollen das Formular als komplett eigenständig agierendes
Objekt einbinden. Dem Formular sollen daher alle Objekte
mitsamt der DB-Verbindung übergeben werden die es braucht.
Der Sinn ist dass sich eine Anwendung entwickelt die mehrere
von einander unabhängige Unterformulare beinhalten kann.
Dadurch ist der Benutzer in der Lage beliebig viele
Stammdatensätze, Belege, was die Formulare auch immer
darstellen gleichzeitig und voneinander unabhängig zu
bearbeiten.
6.19.Combobox- WertListe füllen
Die Listenwerte in den DropDown-Boxen werden über die Parameterklasse gefüllt.
Wenn die Datenklasse mit LESEPARAMETER erstellt wird so wird auch gleichzeitig eine
Liste von Werten gefüllt die an die ComboBox übergeben wird.
Hier die Erstellung des Parameterobjekts und die Zuweisung der Liste an die
ComboBox:
oVART
= *new clsParameter.clsParmData()
oVART.Firma
= strFirma
oVART.Parameter
= "VART"
oParameter.LeseParameter(*ByRef oVART)
cboVersandart.Items.AddRange(oVART.KeyListe.ToArray())
Im Parameterobjekt wird die Liste so deklariert:
/// KeyListe für DropDowns
DclFld KeyListe
Type(System.Collections.ArrayList)
-50Dokument D:\75878992.doc
Access(*Public)
RPG.NET BESTPRACTICES
Hier ist die Routine LESEPARAMETER:
/// Schleife
DoWhile not %eof
/// Zeile in Tabelle erstellen und mit Werten fülllen
dr = cParmData.ParameterWerte.NewRow()
dr.Item("Name")
= PFPARM
dr.Item("Key")
= PFKEY
dr.Item("Wert")
= PFWERT
dr.Item("Bezeichnung") = PFBEZ
/// Zeile in Datentabelle anhängen
cParmData.ParameterWerte.Rows.Add( dr )
/// Feld in Keyliste hängen
cParmData.KeyListe.Add(PFKEY)
/// nächsten Satz lesen
Read
PFINH
EndDo
6.20.Defaultwerte in Comboboxen
Die
Anwender
schätzen
eine
vorbelegte
DropDown, es ist
auch kein Problem
diesen Service zu
bieten.
In unserem Beispiel
wird
eine
Parameterdatei
durchgegangen
und
Parametertabellen
und Listen gefüllt.
Ebenso können wir
einen Defaultwert
einstellen, in der
Tabelle wird ein
Feld eingefügt, hier
mit dem Namen
PFDFT, Typ CHAR
Len 1
-51Dokument D:\75878992.doc
Feldinhalt in Liste
übergeben
RPG.NET BESTPRACTICES
In dieses Feld werden beim
gewünschten Satz *ONMerker eingefüllt.
In der Klassenroutine sieht das so aus:
/// Schleife
DoWhile not %eof
…
/// Feld in Keyliste hängen
cParmData.KeyListe.Add(PFKEY)
/// Standardwert abfragen und setzen
If PFDFT = *ON
cParmData.DefaultKey = PFKEY
Endif
/// nächsten Satz lesen
Read
PFINH
EndDo
Hier die Zuweisung an das DropDown.
cboVersandart.Text
= oVART.DefaultKey
Das Ergebnis:
-52Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.21.Cursorreihenfolge festlegen
In Windows-Programmen kann
auf die Positionierung des
Cursors festgelegt werden.
Dazu hat jedes Control die
Eigenschaft TABINDEX.
Dieser startet bei 0.
Üblicherweise wird während der
Entwicklung am UI gearbeitet,
wenn das UI fertig ist sollte
auch der TABINDEX gesetzt
werden.
Natürlich zählen nur Controls
die auch einen Cursor
annehmen können.
6.22.Komfortable Datenerfassung
Programme werden für Benutzer geschrieben, den sollte man auch so gut wie möglich
unterstützen, man lebt ja davon dass er mit der Arbeit die der Entwickler leistet zufrieden
ist.
Ein wichtiger Punkt ist dass das Eingabefeld nicht mehr Zeichen annehmen kann als das
Datenfeld zulässt.
Eine Textbox ist per Standard auf die MAXLENGTH von 32767 Zeichen eingestellt.
Deswegen sollte für jede Textbox die Feldlänge eingestellt werden. Sie ersparen sich
und dem Anwender jede Menge Ärger.
Bei der Arbeit mit dem Programm ist es praktisch wenn der Feldinhalt in das der Cursor
springt automatisch markiert wird sodass ein einfaches Erfassen möglich ist.
Hier ist ein Weg dem Benutzer die Arbeit leicht zu machen.
Es genügt eine EventRoutine in der das ENTER-Ereignis aller TextBoxen bearbeitet
wird.
BegSr txtNAME1_Enter Access(*Private) Event(*this.txtNAME1.Enter, *this.txtNAME2.Enter,
*this.txtSTRASSE.Enter, *this.txtLand.Enter, *this.txtPLZ.Enter,
*this.txtORT.Enter, *this.txtProjekt.Enter)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
TextBox aus
Ereignisparameter
übernehmen
DclFld txtBox Type(TextBox)
txtBox = sender *as TextBox
txtBox.Text = txtBox.Text.Trim()
txtBox.SelectAll()
EndSr
Mögliche Leerstellen
abschneiden
Alle Zeichen
markieren.
-53-
Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
So macht das Programm einen
professionellen Eindruck.
Das funktioniert natürlich auch für
die ComboBoxen und
NumericUpDown.
6.23.Steuerung aktive TabPage
Die aktive TabPage kann natürlich programmatisch gesteuert werden. In diesem Fall soll
bei verlassen des Feldes Projekt die Positions-Page aktiviert und der Cursor auf ein
bestimmtes Feld positioniert werden.
Der LEAVE-Event wird ausgelöst wenn der
Focus das Feld verlässt.
/// Tabsprung soll Positionserfassung öffnen
BegSr txtProjekt_Leave Access(*Private) Event(*this.txtProjekt.Leave)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
/// stellt Positionserfassung in den Vordergrund
tabMain.SelectedTab = tpPos
/// Setzt Focus auf ArtikelNr
txtArtikelNr.Focus()
EndSr
6.24.DefaultButton für Eingabetaste festlegen
Abhängig von der aktiven TabPage soll bei drücken der Eingabe-Taste ein jeweils
anderer Button ausgelöst werden.
Gernerell wird die Eingabetaste vom ‚Accept’-Button des Formulars abgefangen.
Der wird vom Programm gesetzt wann auch immer sich die aktive TabPage ändert.
/// wenn sich die aktuelle tabPage ändert wird der Default für die Eingabetaste festgelegt
BegSr tabMain_SelectedIndexChanged Access(*Private)
Event(*this.tabMain.SelectedIndexChanged)
-54Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
If tabMAin.SelectedTab = tpTeile
*this.AcceptButton
= btnBelegSpeichern
Else
*this.AcceptButton
= btnPosOk
Endif
EndSr
6.25.Tastencode abfragen
Die Key-Events von Windows-Programmen kommen mit einem Parameter der
Argumente enthält, diese Argumente können mit einer Enumeration der Keys – Klasse
oder direkt mit dem Tastencode abgefragt werden.
In diesem Fall wird die ENTER-Taste abgefragt.
BegSr dgv_KeyPress Access(*Private) Event(*this.dgv.KeyPress)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.Windows.Forms.KeyPressEventArgs)
If e.KeyChar = U'000D'
*this.AuftragAnzeigen()
Endif
EndSr
6.26.Array mit Werten füllen
Eine Array wird wie folgt mit Werten gefüllt:
/// Array mit Werten initialisieren
DclArray
aWerte
Type(*string)
Rank(1)
aWerte = *new System.String[] { "0" , txtArtikelNr.Text, txtBezeichnung.Text,
txtMengeneinheit.Text, nudMenge.Text, nudEinzelpreis.Text, "0", txtPositionstext.Text }
Die Werte innerhalb der geschwungenen Klammer werden an das Array übergeben,
durch *NEW wird es mit einem Typ initialisiert.
6.27.Array aus String füllen
Hier ist ein Beispiel indem ein Array aus einem String gefüllt wird der eine Zeile von
Daten getrennt durch ein bestimmtes Zeichen enthält. Verwendet wird die SPLITFunktion vom Datentyp STRING
lblKW.text = „2006/35“
If lblKW.text <> *blank
DclArray
aKW
DclFld
oc
oc = "/"
aKW = lblKW.Text.Split(oc)
If aKW.length = 2
dr.Item("BPLJJ")
dr.Item("BPLWW")
Endif
Endif
Type(*string)
Type(*onechar)
= %int(aKW[0])
= %int(aKW[1])
-55Dokument D:\75878992.doc
Rank(1)
RPG.NET BESTPRACTICES
6.28.DataGridView oder DataRow mit Werten füllen
Eine Datenzeile wird durch eine Array an Werten dargestellt. Sie kann einfach an die
Rows-Collection angehängt werden.
/// Array mit Werten initialisieren
DclArray
aWerte
Type(*string)
Rank(1)
aWerte = *new System.String[] { "0" , txtArtikelNr.Text, txtBezeichnung.Text,
txtMengeneinheit.Text, nudMenge.Text, nudEinzelpreis.Text, "0", txtPositionstext.Text }
/// Zeile an DataGridView anhängen
dgvPos.Rows.Add( aWerte )
6.29.Werte in DataGridView berechnen
Nach Änderungen/Ergänzungen/Löschungen wird diese Routine aufgerufen die
Positionssummen errechnet und die Werte im Grid updatet.
BegSr
RechneWerteInGrid
DclFld
DclFld
DclFld
DclFld
DclFld
i *integer4
zSumme *decimal
zMenge Type(*zoned)
zPreis Type(*zoned)
zTotal Type(*zoned)
Len(10,3)
Len(13,3)
Len(13,3)
/// um das Durchlaufen der Schleife bei Folgeereignissen abzublocken
If bGridUpdate
bGridUpdate = *false
/// Schleife über die Datenzeilen
ForEach dr
Type(DataGridViewRow) Collection(dgvPos.Rows)
/// Werte initialisieren
zMenge = 0
zPreis = 0
dr.Cells(0).Value
= i+1
/// Rechenfelder einlesen
Try
zMenge = dr.Cells("colMenge").Value *as System.String
Catch Ex Exception
dr.Cells("colMenge").Value = 0
EndTry
Try
zPreis = dr.Cells("colEinzelpreis").Value *as System.String
Catch Ex Exception
dr.Cells("colEinzelpreis").Value = 0
EndTry
/// berechnen und updaten
zSumme = zMenge * zPreis
dr.Cells("colPreis").Value = zSumme
zTotal += zSumme
EndFor
/// Summe zuweisen
lblWert.Text
= zTotal
stbLabel.Text = "Gesamtwert " + zTotal
/// Bearbeitung wieder freigeben
bGridUpdate = *true
Endif
EndSR
-56Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.30. Combo- und Checkboxen als DataGridView-Spalten
Hier ein Beispiel das die Verwendung von Funktionsspalten im DataGridView erläutert.
dclfld
dclfld
dgvChk
dgvCbo
Type(System.Windows.Forms.DataGridViewCheckBoxColumn) new()
Type(System.Windows.Forms.DataGridViewComboBoxColumn)
BegSr dgvDatenErstellen
// Spalte 1
dgvDaten.Columns.Add("Spalte1", "Normale Spalte 1")
// Spalte 2 - ideal für J/N - Richtig / Falsch
dgvChk.Name = "Check"
dgvChk.HeaderText = "Check J/N"
dgvDaten.Columns.Add(dgvChk)
// Spalte 3
dgvCbo
= *new System.Windows.Forms.DataGridViewComboBoxColumn()
dgvCbo.Name = "Spalte3"
dgvCbo.HeaderText = "ComboBox Spalte 1"
dgvCbo.Items.Clear()
dgvCbo.Items.Addrange("Karl", "Franz", "Sepp")
dgvDaten.Columns.Add(dgvCbo)
//
==> Hier möchte ich z.B. "J" auf selected setzen!
/// so gehts halt nicht - musst im Erstellungsevent machen
EndSr
BegSr Form1_Load Access(*Private) Event(*this.Load)
DclSrParm sender *Object
DclSrParm e System.EventArgs
// Occurs when form is first loaded.
// Put form "startup" code here (ie open files).
dgvDatenErstellen()
EndSr
BegSr Form1_FormClosing Access(*Private) Event(*this.FormClosing)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.Windows.Forms.FormClosingEventArgs)
// Occurs when form is closing.
// Put form "housecleaning" code here (ie close files).
EndSr
-57Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
BegSr dgvDaten_RowsAdded Access(*Private) Event(*this.dgvDaten.RowsAdded)
DclSrParm sender *Object
DclSrParm e System.Windows.Forms.DataGridViewRowsAddedEventArgs
/// absichern da bei erstem Durchlauf noch keine Spalten existieren
/// die werden erst im FormLoad erstellt
try
/// um Abwechslung ins Leben zu bringen
if e.Rowindex
< 3
/// bei nur 2 Auswahlmöglichkeiten könnte man auch eine Checkbox nehmen
dgvDaten.Rows.Item( e.RowIndex ).cells("Check").Value = *true
/// man kann einfach den Wert eingeben
dgvDaten.Rows.Item( e.RowIndex ).cells("Spalte3").Value = "Sepp"
else
dgvDaten.Rows.Item( e.RowIndex ).cells("Check").Value = *false
/// oder einen Wert aus der Tabelle nehmen
dgvDaten.Rows.Item( e.RowIndex ).cells("Spalte3").Value =
dgvcbo.Items(1).Tostring()
Endif
catch ex Exception
endTry
EndSr
-58Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.31. Felder an MemoryFile anhängen
Manchmal muss man an einen Memoryfile zur Laufzeit Felder anzuhängen, so wird’s
gemacht.
Die Funktion ‚NeuerBeleg’ erzeugt eine Instanz einer Datenklasse, an den MemoryFile
wird die Spalte Text angehängt.
BegFunc NeuerBeleg
Type(clsBelegDaten)
Access(*Public)
DclFld cBelegDaten
Type(clsBelegDaten)
cBelegDaten
= *new clsBelegDaten()
cBelegDaten.Positionen = BPPOSm.DataSet.Tables(0)
/// Spalte für Texte im Dataset anfügen
DclFld dcText
Type(DataColumn)
new()
dcText.ColumnName = "Text"
dcText.DataType = Type.GetType("System.String")
cBelegDaten.Positionen.Columns.Add(dcText)
LeaveSr cBelegDaten
EndFunc
6.32.Daten in einer DataTable sortieren
Es gibt einige Wege, hier finden wir den Weg über die DataView, ein anderer wäre einen
PrimaryKey über die Tabelle zu legen.
/// eine DataView erzeugen, die Spalte über den Index angeben – ASC - Ascending
DclFld dv
Type( DataView )
dv = *new DataView( dtMain, "", dtMain.Columns( e.ColumnIndex ).ColumnName + " ASC",
DataViewRowState.CurrentRows)
/// die sortierte view in die neue Tabelle ausgeben
dtSort = dv.ToTable()
/// Listbox-Inhalt löschen
lb.Items.Clear()
/// Spalte in Grid ausgeben
ForEach dr
Type( DataRow )
Collection( dtSort.Rows )
/// Spalte in Listbox ausgeben
lb.Items.Add( dr.item( e.ColumnIndex ).Tostring() )
EndFor
-59Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.33.Das TreeView
Ist ein sehr interessantes Control das viele Möglichkeiten bietet. Hier sehen Sie wie das
TreeView gefüllt wird:
/// ------------------------------------------------------------------/// Zweck:
baut die Baumstruktur für die Anzeige auf
///
Gültigkeit:
lokal - innerhalb dieser Klasse
///
Parameter:
keine
/// Hinweise: TreeView, Nodes, Objekte, Ereignisse, Methoden,
///
Datenzugriff, Try..Catch,
/// ------------------------------------------------------------------BegSr FillTree
DclFld
DclFld
DclFld
DclFld
tn
ts
dtGA
dtGB
Type(TreeNode) /// Hauptknoten
Type(TreeNode) /// Subknoten
Type(*date)
/// Hilfsfeld für Datum glt-ab
Type(*date)
/// dto. gültig-bis
/// Änderungen nicht gleich anzeigen
tvNews.BeginUpdate()
/// löschen des Baumes
tvNews.Nodes.Clear()
/// löschen der DropDown-Boxen
cboKeyHNGRN1.Items.Clear()
cboHNGRN1.Items.Clear()
/// initialisieren des GW-Kriteriums
lstHNGRN1
= *blank
/// Aufsetzen Dateibeginn und Readschleife bis EndOfFile
SETLL NEWS2L01
Key(*start)
READ
NEWS2L01
Access(*nolock)
DoWhile not %eof
/// bei GW in Knotengruppe neuen Hauptknoten erstellen
If
HNGRN1 <>
lstHNGRN1
/// Schlüsselfeld füllen
kfFLIAFI = HNGRN1
CHAIN FLDVAL01
Key(klFLDVAL01)
Err(*extended) +
Access(*nolock)
If not %Error and not %eof
/// neuen Hauptknoten als Objekt erstellen
tn = *new TreeNode()
tn.Text = HNGRN1 + " " + TXT1FI
tn.Tag = HNGRN1
/// tvNews ist das Steuerelement, darunter wird /// tn als
Hauptknoten angehängt
tvNews.Nodes.Add(tn)
/// Gruppe auch in die Liste der Komboboxen
cboHNGRN1.Items.Add(HNGRN1)
-60Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
cboKeyHNGRN1.Items.Add(HNGRN1)
/// GW-Kriterium setzen
lstHNGRN1
= HNGRN1
Endif
Endif
/// Problemen bei Datumsformat vorbeugen
Try
dtGA = GLTAN1
Catch ex Exception
/// bei Fehler aktuelles Datum verwenden
dtGA = DateTime.Now()
EndTry
Try
dtGB = GLTBN1
Catch ex Exception
dtGB = DateTime.Now()
EndTry
/// für jeden Datensatz der NEWS2L01 einen Knoten erstellen
ts = *new TreeNode()
ts.Text = %trim(HNGRN1) + " " + %EDITC(SEITN1,"4") + " " +
TEXTN1 + dtGA.ToShortDateString() + " " + DVBKN1 + " " +
dtGB.ToShortDateString()
/// TAG-Eigenschaft beinhaltet den Schlüssel
ts.Tag = %trim(HNGRN1) + %EDITC(SEITN1,"4")
/// Knoten als Subknoten zum jeweiligen Hauptknoten (Gruppe)
tn.Nodes.Add(ts)
/// nächsten Satz aus NEWS2L01 lesen
Read
NEWS2L01
Access(*nolock)
Enddo
/// nun wird der Baum angezeigt
tvNews.EndUpdate()
/// Format mit Baumstruktur öffnen
tabNews.SelectedTab = tabStruktur
EndSr
-61Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.34.Kalenderwochenberechnung, Rekursionen
Die Berechnung der Kalenderwoche ist nicht wirklich trivial, hier ist ein Beispiel in dem
eine Rekursion verwendet wird.
/// Kalenderwochenberechnung gibt Woche als string zurück, bekommt Datum übergeben
BegFunc Kalenderwoche Type(*string)
DclSrParm
dDatum *date
/// ISO-Norm 8601
/// Kalenderwoche beginnt immer an einem Montag
/// Erste Kalenderwoche eines Jahres ist die in der der 4.Januar liegt.
/// Rechenfeld deklarieren
DclFld i2Week *integer2
/// Beginn der ersten Woche im Jahr feststellen
DclFld dVierterJanuar *date
dVierterJanuar = dDatum.Parse("04.01." + dDatum.Year.ToString())
/// Anzahl der Wochen rechnerisch feststellen
i2Week = (dDatum.DayOfYear - dVierterJanuar.DayOfWeek + 1) / 7 + 1
/// wenn die Woche 0 ist fällt sie noch ins alte Jahr
If i2Week = *zero
/// Funktion rekursiv mit 31.12. des Vorjahres aufrufen
LeaveSr Kalenderwoche( dDatum.AddDays( (dDatum.DayOfYear + 1) * -1 ) )
Endif
LeaveSr i2Week.ToString()
EndFunc
-62Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.35.Überladen von Funktionen (OO-Technik)
Die OO-Technologie des Überladens ermöglicht uns eine Funktion mit mehreren
unterschiedlichen Parametern anzusprechen.
In unserem Textausgabe-Beispiel werden beliebige Texte (Artikel, Beleg-Kopfdaten,
Positionstexte, …) in einer Tabelle gespeichert.
Das Handling wird über eine Klasse gemacht die eine Lese- und eine Schreibfunktion
anbietet. Abhängig von den Parametern werden die Keys befüllt.
Damit sich der Nutzer der Klasse keine Gedanken über die Befüllung machen muss und
somit auch weniger Fehler machen kann werden unterschiedliche Parameterlisten
angeboten. Darunter laufen für jede Parameterliste dieselben Funktionen.
Parameterliste 1 - BelegTexte
Parameterliste 2 – ArtikelTexte
Codiert wird das so:
/// Einlesen der Texte für einen Beleg
BegFunc LeseText
Type(*String)
Access(*Public)
DclSrParm
Firma
Type(*char)
Len(2)
DclSrParm
BelegTyp
Type(*char)
Len(3)
DclSrParm
BelegNummer
Type(*char)
Len(10)
DclSrParm
PositionNr
Type(*Integer2)
kfFIRM
kfTYP
kfBENR
kfPOSN
kfATNR
=
=
=
=
=
Firma
BelegTyp
BelegNummer
PositionNr
*blank
LeaveSr HoleTextAusDaten()
EndFunc
/// Einlesen der ArtikelTexte
BegFunc LeseText
Type(*String)
DclSrParm
Firma
Type(*char)
DclSrParm
ArtikelNr
Type(*char)
kfFIRM
kfTYP
kfBENR
kfPOSN
kfATNR
=
=
=
=
=
Access(*Public)
Len(2)
Len(18)
Firma
*BLANK
*ZERO
*zero
ArtikelNr
LeaveSr HoleTextAusDaten()
EndFunc
Über den gleichen Namen bietet VS die Parameterliste an. Der Entwickler kann sich für
eine Liste entscheiden ohne wissen zu müssen was dahinter abläuft.
-63Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.36.Programmaufrufe
Wie im RPG üblich werden Programme mit CALL aufgerufen, dieser Call geht gegen ein
iSeries-Programm.
Move 'LNDC' CCNAME
Move EALNDC CCVAL
Call Pgm( '*LIBL/MB102'
DclParm CCPARM
*IN30 = *OFF
If( CCPRZ = 1 )
*IN30 = *ON
EndIf
) DB( dbRuntime )
6.37.AS/400-API’s aufrufen
6.37.1. Benutzer des DG-Servicejobs auslesen
DclFld
DclFld
DclFld
DclFld
DclFld
Receiver
Length
Format
JobName
JobID
Type(*char)
Type(*binary)
Type(*char)
Type(*char)
Type(*char)
Call
Pgm("QUSRJOBI")
DclParm Receiver
DclParm Length
DclParm Format
DclParm JobName
DclParm JobID
Len(100)
Len(4,0)
Len(8)
Len(26)
Len(16)
inz(100)
Inz("JOBI0100")
inz("*")
DB(ProdDB)
DBDirection(*output)
DBDirection(*input)
DBDirection(*input)
DBDirection(*input)
DBDirection(*input)
txtJob.Text
= Receiver.Substring( 8, 10)
txtUser.Text
= Receiver.Substring( 18, 10)
txtJobnum.Text = Receiver.Substring( 28, 6)
6.37.2. DTAQ auslesen
CALL
Pgm('*LIBL/QRCVDTAQ')
DclParm DtaQName
DclParm DtaQLib
DclParm DtaQLen
DclParm DSData
DclParm DtaQWait
DB(dbBGLesen) Err(*extended)
DBDirection(*input)
DBDirection(*input)
DBDirection(*output)
DBDirection(*output)
DBDirection(*input)
DSLOAD Source( DSData )
Name( DSMPAR )
6.38.Datenstrukturen als iSeries-Programmparameter
Um Datenstrukturen mit gepackten Feldern zwischen der iSeries und dem Client
übertragen zu können empfehle ich Schnittstellenprogramme zu schreiben deren
Schnittstelle keine gepackten Felder enthält.
Generell gibt es in RPG.NET keine Probleme mit gepackten Feldern, sie können ohne
Einschränkungen verwendet werden. Befinden sich gepackte Felder innerhalb eines
-64Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Strings so gibt es dadurch Probleme dass Hex’00’ in der ASCII-Welt als Code für
StringEnde verwendet wird.
Beispiel:
VALUE IN HEX
'404040404040F1F2F3F4F5F640C140F8F7F6F5F4F3F2F140404040404040F1848484F584848484F0'X
41
'F1848484F584848484F0F1848484F584848484F0F1848484F584848484F0F1848484F584848484F0'X
81
'F1848484F584848484F0F1848484F584848484F0F1848484F584848484F0F1848484F584848484F0'X
121 'F1848484F584848484F0F1848484F584848484F0F1848484F58400000000001F8400000000001DF0'X
In diesem String finden Sie auf Stelle 147 und 154 je ein gepacktes Feld mit Feldwert 11,
im ersten Feld positiv, im 2. Feld negativ.
Wenn das Programm direkt angesprochen wird gehen alle Daten ab Stelle 147
unweigerlich verloren. Die Ursache ist dass die EBCDIC zu ASCII Konvertierung auf
dem Host-System stattfindet.
EBCDIC zu ASCII – Konvertierung am Host-System
Bezeichnung
Mode
Data
Message format
Error Msg details
Return code
Type
Char
Char
Char
Char
Char
Länge
4
3000
1
2000
1
Ab dem ersten Hex’00’ in Stelle 147
6.38.1. Lösungsbeispiel Schnittstellenprogramme
Die Programme die Datenstrukturen mit gepackten Feldern verwenden werden über eine
Schnittstelle aufgerufen die entweder wie im Beispiel nur die benötigten Felder enthält
oder alle Felder als Datenstruktur in welcher die gepackten Felder durch gezonte Felder
ersetzt werden.
H
J
I*****************************************************************
I**‚ Schnittstelle zu Kundenstamm wegen gepackter Felder
I**
IPKDN
E DSSFWKDN
I**
-65Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
I**‚ DATENSTRUKTUREN FÜR *LDA
I**
ISYSDTA
EUDSSYSDTADS
I**
I
'*LIBL/#KDN'
C
#PGM
I**
I*****************************************************************
C**
C
*LIKE
DEFN KDN01
#DN01
C
*LIKE
DEFN KDN02
#DN02
C
*LIKE
DEFN KDN23
#DN23
C
*LIKE
DEFN XMCF03
#MCF03
C**
C*****************************************************************
C**‚ PROGRAMM-ÜBERGABE-PARAMETER
C**
C
*ENTRY
PLIST
C
PARM
#DN01
C
PARM
#DN02
C
PARM
#DN23
C
PARM
#MCF03
C**
C**‚ Programmaufruf
C**
C
MOVE #DN01
KDN01
C
MOVE #DN02
KDN02
C
CALL #PGM
C
PARM
PKDN
C**
C**‚ Returncode einlesen
C**
C
*NAMVAR
DEFN *LDA
SYSDTA
C
IN
SYSDTA
C
DUMP
C**
C**‚PROGRAMM BEENDEN
C**
C
MOVE KDN23
#DN23
C
MOVE XMCF03
#MCF03
C
MOVE '1'
*INLR
C**
C*****************************************************************
-66Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.39.Datenzugriff
Die Logik wird wie in
ILERPG geschrieben.
6.40.Routinen aus iSeries-Programmen
Hier ist eine
Routine aus dem
Originalprogramm
die zeigt dass es
keine
wesentlichen
Änderungen im
Verständnis des
RPG braucht um
Logik zu
schreiben.
-67Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.41.F-Spec’s
Natürlich kennt RPG.NET keine F-Spezifikationen mehr, an Stelle der F’specs steht
DclDiskFile.
6.42.Feld- und KeyDeklarationen
Variablen können von Datenbankfeldern
abgeleitet werden, Keylists werden
deklariert wie in RPG gewohnt.
6.43.Datenstrukturen
Datenstrukturen
werden wie auf
der iSeries
deklariert. Die
Felder reihen sich
aneinander
sodass Lücken
mit Dummyfelder
geschlossen
werden müssen.
Überlappende
Felder werden mit
OVERLAY
deklariert.
-68Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.44.Datenstrukturen als Key – Teilkeys mit %KDS
Die BuiltInFunction %KDS erlaubt eine Datenstruktur als Key anzugeben, hier ist ein
Beispiel:
Umso weniger keyfelder eingegeben werden umso mehr Datensätze zeigt das
Programm. Das ist ein typischer Fall von Aufsetzen mit Teilkeys – hier ist eine
Lösungsansatz.
Die Grid-Füll-Routine ruft eine mehrfach überladene Funktion in der Datenklasse auf.
BegSr
FillGrid
DclFld KundenNr
DclFld Jahr
DclFld Art
Type( *decimal )
Type( *decimal )
Type( *decimal )
Select
When
txtJahr.Text
= *blank
KundenNr
= txtKunde.Text *as *decimal
dgv.DataSource = cKundenUmsatz.Liste( KundenNr )
When
txtArt.Text
= *blank
Jahr
= txtJahr.Text *as *decimal
KundenNr
= txtKunde.Text *as *decimal
dgv.DataSource = cKundenUmsatz.Liste( KundenNr, Jahr )
Other
Art
= txtArt.Text *as *decimal
Jahr
= txtJahr.Text *as *decimal
KundenNr
= txtKunde.Text *as *decimal
dgv.DataSource = cKundenUmsatz.Liste( KundenNr, Jahr, Art )
EndSl
EndSr
Die Klasse ‚Kundenumsatz‘ löst die Aufgabe so:
Using System
Using System.Text
Using System.Data
BegClass KundenUmsatz Access(*Public)
DclDb
dbLocal
DBName("*public/DG NET LOCAL")
DclDiskFile
CSMasterL1
Type(*input) Org(*indexed) DB(dbLocal)
File("Examples/CSMasterL1")
DclMemoryFile
CSMaster
/// Key-Datenstruktur
DclDs kyDS
DclDsFld
DclDsFld
DclDsFld
DBDesc(dbLocal) FileDesc("Examples/CSMaster")
erstellen
kyKundenNr
kyJahr
kyArt
like(CSCustNo)
like(CSYear)
like(CSType)
-69Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
/// Listenaufrufe mit verschiedenen Paramtern bearbeiten
BegFunc
Liste Type(DataTable)
Access(*public)
DclSrParm
KundenNr
like(CSCustNo)
kyKundenNr
kyJahr
kyArt
= KundenNr
= *zero
= *zero
LEaveSr LeseListe( 1 )
EndFunc
BegFunc
Liste
DclSrParm
DclSrPArm
Type(DataTable)
Access(*public)
KundenNr
like(CSCustNo)
Jahr
like(CSYear)
kyKundenNr
kyJahr
kyArt
= KundenNr
= Jahr
= *zero
LEaveSr LeseListe( 2 )
EndFunc
BegFunc
Liste
DclSrParm
DclSrPArm
DclSrPArm
Type(DataTable)
Access(*public)
KundenNr
like(CSCustNo)
Jahr
like(CSYear)
Art
like(CSType)
kyKundenNr
kyJahr
kyArt
= KundenNr
= Jahr
= Art
LEaveSr LeseListe( 3 )
EndFunc
/// hier wird die Liste erstellt - die Anzahl der Keyfelder wird
/// als Parameter übergeben
BegFunc
LeseListe
Type(DataTable)
DclSrParm
KeyFelder
Type(*integer2)
csMaster.ClearFileData(0)
/// Aufsetzen und lesen ersten Satz
Select
When KeyFelder = 1
SETLL CSMasterL1
READ
CSMasterL1
When KeyFelder = 2
SETLL CSMasterL1
READ
CSMasterL1
When KeyFelder = 3
SETLL CSMasterL1
READ
CSMasterL1
EndSl
Key( %kds( kyDS, 1) )
Key( %kds( kyDS, 2) )
Key( %kds( kyDS, 3) )
/// Leseschleife
DoWhile NOT %EOF
/// Ausgabe des MemoryFiles
WRITE CSMaster
/// READE mit Keystruktur
Select
When KeyFelder = 1
READE CSMasterL1
When KeyFelder = 2
READE CSMasterL1
When KeyFelder = 3
READE CSMasterL1
EndSl
Enddo
/// Ausgabe der Tabelle
LEaveSr CSMaster.DataSet.Tables(0)
EndFunc
EndClass
-70Dokument D:\75878992.doc
key( %kds( kyDS, 1 ) )
key( %kds( kyDS, 2 ) )
key( %kds( kyDS, 3 ) )
RPG.NET BESTPRACTICES
6.45.Datenstrukturen als Programmparameter
Das Problem mit numerischen Zeichen in Datenstrukturen beruht vor allem darauf dass
Datenstrukturen auf der AS/400 als Strings behandelt werden und daraufhin vom
Entwickler erwartet wird dass das in anderen Umgebungen auch so ist.
Folgende Probleme treten auf:
1. Enthält der String gepackte Felder beginnen die meistens mit H‘00‘ – was Stringende auf ASCIIbasierenden Systemen bedeutet. Da die EBCDIC/ASCII-Konvertierung von der AS/400 gemacht
wird gibt es mit allen anderen Produkten außer DataGate das Problem dass mit dem ersten H‘00‘
der String zuende ist.
2. Enthält der String gezonte numerische Werte ergeben sich Probleme mit negativen Werten da sie
durch alpha-Character dargestellt werden. Das ist überall außer mit DataGate so.
Auch mit DataGate ergeben sich diese Probleme wenn man Datenstrukturen als String
übergibt. Werden die Datenstrukturen als Externe DS beschrieben und als solche
übergeben gibt es auch kein Problem – weder mit gepackten Feldern noch mit gezonten
numerischen Daten.
Beispiel:
Es wird ein AS/400 – Programm aufgerufen das Daten in Datenstrukturen übergibt. Im
ILE-RPG und auch im RPG.NET werden diese EDS deklariert und als Parameter
übergeben:
/// hier werden die Strukturen deklariert - und schlampigerweise public freigegeben
DclDs dsCMASTNEW
DBDesc( dbLocal )
ExtDesc( *yes )
FileDesc( "NXTGEN/CMASTNEW" )
Access( *Public )
DclDs dsCSMASTER
DBDesc( dbLocal )
ExtDesc( *yes )
FileDesc( "NXTGEN/CSMASTER" )
Access( *Public )
BegFunc GetEDS Type( *boolean )
DclSrParm
NR
DclSrParm
DUMP
DclSrParm
VZU
Access( *Public )
Like( CMCUSTNO )
Like( CMACTIVE )
Like( CMACTIVE )
/// hier wird das Programm aufgerufen - die Strukturen werden direkt übergeben
CALL
Pgm( "NXTGEN/GETEDS" ) DB( dbLocal )
DCLPARM
NR
DCLPARM
DUMP
DCLPARM
VZU
DCLPARM
dsCMASTNEW
DCLPARM
dsCSMASTER
LeaveSr (NOT %error )
EndFunc
-71Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Hier ist das ILE-RPG das die Parameter übernimmt und füllt:
H DEBUG(*YES)
FCMASTNEWL1IF
FCSMASTERL1IF
E
E
K DISK
K DISK
D CUSTDS
D SALEDS
E DS
E DS
EXTNAME(CMASTNEW)
EXTNAME(CSMASTER)
C
C
C
C
C
C
*ENTRY
PLIST
PARM
PARM
PARM
PARM
PARM
C
C
C
*LIKE
*LIKE
*LIKE
DEFINE
DEFINE
DEFINE
CMCUSTNO
*INLR
*INLR
C
C
C
(DUMP = *ON)
'BEFORE'
IF
DUMP
ENDIF
C
NR
CHAIN
CMASTNEWL1
C
NR
CHAIN
CSMASTERL1
IF
EVAL
EVAL
EVAL
EVAL
EVAL
EVAL
EVAL
EVAL
EVAL
EVAL
EVAL
EVAL
ENDIF
(VZUMK = *ON)
CSSALES01 = CSSALES01
CSSALES02 = CSSALES02
CSSALES03 = CSSALES03
CSSALES04 = CSSALES04
CSSALES05 = CSSALES05
CSSALES06 = CSSALES06
CSSALES07 = CSSALES07
CSSALES08 = CSSALES08
CSSALES09 = CSSALES09
CSSALES10 = CSSALES10
CSSALES11 = CSSALES11
CSSALES12 = CSSALES12
IF
DUMP
ENDIF
(DUMP = *ON)
NR
DUMP
VZUMK
CUSTDS
SALEDS
NR
DUMP
VZUMK
90
91
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
'AFTER'
MOVE
*ON
*INLR
-72Dokument D:\75878992.doc
*
*
*
*
*
*
*
*
*
*
*
*
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
RPG.NET BESTPRACTICES
Hier ist das Ergebnis nachdem alle Felder in die Listboxen übernommen wurden.
-73Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.46.Hilfsfunktionen
In diesem Dialog wurden Tooltips und F1-Hilfe ebenso wie Gültigkeitsprüfungen
integriert.
Hier ein ToolTip
Hier die Logik für die ToolTips, sie wird üblicherweise in die Initialisierungsroutine
gesetzt.
/// ToolTip setzen
tt.SetToolTip(nudLNR,"Eindeutiger Schlüssel des Datensatzes")
tt.SetToolTip(txtSNAM,"Eindeutiger Suchbegriff des Datensatzes")
tt.SetToolTip(txtName,"Lieferantenname")
tt.SetToolTip(txtORT,"Ort des Lieferanten")
Hier ein Hilfetext, er kann mit F1 auf dem Feld oder
dem Fragezeichen zur Anzeige gebracht werden.
/// Hilfe setzen
hp.SetHelpString(nudLNR,"Geben Sie hier den Schlüssel des Datensatzes an, der Begriff muss
eindeutig sein")
hp.SetHelpString(txtSNAM,"Geben Sie hier einen eindeutigen Suchbegriff für den Datensatz an um den
Lieferanten später einfach finden zu können; Maximal 5 Zeichen")
hp.SetHelpString(txtName,"Der Name des Lieferanten; Max. 50 Zeichen")
hp.SetHelpString(txtORT,"Der Ort des Lieferanten; Max 50 Zeichen")
-74Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.47.Gültigkeitsprüfungen
DotNet bietet einen sog.
ErrorProvider der neben dem
Feld einen roten Hinweispunkt
anzeigt.
Der
Hilfetext
erscheint wenn man mit der
Maus auf den Punkt fährt.
Das ist die Logik die dafür nötig ist.
-75Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.48.Drucken
6.48.1. RPG.NET – Printfiles
Mit ASNA-Printfiles kann man unter Windows ebenso drucken wie auf der iSeries. ASNA
hat eigene PrintControls erstellt, es können aber auch Windows-Controls verwendet
werden.
Vor Eröffnen des
Printfiles werden
wie auf der iSeries
Attribute
überschrieben,
hier werden die
Druckvorschau
und die
Druckerauswahl
eingestellt.
-76Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.48.2. Druckschleife
Wie auf der iSeries
wird in einer Schleife
über eine Datei
gedruckt.
READRANGE ist
ein neuer Befehl von
ASNA der einen
Bereich zwischen
zwei Schlüssel
eingrenzt.
Die Datensätze
werden in den
Printfile wie gewohnt
ausgegeben. Wenn
die Datenfelder des
Printfiles gleich wie
die DB-Felder
benannt sind braucht
auch keine
Zuweisung erfolgen.
6.49.Einbinden von 3rd-Party Komponenten
Für die Darstellung der Werte in einer Grafik wird eine Komponente verwendet die ASNA
mitliefert. Der GraphicServer ist eine frei verfügbare DotNet-Komponente die Ihre
Wurzeln schon in der Vorläufer-Welt (COM) hatte.
Wir finden am Markt jede Menge von Komponenten die, oft auch kostenlos, angeboten
werden.
Meine persönliche Einstellung dazu ist dass ich gerne jede Komponente von Microsoft
einbinde da ich davon ausgehen kann das MS dieselbe oder eine erweiterte
Komponente auf der nächsten Version anbietet.
Diese Situation hatten wir mit dem DataGrid in den Versionen 2003 und 2005.
Auf 2003 gab es ein Grid das seine Aufgabe zwar erfüllte aber Wünsche offen ließ.
Es war nicht einfach möglich verschiedene Controls wie Buttons oder Dropdowns
einzubauen, auch konnten die Zellen nicht beliebig gefärbt werden.
Auf 2005 gibt es einen Nachfolger, das DataGridView das alle diese Ansprüche erfüllt.
Beim Öffnen eines 2003-Projekts mit VS2005 hilft ein Upgrade-Assistent das Projekt
beim Upgrade. Dieser lässt aber das Grid unangetastet und es bleibt auch von der Optik
her das was es auf 2003 war.
-77Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Natürlich kann mit ein paar Eingriffen vom Grid auf das DataGridView umgestellt werden,
das geschieht aber nicht automatisch.
An der Optik der Steuerelemente erkennt man die Generation aus der sie stammen.
Solange man vorwärts geht oder vorne ist sollte das kein Problem sein, bindet man aber
eine Komponente ein von der es keine weiterentwickelte Version gibt so kann es sein
dass man einen gewohnten Vorteil verliert.
Entscheiden Sie selbst ob Sie Fremdkomponenten einsetzen wollen, bedenken Sie aber
auch immer dass Sie sich langfristig gesehen davon abhängig machen.
6.49.1. Grafikdarstellung
Unsere Grafikkomponente ist bereits mit der Vorläuferwelt von ASNA geliefert worden
und ist auch in dieser Welt verfügbar. Da unsere Anwendung nicht davon abhängt
können wir sie guten Gewissens einbinden.
Die Anzeige erfolgt
in einem eigenen
Formular das neben
der Grafik auch ein
Grid mit den Daten
beinhaltet. Bei Klick
auf den Spaltenkopf
wird die Spalte zur
Anzeige der Daten
gewählt.
Hier ist die Ereignisroutine im Hauptformular die dieses Formular aufruft.
/// prinzipiell selber Vorgang wie beim Excel-Button
BegSr btnArtikelGraph_Click Access(*Private) Event(*this.btnArtikelGraph.Click, +
*this.btnKundenGraph.Click, *this.btnUmsatzGraph.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
*this.Cursor = Cursors.WaitCursor
DclFld btn
Type(Button)
btn = sender *as Button
DclFld fGraph Type(frmGraph)
fGraph = *new frmGraph()
DclFld ds
Type(DataSet)
ds = btn.tag *as DataSet
/// hier werden Parameter für die Grafikdaten festgelegt
/// die Textspalte und die Datenspalte für den Start
DclFld strTitel
Type(*string)
SELECT
When btn = btnArtikelGraph
strTitel = "Artikelstatistik"
fGraph.TextColumnNumber = 0
fGraph.DataColumnNumber = 1
fGraph.SummenInLetzterZeile = *true
-78Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
When btn = btnKundenGraph
strTitel = "Kundenstatistik"
fGraph.TextColumnNumber = 2
fGraph.DataColumnNumber = 3
fGraph.SummenInLetzterZeile = *false
When btn = btnUmsatzGraph
strTitel = "Umsatzstatistik"
fGraph.TextColumnNumber = 1
fGraph.DataColumnNumber = 4
fGraph.SummenInLetzterZeile = *false
ENDSL
/// zuweisen des DataSets für die Grafik
fGraph.GraphData = ds
/// zuweisen des Formulartitels
fGraph.Text = fGraph.Text + " " + strTitel
/// ungebundenes Formular anzeigen
fGraph.Show()
/// Sanduhr zurückstellen
*this.Cursor = Cursors.Default
EndSr
Hier wird also per Property festgelegt welche Spalten als Text- und die Datenspalte zu
verwenden ist und wie viele Datenzeilen verarbeitet werden sollen. Die letzte Zeile der
Artikelstatistik ist eine Summenzeile und die sollte nicht in der Grafik angezeigt werden.
BegProp GraphData
Type(DataSet) Access(*Public)
BegSet
/// zugewiesene Daten verwenden
ds = *propval
/// füllen der Combobox mit den Tabellennamen
ForEach dt Type(DataTable)
Collection(ds.Tables)
cboTables.Items.Add(dt.TableName)
EndFor
/// einstellen des ersten Elements - dadurch Event auslösen
cboTables.SelectedIndex = 0
EndSet
EndProp
Hier werden die Events von der ComboBox und dem Klick auf den Spaltenheader
abgefangen und die Anzeige der Grafik aufgerufen.
/region Events
/// wenn andere Tabelle gewählt die Anzeige akutalisieren
BegSr cboTables_SelectedIndexChanged Access(*Private) +
Event(*this.cboTables.SelectedIndexChanged)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
/// nur wenn Daten vorhanden sind
if cboTables.Items.count > 0
Try
/// Datenquelle für Grid festlegen
dgv.DataSource = ds.Tables(cboTables.SelectedIndex)
/// Grafik anzeigen
ShowGraph()
Catch Ex Exception
MsgBox Msg("Bitte gültige Tabelle auswählen") Icon(*information) +
Title("Auswahl Tabellen")
EndTry
Endif
EndSr
/// bei Klick auf Spalte Graphic mit neuen Daten laden und anzeigen
-79Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
BegSr dgv_ColumnHeaderMouseClick Access(*Private) Event(*this.dgv.ColumnHeaderMouseClick)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.Windows.Forms.DataGridViewCellMouseEventArgs)
iDataCol = e.ColumnIndex
ShowGraph()
EndSr
/endregion
Hier ist das befüllen der Eigenschaften des Grafik-Controls:
/region Subroutines
/// Grafik anzeigen
BegSr ShowGraph
DclFld i
*integer2
DclFld iMax
*integer2
DclFld strColName
*string
/// Spaltenname für Datenfelder herausholen
strColName = ds.Tables( cboTables.SelectedIndex ).Columns( iDataCol ).ColumnName
/// Maximum auf Summenzeile einstellen
If bSummenInLetzterZeile
iMax = ds.Tables( cboTables.SelectedIndex ).Rows.Count - 2
Else
iMax = ds.Tables( cboTables.SelectedIndex ).Rows.Count - 1
Endif
/// Datenklassen neu intialisieren
Data = *new Series()
Labels = *new Series()
/// Schleife über Datenspalte des DataSets ( Summenzeile wird nicht übernommen)
Do FromVal(0) Toval(iMax) Index(i)
/// Datensatz aus Tabelle lesen
DclFld dr
Type(DataRow)
dr = ds.Tables( cboTables.SelectedIndex ).Rows(i)
/// Arbeitsfelder initialisieren
DclFld dData Type(Decimal)
DclFld strText Type(*string)
/// mögliche Fehler bei Textspalten abfangen
Try
dData = dr.item( iDataCol ).Tostring()
Catch ex Exception
dData = 0
EndTry
/// Text der angegebenen Spalte einsetzen
strText = dr.item( iTextCol ).tostring()
/// Objekte füllen
Data.SetValue( SeriesComponent.Y, i, dData )
Labels.SetValue( SeriesComponent.Label, i, strText)
EndDo
/// das Chart-Objekt mit Parametern füllen
With gsChart.Chart
.Grid.AxisPie.AxisMode
= AxisMode.Category
.Grid.AxisPie.LabelSeries = Labels
.RemoveAllSeries()
.AddSeries( Data )
.ChartTitle.text = strColName // cboTables.Text
.ChartEventsToEnable.EnableMarkerMouseClickEvent = *True
.GetSeriesDrawing(0).PieLabelLineLength
= 25
.GetSeriesDrawing(0).PieLabelLocation
= PieLabelLocation.Outside
.GetSeriesDrawing(0).markerlabelProperties.Font = *new Font( "Tahoma", 6 )
// explode first datapoint 40%
-80Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
.GetSeriesDrawing(0).SetDataPointExplode( 0, 40 )
.Grid.AxisPie.LabelFormatMask = "C"
.GetSeriesDrawing(0).PieUnits = PieUnits.Value
.ChartType = ChartType.Pie3D
// currency
EndWith
EndSr
/endregion
6.50.Embedded SQL und offener Datenzugriff
Da VisualRPG.NET auf DotNet
Zugriffsmodelle verwenden.
aufsetzt
können
wir
alle
Datenbanken
und
In diesem binden wir die iSeries über ODBC, SQL-Server über ManagedProvider und
Access über OLEDB ein.
-81Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.50.1. Namespaces und Deklarationen
Using
Using
Using
Using
System.Data
System.Data.ODBC
System.Data.OleDb
System.Data.SqlClient
…
/Region MyDeclaratives
DclConst coniSConnection
Value("Connection=ODBC;DSN=ATNICE;UID=NE;PWD=TUBA")
DclConst coniSSelection
Value("SELECT * FROM Petroplus.F4211LA where sddoco=18841")
DclConst conSQLConnection
Value("Integrated Security=SSPI;Persist Security Info=False;Data
Source=NICENOTE2005;Packet Size=4096;Workstation ID=NICENOTE2005;Initial
Catalog=Petroplus;")
DclConst conSQLSelection
Value("SELECT * FROM F4211")
DclConst conAccessConnection
Value("Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\NiceWare\XMPL\XMPL.mdb;")
DclConst conAccessSelection
Value("SELECT * FROM Artikel")
/Endregion
In diesen Deklarationen werden Konstante angelegt aus denen die Textfelder befüllt
werden mit denen die Datenbank-Verbindung und die Abfrage ausgeführt werden.
Natürlich sollten diese Strings in einem ‚ordentlichen Projekt aus der APP.CONFIG
einelesen werden.
6.50.2. Event-Subroutinen
Bei Klick auf Radio-Buttons werden die Felder belegt, bei Start wird abhängig von der
ausgewählten Datenbank eine entsprechende Routine ausgeführt.
/region Events
BegSr rbISeries_Click Access(*Private) Event(*this.rbISeries.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
txtConnection.Text = coniSConnection
txtSelection.Text = coniSSelection
EndSr
BegSr rbSQLServer_Click Access(*Private) Event(*this.rbSQLServer.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
txtConnection.Text = conSQLConnection
txtSelection.Text = conSQLSelection
EndSr
BegSr rbAccess_Click Access(*Private) Event(*this.rbAccess.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
txtConnection.Text = conAccessConnection
txtSelection.Text = conAccessSelection
EndSr
-82Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
BegSr btnStart_Click Access(*Private) Event(*this.btnStart.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
DclFld ds
Type(DataSet)
stb.Text = *blank
dg.DataSource = *nothing
Select
When rbISeries.Checked
ds = iSODBC(txtConnection.Text, txtSelection.text)
When rbSQLServer.Checked
ds = ManagedSQL(txtConnection.Text, txtSelection.text)
When rbAccess.Checked
ds = OLEDB(txtConnection.Text, txtSelection.text)
EndSl
Try
dg.DataSource = ds.Tables(0)
Catch ex Exception
stb.Text = "keine Daten gefunden"
EndTry
EndSr
/Endregion
6.50.3. ODBC
Als Datenbank-Standard hat kann man auf die meisten Datenbanken zugreifen. Natürlich
auch auf die iSeries. Zugriff über ODBC auf die iSeries ist zudem gratis.
Ich empfehle aber diese Funktion wirklich nur für den Zugriff über SQL zu nutzen und
Daten wann immer möglich über Schlüssel zu lesen und die RPG-OpCodes zu
bearbeiten.
Dasselbe gilt für den Zugriff auf iSeries-Programme. Man kann zwar über ODBC aus
StoredProcedures zugreifen, ein Zugriff über ASNA DataGate ist ungleich einfacher und
sicherer.
BegFunc
iSODBC Type(DataSet)
DclSrParm
strConnection
DclSrParm
strSQL
DclFld
DclFld
DclFld
DclFld
conn
cmdData
daData
dsData
*string
*string
Type(Odbc.OdbcConnection) new()
Type(Odbc.OdbcCommand)
new()
Type(Odbc.OdbcDataAdapter) new()
Type(DataSet)
new()
conn.ConnectionString = strConnection
// Verbindung zur iSeries erstellen
Try
conn.Open()
Catch ex Exception
MsgBox Msg("Verbindung zu iSeries über " + strConnection +
" konnte nicht hergestellt werden") Title("Connection") Icon(*exclamation)
LEaveSR dsData
-83Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
EndTry
Try
cmdData.Connection = conn
cmdData.CommandText = strSql
cmdData.CommandType = CommandType.Text
daData.SelectCommand = cmdData
daData.Fill(dsData)
Catch ex Exception
MsgBox Msg("Daten konnten mit Command '" + strSQL +
"' nicht eingelesen werden") Title("SQL-Fehler") Icon(*exclamation)
LEaveSR dsData
EndTry
LEaveSR dsData
EndFunc
6.50.4. SQL-Server
ManagedProvider sind die DotNet-native – Methode um auf Daten zuzugehen.
Auch hier empfehle ich den Zugriff über DataGate da es für den iSeries-Programmierer
einfacher ist auf Satzebene updates auszuführen als sie in ADO.NET zu behandeln.
BegFunc
ManagedSQL
Type(DataSet)
DclSrParm
strConnection
*string
DclSrParm
strSQL
*string
DclFld
DclFld
DclFld
DclFld
conn
cmdData
daData
dsData
Type(SqlConnection)
Type(SqlCommand)
Type(SQLDataAdapter)
Type(DataSet)
new()
new()
new()
new()
conn.ConnectionString = strConnection
// Verbindung zum SQLServer erstellen
Try
conn.Open()
Catch ex Exception
MsgBox Msg("Verbindung zum SQLServer über " + strConnection +
" konnte nicht hergestellt werden") Title("Connection") Icon(*exclamation)
LEaveSR dsData
EndTry
Try
cmdData.Connection = conn
cmdData.CommandText = strSQL
daData.SelectCommand = cmdData
daData.Fill(dsData)
Catch ex Exception
MsgBox Msg("Daten konnten mit Command '" + strSQL +
"' nicht eingelesen werden") Title("SQL-Fehler") Icon(*exclamation)
LEaveSR dsData
EndTry
LEaveSR dsData
EndFunc
-84Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
6.50.5. OLEDB
Für OLEDB gibt es kein DataGate, es gibt aber jede Menge Datenbanken die über
OLEDB angesprochen werden können.
Der Zugriff auf die iSeries ist zwar möglich da über ClientAccess der nötige Driver
mitgeliefert wird, er ist aber lizenzpflichtig.
Für die meisten Datenbanken sind OLEDB-Driver zu bekommen die nicht immer
lizenzpflichtig sind.
Unser Beispiel mit Access steht symbolisch für alle Datenbanken die über OLEDB
angesprochen werden können.
BegFunc
OLEDB Type(DataSet)
DclSrParm
strConnection
DclSrParm
strSQL
DclFld conn
DclFld daData
DclFld dsData
*string
*string
Type(OleDBConnection)
Type(OleDBDataAdapter)
Type(DataSet)
new()
new()
new()
conn.ConnectionString = strConnection
// Verbindung zum SQLServer erstellen
Try
conn.Open()
Catch ex Exception
MsgBox Msg("Verbindung zu Access über " + strConnection +
" konnte nicht hergestellt werden") Title("Connection") Icon(*exclamation)
LEaveSR dsData
EndTry
Try
daData = *new OleDbDataAdapter( strSQL, conn )
daData.Fill(dsData)
Catch ex Exception
MsgBox Msg("Daten konnten mit Command '" + strSQL +
"' nicht eingelesen werden") Title("SQL-Fehler") Icon(*exclamation)
LEaveSR dsData
EndTry
LEaveSR dsData
EndFunc
-85Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7. Microsoft Office einbinden
7.1. Einfache Excel-Ausgabe
Hier wird eine selbst erstellte Excel-Schnittstelle eingesetzt die Daten aus einem DataSet
in Arbeitsblätter von Excel ausgibt. Hier ist der Aufruf aus der Ereignisroutine die alle
Excel-Buttons bearbeitet.
/// diese Routine verarbeitet die Events aller Excel-Buttons
/// da die Daten an den Button gebunden sind braucht hier nicht
/// extra noch auf den Button abgefragt und die richtigen Daten
/// gesucht werden
BegSr btnArtikelExcel_Click Access(*Private) Event(*this.btnArtikelExcel.Click, +
*this.btnKundenExcel.Click, *this.btnUmsatzExcel.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
/// einstellen der Sanduhr
*this.Cursor = Cursors.WaitCursor
/// das Button-Objekt übernehmen
DclFld btn
Type(Button)
btn = sender *as Button
/// das DataSet initialisieren
DclFld ds
Type(DataSet)
/// die Datenklasse instanzieren
DclFld cXLS Type(clsXLS)
cXLS = *new clsXLS()
/// das DataSet aus der TAG-Eigenschaft des Buttons holen und an die
/// Excel-Klasse übergeben
ds = btn.tag *as DataSet
cXLS.DataSet = ds
cXLS.LoadExcel()
/// Sanduhr zurückschalten
*this.Cursor = Cursors.Default
EndSr
Hier wird eine Klasse clsXLS mit einem DataSet ausgestattet und danach die Funktion
LoadExcel ausgeführt.
/// ================================================================================
/// Methode LoadExcel ist als einzige Metholde öffentlich verfügbar
/// ================================================================================
//
/// Wie von Microsoft empfohlen werden die Daten die in Excel ausgegeben werden
/// sollen im ClipBoard, also im Arbeitsspeicher aufbereitet.
///
/// Zuerst wird allerdings das Excel-Objekt und darin ein Worksheet erstellt
///
/// Dann werden die Daten im Clipboard aufgebaut und ins Excel geladen
///
/// ist das geschehen wird Excel sichtbar gemacht
///
/// Mit Autofit werden die Spalten in der idealen Breite präsentiert
///
BegFunc LoadExcel Type(*boolean) Access(*public)
DclFld
i
Type(*integer2)
DclFld
bOK
Type(*boolean) INZ(*true)
DclFld
xlApp
Type(Excel.Application)
DclFld
xlBook
Type(Excel.Workbook)
DclFld
xlRange
Type(Excel.Range)
-86Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
DclFld
DclFld
xlSheet
Clip
Type(Excel.Worksheet)
Type( System.Windows.Forms.Clipboard )
SetMousePtr *HourGlass
/// Mauspointer auf Sanduhr stellen
xlApp = *New Excel.Application()
/// Instazieren von Excel
xlBook
xlApp.Visible
= xlApp.Workbooks.Add( *Noparm )
= *True
/// Neues Workbook anlegen
/// Excel anzeigen
/// für jede Tabelle ein Worksheet erstellen
i = 0
ForEach dt Type(DataTable)
Collection(Prop_DataSet.Tables)
i += 1
If i > 3
xlBook.Sheets.Add(*noparm, *noparm, *noparm, *noparm)
Endif
xlSheet = xlbook.Sheets[i] *As Excel.Worksheet /// das Worksheet ansprechen
xlSheet.Name
= Prop_DataSet.Tables(i-1).TableName /// Namen festlegen
Clip.Clear()
Clip.SetDataObject(TableToClip(Prop_DataSet.Tables(i-1)))
/// Clip füllen
xlSheet.Paste(*NoParm, *NoParm )
/// Sheet aus Clipboard füllen
xlRange = xlSheet.Columns
xlRange.AutoFit()
/// Alle Spalten in den Arb.Bereich holen
/// auf ideale Breite formatieren
EndFor
SetMousePtr *dft
/// Mauspointer zurückschalten
LeaveSR bOK
/// Routine verlassen
EndFunc
Für jede übergebene Tabelle wird ein eigenes Excel-Worksheet angelegt.
-87Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.2. Performante Ausgabe einer Tabelle in Excel
Die vorangegangene Version der Excel-Ausgabe ist bei großen Datenmengen sehr
langsam. Hier ist eine Version die eine Tabelle befüllt und dann die Tabelle auf einmal in
Excel ausgibt.
/// Datentabelle aus Memoryfile laden
DclFld dtUmsatz
Type(DataTable)
dtUmsatz =
mCustSales.DataSet.Tables(0)
/// Arbeitsfelder für Zeile und Spalte
DclFld rowIndex
Type(*integer4)
DclFld columnIndex
Type(*integer4)
inz(1)
/// Array deklarieren - mit CreateInstance instanzieren - verlangt Typ, Zeilen und Spalten
DclFld aTable Type(System.Array)
aTable = System.Array.CreateInstance( Type.GetType("System.Object"),
dtUmsatz.rows.count+1, dtUmsatz.Columns.Count)
/// Spaltentitel in erste Zeile ausgeben
ForEach
dc
Type(DataColumn)
Collection(dtUmsatz.columns)
columnindex += 1
aTable.SetValue( dc.ColumnName.tostring(), 0, columnIndex-1 )
EndFor
/// Datenzeilen ausgeben
ForEach
dr
Type(DataRow)
Collection(dtUmsatz.rows)
rowindex += 1
columnindex = 0
/// Werte für jede Zeile eintragen
ForEach dc
Type(DataColumn)
Collection(dtUmsatz.columns)
columnindex += 1
aTable.SetValue( dr[ columnindex-1 ].tostring(), rowIndex-1, columnIndex-1 )
EndFor
endFor
/// Ausgabebereich festlegen und Tabelle einkopieren
xlRange=xlSheet.Range[ xlSheet.Cells[1,1],
xlSheet.Cells[dtUmsatz.rows.count+1,dtUmsatz.Columns.Count] ]
xlRange.Value2 = aTable
7.3. Excel automatisieren
Die Einbindung von iSeries-Daten und –Programmen in Microsoft-Office birgt großes
Rationalisierungspotential.
Alle Microsoft-Office-Produkte können über VisualRPG.NET gesteuert werden. Das
Ergebnis ist eine wesentliche Hilfestellung für den Anwender und somit eine Ersparnis
an Zeit und Steigerung der Effizienz an vielen Arbeitsplätzen.
iSeries-Daten in Excel auszugeben haben wir alle ja schon vor Jahren geschafft. Die
Basislösung war dem Anwender eine Datei im IFS zur Verfügung zu stellen. Diese Datei
enthielt die gewünschten Werte in CSV- oder TAB-Delimited – Format und musste vom
Anwender abgeholt werden.
Mit VisualRPG.NET können wir:
o Daten von der iSeries oder anderen Quellen einlesen
o Excel öffnen
-88Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
o
o
o
o
o
o
o
Arbeitsblätter benennen
Überschriften, Daten und Summenzeilen einfügen
bestimmte Spalten oder ganze Bereiche farblich hervorheben
Schriften und –Attribute festlegen
iSeries-Programme aufrufen und Ergebnisse in Excel-Zellen ablegen
Daten aus Excel an die iSeries zurückgeben, prüfen, aktualisieren, …
u.v.m.
Alle Funktionen die manuell ausgeführt werden setzt MS-Office in Funktionsaufrufe um
die wir auch mit VisualRPG.NET ausführen können. Dieser Leitfaden zeigt am Beispiel
Excel wie Sie als VisualRPG.NET – Programmierer Microsoft-Office-Anwendungen
auftomatisieren können und weist Sie auf mögliche Gefahren und Fallen in den OfficeProdukten hin.
7.4. Beispielanwendung mit Excel
Wir erstellen ein Windows-Dialogprogramm das die Steuerung des Ablaufs übernimmt.
Eingegeben werden Schlüsselwerte der gewünschten Daten sowie Felder die farblich
hervorzuheben oder zu summieren sind.
Schritt 1:
Das Programm öffnet Excel, gibt Überschriften, Daten und Summenzeilen aus, formatiert
das Sheet.
Schritt 2:
Der Benutzer bearbeitet die Daten.
Schritt 3:
Unser Programm prüft die Daten auf Plausibiliät und gibt entsprechende Meldungen im
Sheet aus.
-89Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Schritt 4:
Update der iSeries-Daten aus dem Worksheet.
7.5. Lassen wir uns von Excel helfen
Für uns iSeries-Programmierer ist es kein Problem Daten aus der iSeries zu verarbeiten
oder Programme aufzurufen. Die Herausforderung besteht darin Excel zu erklären was
wir erreichen wollen.
Dazu gibt es eine einfache Methode, man startet den Makro-Recorder, führt die
gewünschten Schritte manuell aus und liest das Ergebnis aus dem aufgezeichneten
Material aus. So lässt man sich von Excel helfen und hat den schnellsten Weg zum
Erfolg gefunden.
Beachten Sie aber dass uns Excel nicht nur hilft sondern auch behindern kann.
7.6. Excel sieht Daten anders
Für Excel sind Daten generell numerisch. Wenn wir nun ein Datenfeld das 5 Nullen
enthält und vielleicht auch noch ein Schlüsselfeld ist ausgeben bleibt in der Zelle nur
eine Null über.
iSeries-Datenfeld –Alpha 5-Stellen
Excel-Zelle
00000
0
Das lässt sich verhindern indem man Excel erklärt dass dieses Feld ‚alpha’ ist und ein
Hochkomma vor den Wert ausgibt.
7.7. Der Standard von Office-Produkten
Wir als Programmierer sind es gewohnt Programme auf den verschiedensten
Betriebssystem-Versionen zu installieren und erwarten dass neuere BetriebssystemVersionen im Mindesten den Funktionsumfang der Vorgänger enthalten.
Dieses Verhalten nennt man ‚Kompatibilität’ den wir von Office in nicht allzu hohem
Maße erwarten sollten.
Es gibt Unterschiede in den Formeln zwischen deutschen und anderssprachigen
Versionen, man sollte auch nicht davon ausgehen dass die Versionen untereinander
kompatibel sind.
Über lange Zeit sind die Formeln und Funktionen von Excel gleich geblieben. Auch
Office2003 ist in der Lage Funktionen seiner Vorgänger zu erfüllen, es bringt aber einen
neuen Ansatz mit.
-90Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.8. XML in Office
Ein Urproblem in der Datenverarbeitung ist die Mischung von Daten und Programmen
innerhalb eines Objekts. Wir sehen das in Excel, wie auch in gänzlich anderen Bereichen
wie ASP, dem Vorläufer von ASPX der Programmcode in HTML-Code ‚einpackt’.
In unserem Excel-Worksheet haben wir Daten, im Hintergrund liegen Formeln oder
Makro’s die wissen was mit den Daten geschehen soll. All das wird in einem Objekt
gespeichert.
Solange es keine Änderung im Werkzeug gibt ist das auch kein Problem, Excel war
ursprünglich konzipiert um Dienste eines Arbeitsblattes (Worksheet) zu übernehmen.
Microsoft hat mit DotNet ein Bekenntnis zu XML abgelegt. XML ist die Sprache in der
Daten beschrieben werden, erfunden von IBM, standardisiert vom W3C und wie so oft
erfolgreich kommerziell genutzt von Microsoft.
Office2003 – Professional setzt auf eine neue Strategie mit Daten umzugehen. Daten
werden von Darstellung und Verarbeitung getrennt was viele Vorteile bietet. Dieselben
Daten können nicht nur in Excel sondern auch in Word oder im Internet dargestellt
werden ohne mehrfach abgespeichert zu sein.
7.9. Beispielanwendung mit Excel
Eingabefelder für Titel, Firmennummer und
Bestellnummer.
Drop-Down-Listen zur Auswahl von Datenfeldern
für Spalten die besonders hervorzuheben und zu
summieren sind.
Das Programm liest die Dateibeschreibung aus
füllt alle Feldnamen in die Liste für die zu
markierenden Daten, die numerischen Felder
werden für die Summierung angeboten.
7.9.1.
Verarbeitungsschritte
Die eingegebene Bestellnummer wird nach der Eingabe auf vorhanden geprüft, erst bei
positiver Feldprüfung erfolgt die Freigabe des ‚Einlesen’-Buttons.
7.9.1.1.
Einlesen
Wurden die erfassten Daten erfolgreich geprüft wird der Einlesen-Button freigegeben.
o Einlesen der Daten von der iSeries in einen ‚Memoryfile’.
o Ein Feld eines jeden Datensatzes enthält ein julianisches Datum und wird mit
einem iSeries-Programm in ein anderes Format umgewandelt das dann in das
Worksheet ausgegeben wird. (Natürlich könnte man das auch mit DotNetFunktionen, es geht darum den Aufruf eines iSeries-Programmes zu zeigen.)
o Erstellen einer Überschrift für das Arbeitsblatt
-91Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
o Feldnamen und Feldlänge als Überschriften in Zeile 2 und 3
o Formatieren des Überschriftsbereichs mit Hintergrundfarbe und Schriftstärke
‚Bold’
o Festlegen der Darstellung des Datenbereiches mit Hintergrundfarben
o Festlegen der Summenfelder
o Füllen der Daten ins Worksheet
7.9.1.2.
Prüfen
o Inhalt jeder Zelle gegen Feldtyp und Feldlänge prüfen
o Inhalt der Schlüsselfelder auf vorhanden prüfen
o Bei Fehler Fehlermeldung ausgeben
o Wenn kein Fehler Merker *Update oder *Neuanlage in Spalte 1 ausgeben
7.9.1.3. Update
o Anhand des Merkers in Spalte 1 Aktion gegen Datenbank ausführen
o Erfolg in ‚Bemerkung’-Spalte ausgeben
7.9.2.
Programmcode
7.9.2.1.
Referenzen
Bevor wir mit Excel arbeiten können muss eine Referenz auf Excel hinzugefügt werden.
Sie finden im Leitfaden AVRWindows unter 7.3.9 eine Beschreibung wie das gemacht
wird. Im Programm importieren wir den Excel-Namespace mit
Using Excel
7.9.2.2.
Deklarationen
Wir beweisen in diesem Beispiel dass wir mit DataGate ohne Codeänderung mit jeder
Datenbank arbeiten können. Deswegen sind hier 3 Datenbank-Objekte deklariert von
denen natürlich nur eines aktiv sein kann.
// Datenbank zur Umwandlungszeit
DclDB
Name( dbProduction )
//
DclDB
Name( dbProduction )
//
DclDB
Name( dbProduction )
DBname( "ASNA SQL DB" )
DBname( "*public/DG NET LOCAL" )
DBname( "ATNICE" )
Hier sind die File-Deklarationen, der MemoryFile ist für den RPG-Programmierer eine Art
Subfile. In DotNet nennt man das DataSet.
// Deklaration Eingabedaten
DclDiskFile
Name
DclMemoryFile
Name
( F4211LA
)
Type( *Update )
DB
( dbProduction )
+
File
( "*Libl/F4211LA" )
Org
( *Indexed
)
Addrec ( *yes
)
ImpOpen ( *No
)
( memF4211 )
FileDesc
RnmFmt
ImpOpen
-92Dokument D:\75878992.doc
+
+
+
+
DBDesc
( dbProduction )
( "*Libl/F4211" )
+
( I4211,R4211 )
+
( *No
)
+
RPG.NET BESTPRACTICES
Die Excel-Objekte und Datenfelder die wir zur Verarbeitung von Excel brauchen
deklarieren wir global am Programmbeginn.
// Excel-Objekte und Datenfelder
DclFld
xlApp
DclFld
xlBook
DclFld
xlRange
DclFld
xlSheet
DclFld
IX
DclFld
IR
DclFld
NumRecs
DclFld
@Cancel
DclFld
@CRLF
DclFld
iFieldCount
DclFld
iEndHeader
DclFld
iStrData
DclFld
iEndData
DclFld
iMarkColumn
DclFld
iMsgColumn
DclFld
iKeyColumn
Type(Excel.Application)
Type(Excel.Workbook)
Type(Excel.Range)
Type(Excel.Worksheet)
Type( *Integer4 )
Type( *Integer4 )
Type( *Integer4 )
Type( *Boolean )
Type( *String )
Type( *Integer4 )
Type( *Integer4 )
Type( *Integer4 )
Type( *Integer4 )
Type( *Integer4 )
Type( *Integer4 )
Type( *Integer4 )
// Konstante zur Aufbereitung von Excel
DclConst
@TAB
Value( U'0009')
DclConst
@NEW
Value("*Neuanlage")
DclConst
@UPD
Value("*Update")
DclConst
@DEL
Value("*DELETE")
Der Datenzugriff läuft über Dateien mit Schlüssel. Wir leiten die Schlüsselfelder im
Programm von Datenfeldern der Datei ab und deklarieren einige Variablen die Verweise
auf die Spaltennummer enthalten.
// Keyfelder
DclFld
kfVON
Like(SDDOCO)
// Keylist anlegen
DclKlist klUpdate
DclKfld kfSDDOCO
DclKfld kfSDDCTO
DclKfld kfSDKCOO
DclKfld kfSDLNID
// Schlüsselfelder für Key anlegen
DclFld kfSDDOCO
Like(SDDOCO)
DclFld kfSDDCTO
Like(SDDCTO)
DclFld kfSDKCOO
Like(SDKCOO)
DclFld kfSDLNID
Like(SDLNID)
// Konstante für Schlüsselfelder
DclConst
fnSDDOCO
Value("SDDOCO")
DclConst
fnSDDCTO
Value("SDDCTO")
DclConst
fnSDKCOO
Value("SDKCOO")
DclConst
fnSDLNID
Value("SDLNID")
// Spalten für Schlüsselfelder
DclFld ikSDDOCO
*integer2
DclFld ikSDDCTO
*integer2
DclFld ikSDKCOO
*integer2
DclFld ikSDLNID
*integer2
-93Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Um ein iSeries-Programm aufzurufen und Daten auszutauschen kann man, wie in RPG
üblich, Parameterlisten deklarieren. Hier sind die Felder und die Deklarationen.
// Parameterfelder deklarieren
DclFld parm#SIDAT
Type(*char)
DclFld parm#EDAT
Type(*char)
DclFld parm#FFMT
Type(*char)
DclFld parm#TFMT
Type(*char)
DclFld parm#SEP
Type(*char)
DclFld parm$ERTST
Type(*char)
DclFld parm$CTRY
Type(*char)
DclFld parm#FJPN
Type(*char)
DclFld parm#TJPN
Type(*char)
DclFld parm#EDAT2
Type(*char)
DclFld parm#SIDT2
Type(*char)
Len(6)
Len(8)
Len(7)
Len(7)
Len(7)
Len(1)
Len(2)
Len(1)
Len(1)
Len(10)
Len(8)
// Parameterliste anlegen
DclPlist
plX0028
DclParm parm#SIDAT
DclParm parm#EDAT
DclParm parm#FFMT
DclParm parm#TFMT
DclParm parm#SEP
DclParm parm$ERTST
DclParm parm$CTRY
DclParm parm#FJPN
DclParm parm#TJPN
DclParm parm#EDAT2
DclParm parm#SIDT2
// Spalte für Summenfeld
DclFld iSUMFLD *integer2
/Endregion
7.9.2.3.
Constructor
Der Konstruktor ist der Einsprungpunkt für das Programm. Mit InitializeComponent
werden die Controls initialisert. Es macht Sinn hier die Datenbankverbindung
aufzubauen und die Dateien zu eröffnen.
Die Dispose-Subroutine ist die letzte Routine die in diesem Programm ausgeführt wird,
hier sollte man die Daten und die Verbindung zur Datenbank schliessen.
/Region Constructor
BegSr Dispose Access(*Public) Modifier(*Overrides)
DclSrParm disposing Type(*Boolean)
If disposing
//
// TODO: close your files and disconnect your databases here
//
Close F4211LA
Close memF4211
DisConnect dbProduction
EndIf
*Base.Dispose(disposing)
EndSr
BegConstructor Access(*Public)
//
// Required for Windows Form Designer support
//
InitializeComponent()
//
// TODO: Add any constructor code after InitializeComponent call
//
Connect dbProduction
-94Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Open F4211LA
Open memF4211
stb.Text = "DB " + dbProduction.DBName + " in Verwendung"
EndConstructor
/endregion
7.9.2.4.
Events
Hier werden die Ereignisse abgearbeitet. Im Initialisieren werden die Datenlisten in den
Comboboxen aus der Feldbeschreibung der Daten eingelesen.
/Region Events
// Initialisierungsarbeiten Formular
BegSr Form1_Load Access(*Private) Event(*this.Load)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
// Zeilenschaltung initialisieren
@CRLF = System.Environment.NewLine
// Error-Provider auf KundenNummer setzen
epSDDOCO.SetIconAlignment(*this.txtSDDOCO, ErrorIconAlignment.MiddleRight)
epSDDOCO.SetIconPadding(*this.txtSDDOCO, 2)
epSDDOCO.BlinkRate = 1000
epSDDOCO.BlinkStyle = System.Windows.Forms.ErrorBlinkStyle.AlwaysBlink
// Felder aus Tabelle einlesen und in ComboBox ausgeben
ForEach dc
Type(DataColumn) +
Collection(memF4211.DataSet.Tables(0).Columns())
cboFelder.Items.Add(dc.ColumnName)
// -1 sind numerische Werte
if dc.Maxlength < 0
cboSummenFeld.Items.Add(dc.ColumnName)
Endif
EndFor
EndSr
// bei Klick auf Start wird diese Routine aufgerufen
BegSr btnStart_Click Access(*Private) Event(*this.btnStart.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
SetMousePtr *HourGlass
ExSr
ExSr
ExSr
ExSr
LoadDataFromFile
InitExcel
CreateExcelHeader
PutDataIntoExcel
// Schalten der Buttons
btnCheck.Enabled = *true
btnUpdate.Enabled = *true
btnStart.Enabled = *false
// Meldung an den Benutzer
MsgBox Msg("Bearbeiten Sie nun die Daten in Excel") +
Title("Daten bereit") Icon(*information)
SetMousePtr *Dft
EndSr
// bei Klick auf Prüfen wird ProcessData mit *true (=prüfen) aufgerufen
BegSr btnCheck_Click Access(*Private) Event(*this.btnCheck.Click)
-95Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
ProcessData(*true)
EndSr
// bei Klick auf Update wird ProcessData mit *false (=Update) aufgerufen
BegSr btnUpdate_Click Access(*Private) Event(*this.btnUpdate.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
// *false führt Update durch, der Rückgabewert gibt den Erfolg bekant
If ProcessData(*false)
MsgBox Msg("Speichern der geänderten Daten erfolgreich") + Title("Daten
geändert") Icon(*information)
Else
MsgBox Msg("Fehler bei Speichern der Daten") +
Title("Daten korrigieren") Icon(*exclamation)
Endif
*this.Close()
EndSr
/Endregion
7.9.2.5.
Logik
In dieser Region werden alle Subroutinen und Funktionen abgelegt die mit dem Handling
der Daten zu tun haben. Sie finden hier Routinen vom Einlesen der Daten bis zur
Prüfung der Auftragsnummer.
7.9.2.5.1.
Einlesen der Daten mit ReadRange
ReadRange ist ein neuer OpCode von ASNA der den Zugriff auf einen bestimmten
Bereich in der Datei eingrenzt. Es können Unter- und Obergrenze gesetzt werden.
Ausgegeben werden die Daten in einen MemoryFile der ein DotNet-DataSet darstellt und
für den iSeries-Programmierer mit einem Subfile vergleichbar ist.
/Region Logic
// Daten aus der iSeries in Excel laden
BegSr LoadDataFromFile
// neuer Command von ASNA ersetzt SETLL
ReadRange F4211LA Firstkey(kfVON) Access(*nolock)
If %Found
DoWhile NOT %EOF(F4211LA)
IF SDKCOO = txtSDKCOO.Text
// Spalte mit Daten aus iSeries-Programm füllen
SDVR01 = GetDateOutOfJulian(SDDRQJ)
Write memF4211
Endif
Read F4211LA
Enddo
Endif
EndSR
7.9.2.5.2.
Aufrufen eines iSeries-Programmes
Die Parameterfelder und Parameterlisten wurden bereits vorbereitet. In dieser Routine
wird nur mehr der Aufruf abgehandelt.
Die Funktion bekommt einen numerisch-gezonten Input-Parameter und liefert ein Datum
in Form einer Zeichenkette zurück.
-96Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
// Julianisches Datum über iSeries-Programm auslesen
BegFunc GetDateOutOfJulian
Type(*string)
DclSrPArm
zonInVal
like(SDDRQJ)
parm#SIDAT = zonInVal.ToString()
Call Pgm("Petroplus/X0028")
Parmlist(plX0028)
DB(dbProduction)
Err(*extended) +
LeaveSR parm#EDAT
EndFunc
7.9.2.5.3.
Erstellen des Excel-Objektes
Das Feld xlApp wird als Excel-Objekt instanziert und hält die Verbindung zwischen
Programm und Worksheet. Hier werden ins Worksheet ein Workbook ausgegeben, das
erste Worksheet wird mit dem Namen des Titels benannt.
// Excel-Worksheet erstellen
BegSr InitExcel
// Excel instanzieren
xlApp = *New Excel.Application()
xlApp.Visible
= *True
xlApp.WindowState = XlWindowState.xlMaximized
// Neues Workbook anlegen und erstes Sheet benennen
xlBook
= xlApp.Workbooks.Add( *Noparm )
xlSheet
= xlbook.Sheets[1] *As Excel.Worksheet
xlSheet.Name = txtTitel.Text
EndSR
7.9.2.5.4.
Ausgeben der Überschrift
In Zeile 1 wird der Titel des Worksheets, in Zeile 2 und 3 der Feldname und die
maximale Feldlänge ausgegeben.
In der Schleife über die Felder werden die Spalten der Keyfelder in die Arbeitsfelder
ausgegeben um sie bei der Prüfung einfach ansprechen zu können.
// Überschriftszeile in Excel ausgeben
BegSr CreateExcelHeader
DclFld i
DclFld strLength
*integer2
*string
//Feldanzahl ermitteln
iFieldCount = memF4211.DataSet.Tables(0).Columns.Count()
// Titel festlegen, Spalten verbinden und zentrieren
xlSheet.Cells[1,1] = txtTitel.Text
xlRange = xlSheet.Range[xlSheet.Cells[1,1], xlSheet.Cells[1,iFieldCount+1]]
xlRange.HorizontalAlignment = xlHAlign.xlHAlignCenter
xlRange.Merge( *NoParm )
// Feldnamen und Max.Länge in Überschrift holen
xlSheet.Cells[2,1] = "Feldname"
xlSheet.Cells[3,1] = "Max.Länge"
// Schleife über Datenfelder zur Ausgabe der Felddaten in Überschrift
ForEach dc
Type(DataColumn)
Collection(memF4211.DataSet.Tables(0).Columns())
i = i + 1
strLength = dc.Maxlength.Tostring()
// -1 sind numerische Werte
xlSheet.Cells[2,i+1] = dc.ColumnName
if NOT strLength.StartsWith("-")
-97Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
xlSheet.Cells[3,i+1] = dc.Maxlength.Tostring()
Endif
// herausfinden der Spalte die farblich markiert werden soll
if dc.ColumnName = cboFelder.Text
iMarkColumn = i+1
Endif
// merken der Spalte mit dem Satzkey
Select
when dc.ColumnName.ToUpper() =
ikSDDOCO = i+1
when dc.ColumnName.ToUpper() =
ikSDDCTO = i+1
when dc.ColumnName.ToUpper() =
ikSDKCOO = i+1
when dc.ColumnName.ToUpper() =
ikSDLNID = i+1
Endsl
fnSDDOCO
fnSDDCTO
fnSDKCOO
fnSDLNID
If dc.ColumnName.ToUpper() = cboSummenfeld.text
iSUMFLD = i+1
Endif
EndFor
// Letzte Überschriftszeile merken
iEndHeader = 3
// Bemerkungsfeld anhängen
iMSgColumn = iFieldCount+2
xlSheet.Cells[3,iMSgColumn] = "Bemerkung"
xlRange = xlSheet.Range[xlSheet.Cells[1,iMSgColumn], xlSheet.Cells[3,iMSgColumn]]
xlRange.VerticalAlignment = xlVAlign.xlVAlignCenter
xlRange.Merge( *NoParm )
// Überschriftsbereich auswählen
xlRange=xlSheet.Range[xlSheet.Cells[1,1], xlSheet.Cells[3,iMSgColumn]]
// Einstellungen für Bereich festlegen
With xlRange
.Horizontalalignment = xlHAlign.xlHAlignCenter
.Font.Bold
= 1
// Achtung *ON arbeitet hier nicht
.Font.Name
= 'Arial'
.Font.Size
= 10
.Interior.Colorindex = 15
// Hellgrau
.Interior.Pattern
= 1
// xlSolid
.Borders.Linestyle
= 1
// Durchgehende Linie
.Borders.Weight
= 3
// Mittelbreit
EndWith
EndSR
7.9.2.5.5.
Ausgeben der Daten
Ein von Microsoft empfohlener Weg ist es die Daten in den Zwischenspeicher ‚Clipboard’
zu laden um sie dann an Excel zu übergeben. Die Felder werden mit TAB getrennt und
am Ende der Zeile ein CRLF eingefügt.
Nachdem die Zeilen eingefügt wurden ist das Summenfeld einzufügen und die
Formatierung anzupassen.
// Daten in Excel ausgeben
BegSr PutDataIntoExcel
DclFld
DclFld
DclFld
DclFld
strWrk *string
Clip
Type( System.Windows.Forms.Clipboard )
strSumme
*string
strError
*string
// Schleife über die Sätze des MemoryFiles
ForEach dr
Type(DataRow) Collection(memF4211.DataSet.Tables(0).rows)
// Schleife über alle Felder
-98Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
ForEach dc Type(DataColumn) Collection(memF4211.DataSet.Tables(0).Columns)
// Feld für Feld einlesen
strWrk = strWrk + @TAB + dr.Item(dc.ColumnName).Tostring()
EndFor
// Zeilenschaltung am Satzende
strWrk = strWrk + @CRLF
EndFor
// Beginn und Ende der Datenzeilen festlegen
iStrData = iEndHeader + 1
iEndData = istrData + memF4211.DataSet.Tables(0).rows.Count - 1
// gewünschte Spalte markieren
if iMarkColumn > 0
xlRange=xlSheet.Range[xlSheet.Cells[istrData,iMarkColumn],
xlSheet.Cells[iEndData,iMarkColumn]]
With xlRange
.Font.Bold
= 1
// Achtung *ON arbeitet hier nicht
.Font.Name
= 'Arial'
.Font.Size
= 10
.Interior.Colorindex = 34
// Hellblau
.Interior.Pattern
= 1
// xlSolid
.Borders.Linestyle
= 1
// Durchgehende Linie
.Borders.Weight
= 2
// schmal
EndWith
Endif
// Bemerkungsfeld formatieren
xlRange=xlSheet.Range[
xlSheet.Cells[1,iMSgColumn], xlSheet.Cells[iEndData,iMSgColumn] ]
xlRange.Interior.Colorindex= 40
// Rosa
xlRange.Interior.Pattern
= 1
// xlSolid
xlRange.Borders.Linestyle
= 1
// Durchgehende Linie
xlRange.Borders.Weight = 3
// Mittelbreit
// Summenfeld einbauen
if iSUMFLD > 0
xlRange = xlSheet.Range[ xlSheet.Cells[iEndData+1,iSUMFLD],
xlSheet.Cells[iEndData+1,iSUMFLD] ]
strSumme = "=SUMME(Z" + istrData.ToString() + "S" + iSUMFLD.ToString() + ":Z" +
iEndData.ToString() + "S" + iSUMFLD.ToString() + ")"
Try
xlRange.FormulaR1C1 = strsumme
Catch ex Exception
strError = ex.Message
EndTry
With xlRange
.Font.Bold
= 1
.Font.Name
= 'Arial'
.Font.Size
= 10
.Interior.Colorindex = 15
// Hellgrau
.Interior.Pattern
= 1
// xlSolid
.Borders.Linestyle
= 1
// Durchgehende Linie
.Borders.Weight
= 3
// Mittelbreit
EndWith
Endif
// Daten aus Clipboard in Excel übergeben
xlSheet.Range[ xlSheet.Cells[istrData,1], xlSheet.Cells[iEndData,iFieldCount + 1] ].Select(
)
Clip.SetDataObject ( strWrk )
xlSheet.Paste ( *NoParm, *NoParm )
// Autofit für alle Spalten ausführen
xlRange = xlSheet.Columns
// Select all columns
xlRange.AutoFit()
EndSR
-99Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.9.2.5.6.
Prüfroutinen aus dem UserDialog
Hier sind die Prüfroutinen die aus dem Formular angesprochen werden.
// Prüfung des Eingabefeldes Nummer
BegFunc NummerOK
Type(*boolean)
// sicherheitshalber den Start-Button deaktivieren
btnStart.Enabled = *false
// wenn leer - keine Prüfung
If txtSDDOCO.Text = *blank
LeaveSr *true
Endif
// ist der Wert numerisch - feststellen durch zuweisen in gepacktes Feld
Try
kfVON = txtSDDOCO.Text
Catch ex Exception
stb.Text = "Auftragsnummer ist nicht numerisch"
LEaveSr *false
EndTry
// prüfen ob der Kunde existiert
Chain F4211LA Key(kfVON)
If %found
btnStart.Enabled = *true
stb.Text = "Daten für Auftrag " + %trim(txtSDDOCO.text) +
" können verarbeitet werden"
LEaveSR *true
Else
stb.Text = "Auftrag wurde nicht gefunden"
LeaveSr *false
Endif
LEaveSR *true
EndFunc
// prüfen der Kundennummer
BegSr txtSDDOCO_Validated Access(*Private)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
Event(*this.txtSDDOCO.Validated)
If NummerOK()
// Fehler im ErrorProvider löschen
epSDDOCO.SetError(*this.txtSDDOCO, "")
Else
// Fehler im Errorprovider setzen
epSDDOCO.SetError(*this.txtSDDOCO, "Auftragsnummer st ungültig")
EndIf
EndSr
/endregion
7.9.2.5.7.
Prüf- und Verarbeitungs-Hauptroutine
Diese Routine prüft oder verarbeitet die Daten, abhängig vom Aufrufparameter. Werden
bei der Prüfung Fehler gefunden wird eine MessageBox angezeigt. Die Verarbeitung pro
Zeile läuft in einer eigenen Routine der die Zeilennummer übergeben wird.
// eine eigene CodeRegion für den Dialog Excel/iSeries
/region Prüfen und Update
// Datenverarbeitung prüfen oder updaten
// wird über eine Routine abgewickelt die die Steuerung übernimmt
BegFunc ProcessData
Type(*boolean)
DclSrParm
bCheck *boolean // *True = prüfen, *False = Update
-100Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
// Diverse Variablen
DclFld bOK
Type(*boolean) inz(*true)
DclFld i
*integer4
DclFld iErrCnt *integer4
// Schleife über die Datenfelder
Do iStrData
iEndData
i
//
//
//
If
iErrCnt wird per Referenz übergeben, somit wird im
aufgerufenen Programm die Variable aus dieser Routine
bearbeitet
bCheck
if not CheckLine(i,*ByRef iErrCnt)
bOK = *false
Endif
Else
if not UpdateLine(i,*ByRef iErrCnt)
bOK = *false
Endif
Endif
Enddo
// Autofit für alle Spalten ausführen
xlRange = xlSheet.Columns
xlRange.AutoFit()
// Meldung ausgeben wenn Fehler gefunden wurden
If not bOK
MSgBox Msg("Es wurden " + iErrCnt.ToString() + " Fehler gefunden")
Title("Fehler in Daten") Icon(*information)
Endif
LeaveSr bOK
EndFunc
7.9.2.5.8.
Prüfen einer Zeile
Die Prüfung erfolgt durch zuweisen des Feldwerts in das Datenfeld und Prüfung der
Länge bei Alpha-Felder. Dabei werden Fehler abgefangen und im Fehlerfall eine
Meldung zurückgegeben und der Fehlerschalter erhöht.
Der Satzkey wird gegen die Datei geprüft um festzustellen ob der Satz bereits existiert.
Entsprechend wird ein Hinweis in die erste Spalte ausgegeben.
// prüfen einer Datenzeile
// die Zeilennummer wird per Value übergeben
// der Fehlerzähler per Referenz, dadurch wird die Variable iErrCnt im
// aufrufenden Programm verwendet,
// der Name ist egal, der Typ muss übereinstimmen
BegFunc
CheckLine
Type(*boolean)
DclSrParm
iLine *integer4
DclSrParm
iErrors *integer4
By(*reference)
// diverse Felder
DclFld i
DclFld dr
DclFld strMsgText
DclFld strFeld
DclFld strWert
DclFld strMaxLen
DclFld iMaxLen
DclFld bOK
*integer4
Type(DataRow)
*string
*string
*string
*string
*Integer2
*boolean
Inz(*true)
// zur Prüfung einen neuen Satz erstellen der aber nicht ausgegeben wird
dr = memF4211.DataSet.Tables(0).NewRow()
strMsgText = *blank
// Schleife über die Excel-Datenfelder
Do Fromval(2) Toval(iMsgColumn-1) Index(i)
// Feldnamen herausfinden
-101Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
xlRange = xlSheet.Cells[2,i] *as Range
xlRange.Select()
strFeld = xlRange.Text.ToString()
// für Zeichenfelder Feldlänge herausfinden
xlRange = xlSheet.Cells[3,i] *as Range
xlRange.Select()
strMaxLen = xlRange.Text.ToString()
if strMAxlen <> *blank
iMaxLen = strMaxLen
Else
iMAxLen = 0
Endif
// Feldwert aus Datenzeile einlesen
xlRange = xlSheet.Cells[iLine,i] *as Range
xlRange.Select()
strWert = xlRange.Text.ToString()
// Fehler abfangen (CPF0000)
try
// versuchen den Feld den Wert zu übergeben
dr.Item(strFeld) = strWert
Catch ex Exception
// bei FEhler reagieren
strMsgText = strMsgText + strFeld + "(" + ex.Message + ");"
iErrors = iErrors + 1
xlRange=xlSheet.Range[ xlSheet.Cells[iLine,i], xlSheet.Cells[iLine,i]
]
xlRange.Interior.Colorindex = 40
// Rosa
bOk = *false
EndTry
// Zeichenfelder auf gültige Länge prüfen
if strWert.Length > iMaxLen and iMaxLen > 0
strMsgText = strMsgText + strFeld +
"(um " + %char(strWert.Length - iMaxLen) +
" Stellen zu lang);"
iErrors = iErrors + 1
xlRange=xlSheet.Range[ xlSheet.Cells[iLine,i], xlSheet.Cells[iLine,i]
]
xlRange.Interior.Colorindex = 40
// Rosa
bOk = *false
Endif
// merken Felder für den Satzkey
Select
when i = ikSDDOCO
kfSDDOCO = strWert
when i = ikSDDCTO
kfSDDCTO = strWert
when i = ikSDKCOO
kfSDKCOO = txtSDKCOO.text // strWert
when i = ikSDLNID
kfSDLNID = strWert
Endsl
Enddo
// wenn kein Fehler auf Datensatz der iSEries prüfen
// und *Update/*Neuanlage in erste Spalte ausgeben
if strMsgText = *blank
kfSDKCOO = "00000"
Chain F4211LA Key(klUpdate) // nicht für SQL-Server Access(*nolock)
IF %found()
xlSheet.Cells[iLine,1] = @UPD
Else
xlSheet.Cells[iLine,1] = @NEW
Endif
-102Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
UNLOCK F4211LA // für SQL-Server
Endif
// Text in Meldungsspalte ausgeben
xlSheet.Cells[iLine,iMsgColumn] = strMsgText
LeaveSR bOK
EndFunc
7.9.2.5.9.
Update des Datensatzes
Angängig vom Wert der Spalte 1 werden die Daten der Zeile verarbeitet. Ist hier *Delete,
*Update oder *Neuanlage so wird die entsprechende Funktion ausgeführt.
Die Schlüsselfelder werden aus der in der Load-Routine herausgefundenen Spalte
geladen. Die Zuweisung der Daten in die Felder erfolgt über den Feldnamen.
// Update der iSeries aus einer Datenzeile von Excel
BegFunc
UpdateLine
Type(*boolean)
DclSrParm
iLine *integer4
DclSrParm
iErrors *integer4 By(*reference)
DclFld
DclFld
DclFld
DclFld
DclFld
DclFld
DclFld
i
dr
strMsgText
strFeld
strWert
strVerarb
bOK
*integer4
Type(DataRow)
*string
*string
*string
*string
*boolean
Inz(*true)
strMsgText = *blank
// Verarbeitung nur wenn Spalte 1 nicht leer
xlRange = xlSheet.Cells[iLine,1] *as Range
xlRange.Select()
strVerarb = xlRange.Text.ToString()
if strVerarb = *blank
LeaveSr bOK
Endif
// Keyfelder für Update auslesen
xlRange = xlSheet.Cells[iLine,ikSDDOCO] *as Range
xlRange.Select()
kfSDDOCO = xlRange.Text.ToString()
xlRange = xlSheet.Cells[iLine,ikSDDCTO] *as Range
xlRange.Select()
kfSDDCTO = xlRange.Text.ToString()
//
//
//
weil Excel die ‘00000’ auf ‘0’ verkürzt …
xlRange = xlSheet.Cells[iLine,ikSDKCOO] *as Range
xlRange.Select()
kfSDKCOO = txtSDKCOO.Text // xlRange.Text.ToString()
xlRange = xlSheet.Cells[iLine,ikSDLNID] *as Range
xlRange.Select()
kfSDLNID = xlRange.Text.ToString()
// wenn Satz gelöscht werden soll
If strVerarb.ToUpper() = @DEL
Delete F4211LA Key(klUpdate) Err(*extended)
If %Error()
strMsgText = "Fehler bei Löschen Datensatz"
iErrors = iErrors + 1
bOK = *false
Else
strMsgText = "Löschen erfolgreich"
Endif
Else
-103Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
// Satz auf iSeries sperren
Chain F4211LA Key(klUpdate)
Access(*dft)
// Update auf Datenfelder
Do Fromval(2) Toval(iMsgColumn-1) Index(i)
xlRange = xlSheet.Cells[2,i] *as Range
xlRange.Select()
strFeld = xlRange.Text.ToString()
xlRange = xlSheet.Cells[iLine,i] *as Range
xlRange.Select()
strWert = xlRange.Text.ToString()
try
Select
when strFeld = "SDMCU"
SDMCU = strWert
when strFeld = "SDLITM"
SDLITM = strWert
when strFeld = "SDOCTO"
SDOCTO = strWert
EndSL
// evtl. Fehler abfangen
Catch ex Exception
strMsgText = strMsgText + strFeld +
"(" + ex.Message + ");"
iErrors = iErrors + 1
xlRange=xlSheet.Range[xlSheet.Cells[iLine,i],
xlSheet.Cells[iLine,i] ]
xlRange.Interior.Colorindex = 40
bOk = *false
EndTry
Enddo
// wenn kein Fehler Update/Write ausführen
if strMsgText = *blank
IF %found()
Update F4211LA Err(*extended)
Else
Write F4211LA Err(*extended)
Endif
If %Error()
strMsgText = "Fehler bei Ausgabe in Datenbank"
iErrors = iErrors + 1
bOK = *false
Else
strMsgText = "Ausgabe erfolgreich"
Endif
Endif
UNLOCK F4211LA // für SQL-Server
Endif
// Meldung in Infospalte ausgeben
xlSheet.Cells[iLine,iMsgColumn] = strMsgText
LeaveSR bOK
EndFunc
/Endregion
-104Dokument D:\75878992.doc
// Rosa
RPG.NET BESTPRACTICES
7.10.Office-Funktionen herausfinden
7.10.1. Makro einsetzen
Ein Großteil der Zeit die man für Office-Programmierung benötigt geht damit verloren
nach Funktionen von Office zu suchen.
Wenn man im Internet nach Lösungen sucht muss man sich erfahrungsgemäß durch
Tonnen von Datenmüll suchen bis man die gewünschte Lösung gefunden hat.
In der Excel-Hilfe kann es vorkommen dass man Lösungen angeboten bekommt die zur
englischen Originalversion passen aber für die Sprachversion nicht verwendbar sind.
Der beste Weg ist Office selbst die Lösung beschreiben zu lassen, das geht wie folgt:
1. Makro-Aufzeichnung starten
2. gewünschte Funktion ausführen
3. Aufzeichnung beenden
4. VB-Editor aufrufen
-105Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Das Makro enthält die ausgeführten Funktionen.
Dieser Code lässt sich in das Programm übertragen, Beispiele dazu sehen in jeder
Routine.
7.10.2. Vorsicht bei Formeln
Die Summenformel ist so nicht in Excel übertragbar.
Achten Sie auch darauf bei Einfügen von Formeln mögliche Fehler abzufangen.
Excel wirft eine Fehlermeldung aus wenn eine ungültige Formel ausgegeben wird die
das Programm zum Absturz bringt wenn Sie nicht in einem Try-Catch-Block abgefangen
wird.
Prüfen Sie Formeln mit der Online-Hilfe. Hier ist zur Erinnerung der Code aus unserem
Beispiel.
// Summenfeld einbauen
if iSUMFLD > 0
xlRange = xlSheet.Range[ xlSheet.Cells[iEndData+1,iSUMFLD],
xlSheet.Cells[iEndData+1,iSUMFLD] ]
strSumme = "=SUMME(Z" + istrData.ToString() + "S" + iSUMFLD.ToString() + ":Z" +
iEndData.ToString() + "S" + iSUMFLD.ToString() + ")"
Try
xlRange.FormulaR1C1 = strsumme
Catch ex Exception
strError = ex.Message
EndTry
With xlRange
.Font.Bold
= 1
.Font.Name
= 'Arial'
.Font.Size
= 10
.Interior.Colorindex = 15
// Hellgrau
.Interior.Pattern
= 1
// xlSolid
.Borders.Linestyle
= 1
// Durchgehende Linie
.Borders.Weight
= 3
// Mittelbreit
EndWith
Endif
Die funktionierende Summenformel die hier ausgegeben wird lautet "=SUMME(Z3S3:Z6S3)"
Unser VB-Makro empfiehlt aber "=SUM(R[-3]C:R[-1]C)", diese Funktion arbeitet definitiv
nicht.
Formeln sind immer abhängig von der Office-Version und der Sprache. Der Wunsch von
Microsoft war es dem Benutzer die Arbeit so angenehm wie möglich zu machen, für den
Programmierer ist dadurch die Arbeit nicht einfacher geworden.
-106Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.11.Integration von Word und iSeries mit RPG.NET
7.11.1. Konzept
Kunden- Artikelund WWS-Daten
von der iSeries
Bilder und Texte
vom Server
Ausgabe in ein
Word-Dokument
Druck und
Versand per Post
Direkt in eMail
ausgeben
Dokumentarchiv
oder elektron.
Archiv
-107Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.11.2. Umsetzung
7.11.2.1. Kopf- und Fussinformationen
Das Bearbeitungsprogramm wird mit Kopf- und Fußdaten vorbelegt. Die Erfassung der
Positionen erfolgt über komfortable Dialoge.
Zum Kopftext kann ein Bild ausgewählt werden.
-108Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.11.2.2. Artikelpositionen
Die Artikelliste wird über den Auswahl-Link aufgerufen. Die Auswahl erfolgt über
markieren und OK.
Die Mengen und
Preise werden direkt
im Grid editiert.
Der Gesamtwert wird
automatisch
mitgerechnet.
Die Detailmaske zeigt die
Positionsdaten an und lässt
Bilder und Texte für den Druck
vor
und/oder
nach
der
Positionszeile erfassen.
-109Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Die Auswahl und Bearbeitung von
Bildern und Texten erfolgt über
Kontext-Menü’s.
Die Dateiauswahl basiert auf den
gewohnten Windows-Dialogen.
-110Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
In den Textbereichen sind
Bearbeitungsmöglichkeiten
vorgesehen. Einige häufig
verwendete
wie
Fett/Unterstreichen werden
direkt angeboten.
Natrülich
können auch
Tabellen und Bilder in den
Texten mitkommen.
Anspruchsvollere
Formatierungswünsche
werden
über
den
‚Schriftart’-Dialog erfüllt.
-111Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Die Positionstabelle bietet eine Übersicht über die erfassten Positionen und ihre
Zusatzinformationen.
-112Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.11.3. Das Ergebnis
Dieses Beispiel zeigt dass es problemlos möglich ist Daten, Text und Bilder über
RPG.NET weiterzuverarbeiten.
Beachten Sie dass die Textattribute wie Fett, Unterstrichen, Farbe etc. vollständig
übernommen werden.
Die Formateinstellungen des Basisdokuments wurden übernommen, können aber auch
übersteuert werden.
-113Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
7.11.4. Technische Voraussetzungen
Die Voraussetzungen am Client sind




Betriebssystem Windows
IP-Verbindung zur iSeries
ASNA-DataGate zum Zugriff (auf der iSeries)
MS-Word zur Bearbeitung der Dokumente
Die Textbausteine und Vorlagen werden in RTF-Format vorbereitet, die Ausgabe erfolgt
in Word.
RTF ist ein standardisiertes Format für Texte das auch von Word gelesen und
ausgegeben werden kann.
7.11.5. Programmcode Word
Hier ist die Druckroutine für die Ausgabe in Word, natürlich ist das Word-Objekt wie
Excel zu referenzieren.
In einer Vorlaufschleife werden für jede Datenzeile zuerst Objekte erstellt die danach in
ein einziges Dokument gebunden werden.
/region Word
BegSr btnDrucken_Click Access(*Private) Event(*this.btnDrucken.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
Löschen
bestehender
RTF-Files und sichern
der aktuellen RTF-Files
If File.Exists(strWorkDir + "\KOPF.rtf")
File.Delete(strWorkDir + "\KOPF.rtf")
Endif
rtbKopf.SaveFile(strWorkDir + "\KOPF.rtf", RichTextBoxStreamType.RichText)
If File.Exists(strWorkDir + "\FUSS.rtf")
File.Delete(strWorkDir + "\FUSS.rtf")
Endif
rtbFuss.SaveFile(strWorkDir + "\FUSS.rtf", RichTextBoxStreamType.RichText)
DclFld picTag Type(PICClass)
new()
picTag = pbKopf.Tag *as PICClass
If File.Exists(strWorkDir + "\KOPF")
File.Delete(strWorkDir + "\KOPF")
Endif
if pbKopf.Image <> *nothing
File.Copy(picTag.FileName,strWorkDir + "\KOPF")
Endif
DclFld
DclFld
DclFld
dclfld
dclfld
dclfld
dclfld
dclfld
dclfld
strInFileName *string
strInPosName
*string
strOutFileName *string
WordApp
type(Word.Application)
WordDoc
type(Word.Document)
Selection
type(Word.Selection)
ActiveDocument
type(Word.Document)
Table1
type(Word.Table)
Row
type(Word.Row)
-114Dokument D:\75878992.doc
Deklaration der
Word-Objekte
RPG.NET BESTPRACTICES
dclfld Range
type(Word.Range)
strInFileName
= asrApp.GetValue("Vorlage", Type.GetType("System.String")) *as
String
strInPosName
= asrApp.GetValue("PosVorlage", Type.GetType("System.String")) *as
String
strOutFileName = asrApp.GetValue("AusgabePfad", Type.GetType("System.String")) *as
String
strOutFileName = strOutFileName + "\Auftrag_" + txtAuftragsnr.Text + ".DOC"
If File.Exists(strOutFileName)
File.Delete(strOutFileName)
Endif
WordApp
Word-Objekt erzeugen
= *New Word.Application()
WordApp.Visible = *true
/// Vorlauf - erzeugen der Positionsmodule Jede Zeile im Grid bearbeiten
DclFld i *integer2
Vorlaufschleife
DclFld p *string
i = 0
ForEach Name(dr) Collection(dgvPositionen.Rows)
Type(DataGridViewRow)
Application.DoEvents()
WordDoc
Word-Dokument auf
Positionsebene öffnen
-
= WordApp.Documents.Open(strInPosName, *noparm, *noparm,
*noparm, *noparm, *noparm, *noparm, *noparm, *noparm,
*noparm, *noparm, *noparm, *noparm, *noparm, *noparm, *noparm
)
ActiveDocument = WordApp.ActiveDocument
Selection
= WordApp.Selection
If File.Exists(strWorkDir + "\VOR_" + i.ToString() + ".rtf")
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark,
*noparm, *noparm, "VORTEXT")
Vor-Zeile-Objekte einbauen
Selection.InsertFile(strWorkDir + "\VOR_" + i.ToString() +
".rtf",*noparm,*noparm,*noparm,*noparm)
Endif
If File.Exists(strWorkDir + "\VOR_" + i.ToString())
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark,
*noparm, *noparm, "VORBILD")
Selection.InlineShapes.AddPicture (strWorkDir + "\VOR_" +
i.ToString() , *false, *true, *noparm)
Zeile in Rahmen bauen Endif
p = %char(i + 1)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "POS")
Selection.TypeText(p.ToString())
Selection.MoveRight(Word.WdUnits.wdCell,1, *noparm)
Selection.TypeText(dr.cells("dgcMenge").value.tostring())
Selection.MoveRight(Word.WdUnits.wdCell,1, *noparm)
Selection.TypeText(dr.cells("dgcArtikelNummer").value.tostring())
Selection.MoveRight(Word.WdUnits.wdCell,1, *noparm)
Selection.TypeText(dr.cells("dgcArtikelBezeichnung").value.tostring())
Selection.MoveRight(Word.WdUnits.wdCell,1, *noparm)
Selection.TypeText(dr.cells("dgcPreis").value.tostring())
Selection.MoveRight(Word.WdUnits.wdCell,1, *noparm)
Selection.TypeText(dr.cells("dgcWert").value.tostring())
If File.Exists(strWorkDir + "\NACH_" + i.ToString() + ".rtf")
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark,
*noparm, *noparm, "NACHTEXT")
Nach-Zeile-Objekte einbauen
Selection.InsertFile(strWorkDir + "\NACH_" + i.ToString() +
".rtf",*noparm,*noparm,*noparm,*noparm)
Endif
If File.Exists(strWorkDir + "\NACH_" + i.ToString())
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark,
*noparm, *noparm, "NACHBILD")
Zeilen-Dokument speichern
Selection.InlineShapes.AddPicture (strWorkDir +
"\NACH_" + i.ToString() , *false, *true, *noparm)
Endif
WordDoc.SaveAs (strWorkDir + "\POS_" + i.ToString() +
".doc",*noparm,*noparm,*noparm,*noparm,*noparm,*noparm,
-115Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
*noparm,*noparm,*noparm,*noparm,*noparm,*noparm,*noparm,*nopa
rm,*noparm )
WordDoc.Close (*noparm,*noparm,*noparm)
i = i + 1
Schleifenende Vorlauf
EndFor
WordDoc = WordApp.Documents.Open(strInFileName, *noparm, *noparm, *noparm,
*noparm, *noparm, *noparm, *noparm, *noparm, *noparm,
*noparm, *noparm, *noparm, *noparm, *noparm, *noparm )
ActiveDocument = WordApp.ActiveDocument
Kopfdaten
ausgeben
Selection
Ergebnis-Dokument erstellen
= WordApp.Selection
/// Header
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "ANREDE")
Selection.Find.ClearFormatting()
Selection.TypeText(cboAnrede.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "NAME1")
Selection.Find.ClearFormatting()
Selection.TypeText(txtName.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "NAME2")
Selection.Find.ClearFormatting()
Selection.TypeText(txtName2.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "STRASSE")
Selection.Find.ClearFormatting()
Selection.TypeText(txtAnschrift.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "LAND")
Selection.Find.ClearFormatting()
Selection.TypeText(txtLand.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "PLZ")
Selection.Find.ClearFormatting()
Selection.TypeText(txtPlz.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "ORT")
Selection.Find.ClearFormatting()
Selection.TypeText(txtOrt.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "BELEGNR")
Selection.Find.ClearFormatting()
Selection.TypeText(txtAuftragsnr.text)
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "BELEGDATUM")
Selection.Find.ClearFormatting()
Selection.TypeText(DateTime.Now.ToShortDateString())
If File.Exists(strWorkDir + "\KOPF.rtf")
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "KOPFTEXT")
Selection.Find.ClearFormatting()
Selection.InsertFile(strWorkDir +
"\KOPF.rtf",*noparm,*noparm,*noparm,*noparm)
Endif
If File.Exists(strWorkDir + "\FUSS.rtf")
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "FUSSTEXT")
Selection.Find.ClearFormatting()
Selection.InsertFile(strWorkDir +
"\FUSS.rtf",*noparm,*noparm,*noparm,*noparm)
Endif
If File.Exists(strWorkDir + "\KOPF")
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "KOPFBILD")
Selection.Find.ClearFormatting()
Selection.InlineShapes.AddPicture (strWorkDir + "\KOPF" ,
*false, *true, *noparm)
Endif
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "POSTAB")
Selection.Find.ClearFormatting()
-116Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
i = 0
ForEach Name(dr) Collection(dgvPositionen.Rows)
Application.DoEvents()
Schleife über
Positionen, alle
Positionsdokumente
einlesen und
ins Ergebnisdokument
integrieren.
Type(DataGridViewRow)
If File.Exists(strWorkDir + "\POS_" + i.ToString() + ".doc")
Selection.InsertFile(strWorkDir + "\POS_" + i.ToString() +
".doc",*noparm,*noparm,*noparm,*noparm)
Selection.MoveDown(Word.WdUnits.wdLine,1, *noparm)
Endif
i = i + 1
EndFor
Selection.GoTo(Word.wdGoToItem.wdGoToBookmark, *noparm, *noparm, "SUMTAB")
Selection.TypeText("Auftragswert gesamt " + lblGesamtWert.Text)
WordDoc.SaveAs (strOutFileName,*noparm,*noparm,*noparm,*noparm,
*noparm,*noparm,*noparm,*noparm,*noparm,*noparm,*noparm,
*noparm,*noparm,*noparm,*noparm )
Ergebnisdokument
ausgeben
EndSr
/endregion
7.11.6. Text in RTF-Box formatieren
In diesem Projekt ist auch eine relativ interessante Steuerung des Textes in einer RTFBox umgesetzt. Darum hier der Code und ein paar erklärende Worte:
Es wird ein Objekt vom Typ RTFClass / PICClass erzeugt und einem Control
zugeordnet.
Diese Klasse enthält das Control selbst und einige Informationen, es hat auch einen
eigenen Construktor zum Erzeugen des Controls das es beinhaltet.
BegClass RTFClass
Access(*Public)
DclFld rtbName
Type(*string)
DclFld rtbControl
Type(RichTextBox)
DclFld rtbText
Type(*string)
DclFld FileName
Type(*string)
Access(*Public)
Access(*Public)
Access(*Public)
Access(*Public)
BegConstructor Access(*Public)
rtbControl = *new RichTextBox()
EndConstructor
EndClass
BegClass PICClass
Access(*Public)
DclFld picName
Type(*string)
DclFld picControl
Type(PictureBox)
DclFld picImage
Type(Image)
DclFld FileName
Type(*string)
BegConstructor Access(*Public)
picControl = *new PictureBox()
EndConstructor
EndClass
-117Dokument D:\75878992.doc
Access(*Public)
Access(*Public)
Access(*Public)
Access(*Public)
RPG.NET BESTPRACTICES
In der FormLoad werden die RTF und PIC – Objekte erzeugt, ein Contextmenü wird
ihnen zugewiesen.
/region Events
BegSr Form1_Load Access(*Private) Event(*this.Load)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
DclFld oRTFKopf
Type(RTFClass) new()
oRTFKopf.rtbControl
= rtbKopf
oRTFKopf.rtbName
= "rtbKopf"
rtbKopf.Tag
= oRTFKopf
SetContextTag(oRTFKopf, ctmRTB)
DclFld oPicKopf
Type(PICClass) new()
oPicKopf.FileName
= ""
oPicKopf.picControl
= pbKopf
oPicKopf.picName
= "pbKopf"
SetContextTag(oPicKopf, ctmPic)
DclFld oRTFVor Type(RTFClass) new()
oRTFVor.rtbControl
= rtbVor
oRTFVor.rtbName
= "rtbVor"
rtbVor.Tag
= oRTFVor
SetContextTag(oRTFVor, ctmRTBVor)
DclFld oPicVor Type(PICClass) new()
oPicVor.FileName
= ""
oPicVor.picControl
= pbVor
oPicVor.picName
= "pbVor"
SetContextTag(oPicVor, ctmPicVor)
DclFld oRTFNach
Type(RTFClass) new()
oRTFNach.rtbControl
= rtbNach
oRTFNach.rtbName
= "rtbNach"
rtbNach.Tag
= oRTFNach
SetContextTag(oRTFNach, ctmRTBNach)
DclFld oPicNach
Type(PICClass) new()
oPicNach.FileName
= ""
oPicNach.picControl
= pbNach
oPicNach.picName
= "pbNach"
SetContextTag(oPicNach, ctmPicNach)
EndSr
Um nicht für jede Funktion im Contextmenü eine eigene Eventsubroutine erzeugen zu
müssen wird ein Handler pro Control erzeugt der das Sendeobjekt an eine zentrale
Handler-Subroutine weitergibt.
BegSr ContextRTF_Click Access(*Private) Event(*this.itmNormal.Click, *this.itmFett.Click,
*this.itmUnterstreichen.Click, *this.itmSchriftart.Click,
*this.itmTextauswahl.Click, *this.itmTextspeichern.Click,
*this.itmTextEinfuegen.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
BearbeiteRTF(Sender)
EndSr
BegSr ContextRTFVOR_Click Access(*Private) Event(*this.itmVNormal.Click,
*this.itmVFett.Click, *this.itmvUnterstreichen.Click,
*this.itmVSchriftart.Click, *this.itmVTextAuswaehlen.Click,
*this.itmVTextSpeichern.Click, *this.itmVTextEinfuegen.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
BearbeiteRTF(Sender)
EndSr
-118Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
BegSr ContextRTFNACH_Click Access(*Private) Event(*this.itmNNormal.Click,
*this.itmNFett.Click, *this.itmNUnterstreichen.Click,
*this.itmNSchriftart.Click, *this.itmNTextAuswaehlen.Click,
*this.itmNTextSpeichern.Click, *this.itmNTextEinfuegen.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
BearbeiteRTF(Sender)
EndSr
Die zentrale Handler-Subroutine holt sich aus dem übergebenen Objekt das im Tag
versteckte RTF-Objekt raus und bearbeitet die Auswahl des Context-Menü’s.
BegSr BearbeiteRTF Access(*Private)
DclSrParm sender Type(*Object)
DclFld
DclFld
DclFld
DclFld
DclFld
ctm
ctm
rtbTag
rtb
fnt
nam
Type(ToolStripMenuItem)
Type(RTFClass)
new()
Type(RichTextBox)
new()
Type(Font)
Type(*string)
= sender *as ToolStripMenuItem
If ctm.Tag = *nothing
ctm.Tag = *new RTFClass()
Endif
RTF-Klasse aus TAG holen
rtbTag = ctm.Tag *as RTFClass
rtb
= rtbTag.rtbControl *as RichTextBox
nam
= rtbTag.FileName
fnt
= rtb.SelectionFont
Select
Auswahl des
ContextMenü’s
abarbeiten
When ctm.Text = itmNormal.Text
rtb.SelectionFont = *new Font(fnt.FontFamily, fnt.Size,
FontStyle.Regular)
When ctm.Text = itmFett.Text
rtb.SelectionFont = *new Font(fnt.FontFamily, fnt.Size,
FontStyle.Bold)
When ctm.Text = itmUnterstreichen.Text
rtb.SelectionFont = *new Font(fnt.FontFamily, fnt.Size,
FontStyle.Underline)
When ctm.Text = itmSchriftart.Text
dlgFont.ShowColor = *true
dlgFont.Font
= rtb.SelectionFont
dlgFont.Color = rtb.SelectionColor
If dlgFont.ShowDialog() <> DialogResult.Cancel
rtb.SelectionFont
= dlgFont.Font
rtb.SelectionColor
= dlgFont.Color
EndIf
When ctm.Text = itmTextauswahl.Text *OR ctm.Text = itmTexteinfuegen.Text
ofd.FileName
= nam
ofd.DefaultExt
= ".rtf"
ofd.InitialDirectory = asrApp.GetValue("TextPfad",
Type.GetType("System.String")) *as String
ofd.Filter
= "rtf files (*.rtf)|"
ofd.FilterIndex
= 1
If ofd.ShowDialog() <> DialogResult.Cancel
if ctm.Text = itmTextauswahl.Text
rtb.LoadFile(ofd.FileName,
RichTextBoxStreamType.RichText)
Else
DclFld rtbInsert Type(RichTextBox)
new()
rtbInsert.LoadFile(ofd.FileName,
RichTextBoxStreamType.RichText)
rtb.SelectedText = rtbInsert.Text
Endif
rtbTag.FileName
= ofd.FileName
EndIf
When ctm.Text = itmTextspeichern.Text
sfd.FileName
= nam
sfd.InitialDirectory = asrApp.GetValue("TextPfad",
Type.GetType("System.String")) *as String
sfd.Filter
= "rtf files (*.rtf)|"
-119Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
sfd.FilterIndex
= 1
sfd.OverwritePrompt
= *true
If sfd.ShowDialog() <> DialogResult.Cancel
rtb.SaveFile(sfd.FileName, RichTextBoxStreamType.RichText)
rtbTag.FileName
= sfd.FileName
EndIf
EndSl
Select
When rtbTag.rtbName = "rtbKopf"
rtbKopf
= rtb
rtbKopf.Tag
= rtbTag
When rtbTag.rtbName = "rtbVor"
rtbVor
= rtb
rtbVor.Tag
= rtbTag
When rtbTag.rtbName = "rtbNach"
rtbNach
= rtb
rtbNach.Tag
= rtbTag
EndSl
EndSr
Die zentrale Handler-Subroutine für die Bild-Bearbeitung ist durch die geringere Anzahl
an Funktionen ein bisschen übersichtlicher als die RTF-Routine, sie folgt aber
demselben Prinzip.
BegSr itmBildsuchen_Click Access(*Private) Event(*this.itmBildsuchen.Click,
*this.itmBildsuchenNach.Click, *this.itmBildsuchenVor.Click,
*this.itmBildloeschen.Click, *this.itmBildloeschenVOR.Click,
*this.itmBildloeschenNACH.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
DclFld
DclFld
DclFld
DclFld
ctm
Type(ToolStripMenuItem)
picTag Type(PICClass)
new()
pic
Type(PictureBox)
new()
nam
Type(*string)
ctm
= sender *as ToolStripMenuItem
picTag = ctm.Tag *as PICClass
pic
= picTag.picControl *as PictureBox
nam
= picTag.FileName
Select
When ctm.Text = itmBildsuchen.Text
ofd.FileName
= ""
ofd.DefaultExt
= ".jpg"
ofd.InitialDirectory = asrApp.GetValue("BildPfad",
Type.GetType("System.String")) *as String
ofd.Filter
= "jpg files (*.jpg)|*.jpg|All files
(*.*)|*.*"
ofd.FilterIndex
= 1
If ofd.ShowDialog() <> DialogResult.Cancel
LOADPICTURE
File(ofd.FileName)
Target(pic.Image)
picTag.FileName
= ofd.FileName
EndIf
When ctm.Text = itmBildloeschen.Text *or
ctm.Text = itmBildloeschenVOR.Text *or
ctm.Text = itmBildloeschenNACH.Text
pic.Image = *nothing
picTag.FileName = ""
EndSl
Select
When picTag.picName = "pbKopf"
pbKopf
= pic
pbKopf.Tag
= picTag
if ctm.Text = itmBildloeschen.Text
pbKopf.Image = *nothing
Endif
When picTag.picName = "pbVor"
pbVor
= pic
pbVor.Tag
= picTag
-120Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
if ctm.Text = itmBildloeschenVOR.Text
pbVOR.Image = *nothing
Endif
When picTag.picName = "pbNach"
pbNach
= pic
pbNach.Tag
= picTag
if ctm.Text = itmBildloeschenNACH.Text
pbNACH.Image = *nothing
Endif
EndSl
EndSr
-121Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
8. Webseiten
Die hier angeführten Informationen helfen Ihnen beim Einstieg in die Webentwicklung mit
VS 2005, können aber keinesfalls Schulungen ersetzen. Das Thema Web-Entwicklung
ist sehr umfangreich, es verlangt mehr Designer-Qualität als Windows-Projekte und ist
deshalb hier nur im Ansatz beschrieben.
Weitere Informationen finden Sie im Handbuch ‚AVRWeb’ das sie von der ActionPackCD oder im Internet downloaden können.
8.1. Anlegen eines Projekts
Ein neues Web-Projekt wird nicht als Projekt sondern als Website gesehen.
Hier wird der Projekttyp Website oder WebService ausgewählt. Ebenso der Ort an dem
das Projekt angelegt wird.
-122Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
8.2. Anlegen einer Masterpage
Wie in Powerpoint oder
Word kann man eine
Seitenvorlage erstellen in
die Webseiten eingebettet
werden.
Die Mastersite kann einen Titel und die Navigation enthalten. Sie enthält in jedem Fall
einen Platzhalter für die Webseiten die angezeigt werden sollen.
-123Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Die Navigation basiert in den meisten Fällen auf einem Menü oder einer TreeView. Um
den ‚Breadrcrumb’ angezeigt zu bekommen (die Position in der man sich innerhalb der
Seite befindet) braucht man die XML-Datei Web.Sitemap.
8.3. Anlegen von Webseiten
Mit ‚Inhaltsseiten hinzufügen’ werden
Masterpage Inhaltsseiten angefügt.
zur
Diese Seiten füllen dann den Inhalt des Content
der MasterPage und werden auch im Editor
entsprechend angezeigt.
-124Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
8.4. Startseite festlegen
Die Startseite wird in
den Eigenschaftsseiten
des Projekts oder im
Contextmenü der Seite
festgelegt.
Das Projekt braucht
eine Startseite, ist keine
Startseite definiert wird
das
Verzeichnis
angezeigt und per Klick
auf eine Seite die Seite
ausgewählt.
8.5. Seitengröße festlegen
Jede Seite sollte eine
durchgängige Seitengröße
haben die einer üblichen
Bildschirmauflösung
entspricht aber nicht größer
als 1024x798 sein sollte da
sie sonst nicht auf jedem
Bildschirm
angezeigt
werden kann.
-125Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
8.6. Seiten zeichnen
In der Toolbox finden
sich jede Menge an
Controls, sie sind im
Designer gleich wie
Windows-Controls am
Formular
zu
behandeln.
8.7. Projektorganisation
Eine wesentliche Neuerung von VS2005 ist die
Organisation der Website in Verzeichnissen.
Die Solution ist in einem anderen Verzeichnis abgelegt
als die Seiten selbst.
-126Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
8.8. Programmierung
Generell sollte die Businesslogik in Namespaces/DLL’s ausgelagert werden.
Nur dadurch ist eine effiziente Programmierung möglich.
Für einfache Seiten genügen dann ein paar Zeilen wie z.B. hier:
Using
Using
Using
Using
Using
Using
Using
Using
Using
Using
System
System.Data
System.Configuration
System.Collections
System.Web
System.Web.Security
System.Web.UI
System.Web.UI.WebControls
System.Web.UI.WebControls.WebParts
System.Web.UI.HtmlControls
Deklaration des
Namespaces
Using NiceWare.Workshop.BaseClass
BegClass _Default Partial(*Yes) Access(*Public) Extends(System.Web.UI.Page)
Dcldb
DclFld
DclFld
DclFld
DclFld
DclFld
dbRuntime
cAdressen
cAdressDetail
ErrorMessage
strTyp
dNummer
DBName("*Public/WORKSHOP")
Type(Adressen)
Type(Adressen.clsAdressDetail)
*string
*string
System.Decimal
BegSr Page_Load Access(*Private) Event(*This.Load)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
If ( Request( "Typ" ) = *Nothing )
strTyp = "K"
Else
strTyp = Request( "Typ" )
EndIf
If ( Request( "Key" ) = *Nothing )
lblDatenArt.Text = "keine Adressnummer angegeben"
Else
dNummer = Request( "Key" ) *as System.Decimal
-127Dokument D:\75878992.doc
Deklaration der
Klassen
RPG.NET BESTPRACTICES
EndIf
Try
Connect dbRuntime
cAdressen = *new Adressen( dbRuntime, strTyp )
Catch ex Exception
ErrorMEssage = ex.Message
EndTry
//
// Called the first time that the page is loaded.
//
If (NOT Page.IsPostBack)
/// Daten neu einlesen
cAdressDetail = cAdressen.LeseAdresse(dNummer,*false)
If strTyp = "K"
lblDatenArt.Text = "Kunde"
Else
lblDatenart.Text = "Lieferant"
Endif
txtNUM.Text
= cAdressDetail.Nummer
txtANR.Text
= cAdressDetail.Anrede.trim()
txtVNA.Text
= cAdressDetail.Vorname.trim()
txtNNA.Text
= cAdressDetail.Nachname.trim()
txtSTR.Text
= cAdressDetail.Strasse.trim()
txtLND.Text
= cAdressDetail.Land.trim()
txtPLZ.Text
= cAdressDetail.PLZ.trim()
txtORT.Text
= cAdressDetail.Ort.trim()
Aufbauen der
Datenverbindung und
Instanzierung der klassen
Einlesen der Daten in die
Klasse bei erstem Laden
des Formulars
Session["AdressDetail"] = cAdressDetail
Else
//
// Called subsequent times that the page is displayed.
//
cAdressDetail = Session["AdressDetail"] *as Adressen.clsAdressDetail
EndIf
EndSr
BegSr btnSpeichern_Click Access(*Private) Event(*This.btnSpeichern.Click)
DclSrParm sender Type(*Object)
DclSrParm e Type(System.EventArgs)
/// Daten der Klasse updaten
cAdressDetail.Nummer = txtNUM.Text
cAdressDetail.Anrede = txtANR.Text
cAdressDetail.Vorname = txtVNA.Text
cAdressDetail.Nachname = txtNNA.Text
cAdressDetail.Strasse = txtSTR.Text
cAdressDetail.Land
= txtLND.Text
cAdressDetail.PLZ
= txtPLZ.Text
cAdressDetail.Ort
= txtORT.Text
/// Daten aktualisieren
cAdressen.AktualisiereAdresse(cAdressDetail)
/// Liste aufrufen
Response.Redirect("~/Kunden.aspx?Typ="+strTyp)
EndSr
EndClass
-128Dokument D:\75878992.doc
Bei Speichern die Daten
zurückgeben und zurück
zur Listansicht.
RPG.NET BESTPRACTICES
8.9. Gestaltung
Die ASPX-Seite kann mit den Werkzeugen von VS gestaltet werden. Hinter der
Oberfläche verbirgt sich HTML-Code der auch direkt bearbeitet werden kann und in
manchen Fällen auch direkt bearbeitet werden muss.
Die Oberflächengestaltung wird über ein sog. CSS (Cascading Style Sheet) gelöst.
Indem das Aussehen der CSS-Klassen festgelegt wird.
Dem Label
‘Benutzer’ wird hier
die CSS-Klasse
‘Medium’
zugewiesen.
-129Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
8.10.Global.ASAX
Diese Datei enthält Event-Subroutinen die sich auf den Webserver bzw. die Anwendung
beziehen und z.B. ausgeführt werden wenn der Webserver oder die Anwendung zum
ersten Mal gestartet werden.
In diesem Beispiel ist der einzige benutzte Event Application-Start. Hier wird der DBName eingelesen.
BegSr Application_Start Access(*Protected)
DclSrParm Sender Type(*Object)
DclSrParm e Type(System.EventArgs)
// Code that runs on application startup
// DB-Name als Servervariable anlegen
Application[ "DBRuntime" ] = System.Configuration.ConfigurationSettings.AppSettings("DBRuntime")
EndSr
9. WebServices erstellen
Sind eine ideale Schnittstelle für die Unterstützung von B2B-Projekten.
Sie sind mit RPG.NET einfach zu erstellen und ebenso einfach zu nutzen.
In unserem Beispiel werden die Klassen und Methoden eines Namespaces als Dienst
zur Verfügung gestellt.
Hier ist die Testansicht des Service – er wird auf dem Rechner auf dem er installiert ist
bereitgestellt.
-130Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Da ein Webservice keine Oberfläche braucht ist er sehr schnell zu entwickeln.
Ich empfehle auch hier soviel Logik wie möglich in Form von DLL zu kapseln.
9.1. Programmierung
Using
Using
Using
Using
System
System.Web
System.Web.Services
System.Web.Services.Protocols
Referenz auf Namespace
Using Niceware.Workshop.BaseClass
BegClass WWSDienste Access(*Public) Extends(System.Web.Services.WebService) +
Attributes(WebService(Namespace:="http://localhost/WWSservice/", +
-131Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Description:="Ein Beispiel für Webservices erstellt mit ASNA VisualRPG.NET"), +
WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1))
Attribute des Service
festlegen.
/region Adressen
/// Methode zur Rückgabe der Adressliste als Dataset
BegFunc AdressListe
Type(System.Data.DataSet)
Access(*Public) Attributes(WebMethod())
DclSrParm
Art
Type(*OneChar) /// AdressArt (K/L/F)
DclSrParm
Key
Type(*string) /// Name oder Nummer zum aufsetzen
/// Methoden
DclFld cAdressen
DclFld cAdressliste
DclFld ds
Type(Adressen)
Type(Adressen.clsAdressListe)
Type(System.Data.DataSet)
new()
cAdressen = *new Adressen( dbRuntime, Art.ToString() )
cAdressliste = cAdressen.Adressliste(Key)
ds.Tables.Add( cAdressliste.dtAdressen.Copy() )
LeaveSr ds
EndFunc
Klassen deklarieren und
instanzieren.
Methode aufrufen und
Rückgabewerte als
Ergebnis liefern
9.2. Bilder in XML-übertragen
Bilddaten müssen um mit einem Webservice übertragen werden zu können in einen
String konvertiert werden. Dazu wird üblicherweise die Konvertierungsfunktion
CONVERT.TOBASE64STRING verwendet. Hier ist ein Anwendungsbeispiel:
BegFunc
BildToBase64
DclSrParm
Bild
DclFld
DclFld
Type(*string)
Type( System.Drawing.Image )
cMemory
cBase64
Type( MemoryStream )
Type( *string )
cMemory = *new MemoryStream()
Bild.Save(cMemory, ImageFormat.Bmp)
cBase64 = Convert.ToBase64String(cMemory.ToArray())
LeaveSr cBase64
EndFunc
Hier das Rückkonvertieren des Bildes aus dem Stream
ms = *new MemoryStream( Convert.FromBase64String( cArtikelInfo.BildBase64 ) )
pbBild.Image
= *new Bitmap( ms )
-132Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
10. WebServices nutzen
Webservices sind in DotNet ideal einzubinden,
das Beispiel zeigt die Verwendung eines
Webservices aus einem Windows-Projekt heraus.
Der Webservice wird über die Webreferenz eingebunden und steht mit seinen Klassen
und Methoden zur Verfügung.
-133Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Hier ist die Sicht auf den Code, das Projekt ist in VB programmiert.
Public Class Form1
Dim WS As New localhost.WWSDienste()
Dim dt As DataSet
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles btnKunden.Click
dt = WS.AdressListe("K", "0")
dgv.DataSource = dt.Tables(0)
End Sub
Private Sub btnLieferanten_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles btnLieferanten.Click
dt = WS.AdressListe("L", "0")
dgv.DataSource = dt.Tables(0)
End Sub
Private Sub btnArtikel_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles btnArtikel.Click
dt = WS.ArtikelListe(0)
dgv.DataSource = dt.Tables(0)
End Sub
Private Sub btnBelege_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles btnBelege.Click
dt = WS.BelegListe(False, "")
dgv.DataSource = dt.Tables(0)
End Sub
End Class
Beim Nutzen eines Webservice fallen alle Deklarationen mit Ausnahme der auf den
Webservice und die Klassen die man verwendet weg, deswegen ist dieser
Programmcode alles andere als aufregend.
-134Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
11. ASNA-Datagate Bibliotheksfunktionen
Im Namespace ASNA.DataGate.Client ist eine Vielzahl an Funktionen enthalten die
sehr effizient einsetzbar sind.
Ich habe aus meinen Projekten ein paar Routinen herausgegriffen die öfters gebraucht
werden.
11.1. DG-Datenbanken auslesen
Using
using
using
using
using
System
ASNA.DataGate.Client
ASNA.DataGate.Common
ASNA.DataGate.DataLink
ASNA.DataGate.Providers
…
/// Namen der DB2-Datenverbindungen aus Registry einlesen
/// und als ArrayList für die ComboBox zurückgeben
BegFunc
GetDB2List Type(System.Collections.ArrayList)
Access(*Public)
/// deklarieren und instanzieren
DclFld DBList
Type(System.Collections.ArrayList) new(*dft)
/// DBNamen als StringArray einlesen
DclArray
DbNames Type(*String) Rank(1)
/// Public databases
DbNames = dbLocal.GetNames(*True)
ForEach DatabaseName DbNames *String
If IsDB2(DatabaseName)
DBList.Add("*Public/" + DatabaseName)
Endif
EndFor
/// Local database
DbNames = dbLocal.GetNames(*False)
ForEach DatabaseName DbNames *String
If IsDB2(DatabaseName)
DBList.Add(DatabaseName)
Endif
EndFor
/// zurückgeben
LeaveSr
DBList
EndFunc
/// Label auf DB2 prüfen
BegFunc
IsDB2 Type(*Boolean)
DclSrParm
strDBName
*string
/// DB-einlesen, prüfen und retour
dbLocal.DBName = strDBName
IF dbLocal.Label = "DB2"
LeaveSr *true
Else
LeaveSr *false
Endif
EndFunc
-135Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
11.2.iSeries-Bibliotheksliste auslesen
Using
using
using
using
using
System
ASNA.DataGate.Client
ASNA.DataGate.Common
ASNA.DataGate.DataLink
ASNA.DataGate.Providers
…
/// Bibliotheken aus Datenverbindungen einlesen
BegFunc
GetLibList Type(System.Collections.ArrayList)
Access(*Public)
DclSrParm
dbLocal
Type(AdgConnection)
By(*reference)
/// deklarieren und instanzieren
DclFld
LibList
Type(System.Collections.ArrayList)
new(*dft)
DclFld dir Type(IDirectory)
Try
dir = AdgFactory.NewDirectory(dbLocal, "/")
Catch Type(dgException)
LibList.Add("<*Nothing>")
LeaveSr LibList
EndTry
ForEach lib Type(IAdgObject) Collection(dir.ItemList)
LibList.Add(lib.ToString().Remove(0, 1))
EndFor
/// zurückgeben
LeaveSr
LibList
EndFunc
-136Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
11.3.Objektliste der iSeries-Bibliotheken auslesen
Using
using
using
using
using
System
ASNA.DataGate.Client
ASNA.DataGate.Common
ASNA.DataGate.DataLink
ASNA.DataGate.Providers
…
/// Objekte aus Bibliothek einlesen
BegFunc
GetObjects Type(*boolean)
Access(*Public)
DclSrParm
dbLocal
Type(ADGConnection)
By(*reference)
DclSrParm
strLib
Type(*string)
/// deklarieren und instanzieren
lPFList.Clear()
DclFld dir Type(IDirectory)
Try
dir = AdgFactory.NewDirectory(dbLocal, strLib)
Catch Type(dgException)
LeaveSr *false
EndTry
ForEach lib Type(IAdgObject) Collection(dir.ItemList)
lPFList.Add(lib.ToString().Remove(0, 1 + strLib.Length))
EndFor
If strErrorMessage = *blank
LeaveSr
*true
Else
LeaveSr
*false
Endif
EndFunc
-137Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
11.4.Dateifeldbeschreibung auslesen
Using
using
using
using
using
System
ASNA.DataGate.Client
ASNA.DataGate.Common
ASNA.DataGate.DataLink
ASNA.DataGate.Providers
…
/// Daten für Klassengenerierung erstellen
BegFunc
PrepareGenerationData
Type(clsDB.clsGenerationData)
Access(*Public)
DclSrParm
dbLocal
Type(ADGConnection)
By(*reference)
DclSrParm
strLib
Type(*string)
DclSrParm
strFile
Type(*string)
/// verwenden der ADG - Objekte
DclFld
dbFA Type(FileAdapter)
DclFld
dsFA Type(ADGDataSet)
DclFld
ktFA Type(ADGKeyTable)
dbFA = *new FileAdapter(dbLocal)
dbFA.FileName = strLib + "/" + strFile
dbFA.MemberName = "*FIRST"
dbFA.OpenNewAdgDataSet(*ByRef dsFA)
/// DatenFelder einlesen
DclFld
dtFA
Type(System.Data.DataTable)
DclFld
iMaxLength Type(*integer2)
dtFA = dsFA.Tables(0)
i = 0
ForEach dc Type(System.Data.DataColumn) Collection(dtFA.Columns)
/// hier stehen die Felder in Form der DataColumn zur Verfügung
EndFor
-138Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
/// die Felder der KeyTable einlesen
ktFA = dsFA.NewKeyTable(0)
ForEach dc Type(System.Data.DataColumn) Collection(ktFA.DataTable.Columns)
EndFor
-139Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
12. Windows-Dienste programmieren
12.1.Was ist ein Windows-Dienst ?
Ein Windows-Dienst ist ein Programm das im Hintergrundprogramm abläuft und das
ohne Programmoberfläche auskommt. Also nichts weiter als ein Batch-Programm.
Ein Dienst wird gerne für Arbeiten eingesetzt die keine besondere Kontrolle brauchen
und sicher und stabil ablaufen sollen.
Ich habe im Rahmen einer Kundenanforderung ein Dienstprojekt umgesetzt das ähnlich
wie ein Trigger eine Datei überwachen soll indem Anforderungen für ein MD5-Encryption
abgesetzt werden.
Das Programm setzt über einen LF der verarbeitete Sätze ausschließt auf einer Datei
auf und gibt für jeden Input-Text einen En-Crypteten String aus.
Bei einem Service sind ein paar Unterschiede zu Windows-Dialogprogrammen zu
beachten.
Das Projekt braucht eine Referenz auf System.ServiceProcess
Sowie auf System.Configuration.Install
Diese Namespaces sind üblicherweise nicht referenziert.
Es benötigt auch einen ProcessInstaller der für das Handling
der Installation und Deinstallation gebraucht wird.
Die Verarbeitungslogik muss verschiedene Events bedienen.
Damit man verfolgen kann was der Service macht schreibt er ein eigenes Eventlog mit.
-140Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
12.2.PROGRAM.VR - Basis des Dienstes
In der Klasse PROGRAM finden wir die Eigenschaften und die MAIN-Methode die den
Einsprungpunkt darstellt.
Using System
Using System.Text
Using System.ServiceProcess
DclNamespace EnCryption
BegClass Program Access(*Public)
BegProp WindowsServiceName Type( *String ) Access( *Public ) Shared( *Yes )
BegGet
LeaveSr "EnCryption"
// Name your Windows service with the literal value above.
// Both the AVRWindowsService and the ProcessInstaller classes
// use this name. This name needs to be unique across _all_
// Windows services. Choose it carefully (perhaps prefixing
// it with your company name).
EndGet
EndProp
BegProp WindowsServiceDescription Type( *String ) Access( *Public ) Shared( *Yes )
BegGet
LeaveSr "MD5 - Encryption"
// Provide your Windows service description here. This is what shows
// as the service description in the Service Control Manager.
EndGet
EndProp
BegProp EventSource Type( *String ) Access( *Public ) Shared( *Yes )
BegGet
LeaveSr "EnCryptionLog"
// Name your event log source here.
EndGet
EndProp
BegProp EventLog Type( *String ) Access( *Public ) Shared( *Yes )
BegGet
LeaveSr "EnCryptionLog"
// Name your event log here. While you could write to existing logs,
// it's probably a little nicer to write to your own log--and this program
// provides the simple code required to do that.
// Do note that if you create multiple Windows services, you might want to keep
// the EventLog property the same for all of them.
EndGet
EndProp
BegSr Main Shared( *Yes ) Access( *Public )
// Specify the entry point for the service.
ServiceBase.Run( *New EnCryption() )
EndSr
EndClass
-141Dokument D:\75878992.doc
Die Klasse Encryption wird
instanziert und ausgeführt
RPG.NET BESTPRACTICES
12.3.ProcessInstaller.VR – Constructor
Im ProcessInstaller wird der Constructor des Service hinterlegt.
Using
Using
Using
Using
Using
Using
Using
Using
System
System.Collections
System.ComponentModel
System.Data
System.Diagnostics
System.ServiceProcess
System.Text
System.Configuration.Install
BegClass ProcessInstaller Extends(Installer) Access( *Public ) Attributes( RunInstaller( *True ) )
DclFld ServiceProcessInstaller1 Type( System.ServiceProcess.ServiceProcessInstaller )
DclFld ServiceInstaller1
Type( System.ServiceProcess.ServiceInstaller )
BegConstructor Access(*Public)
*This.ServiceProcessInstaller1 = *New System.ServiceProcess.ServiceProcessInstaller()
*This.ServiceInstaller1
= *New System.ServiceProcess.ServiceInstaller()
//
// ServiceProcessInstaller1.
// Read about the ServiceProcessInstaller class here:
// http://msdn2.microsoft.com/
en-gb/library/system.serviceprocess.serviceprocessinstaller.aspx
*This.ServiceProcessInstaller1.Account = System.ServiceProcess.ServiceAccount.LocalSystem
*This.ServiceProcessInstaller1.Password = *Nothing
*This.ServiceProcessInstaller1.Username = *Nothing
//
// ServiceInstaller1.
// Read about the ServiceInstaller class here:
// http://msdn.microsoft.com/library/default.asp?url=/library/
en-us/cpref/html/frlrfSystemServiceProcessServiceInstallerClassTopic.asp
// Name the service.
*This.ServiceInstaller1.ServiceName = Program.WindowsServiceName
*This.ServiceInstaller1.Description = Program.WindowsServiceDescription
// The value of this property must be identical to the name recorded
// for the service in the extended ServiceBase class.
// You could also specify Disabled and Manual start mode here.
*This.ServiceInstaller1.StartType = System.ServiceProcess.ServiceStartMode.Automatic
*This.Installers.Add( *This.ServiceProcessInstaller1 )
*This.Installers.Add( *This.ServiceInstaller1 )
EndConstructor
EndClass
-142Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
12.4.EnCryption.VR – Hier wird gearbeitet
Hier spielt sich die Verarbeitung ab, ein Timer steuert den Ablauf des Programms.
Using
Using
Using
Using
Using
Using
Using
System
System.Collections
System.ComponentModel
System.Data
System.Diagnostics
System.ServiceProcess
System.Tex
BegClass EnCryption Extends(ServiceBase) Access( *Public )
DclFld
DclFld
DclFld
EventLog1
cMD5Encrypt
tmr
Type( System.Diagnostics.EventLog ) New()
Type( MD5Encrypt )
Type( System.Timers.Timer )
BegConstructor Access(*Public)
*This.ServiceName = Program.WindowsServiceName
If ( NOT System.Diagnostics.EventLog.SourceExists( Program.EventSource ) )
System.Diagnostics.EventLog.CreateEventSource( Program.EventSource, Program.EventLog )
EndIf
EventLog1.Source
= Program.EventLog
Timer instanzieren und
Handler-SR anhängen
tmr = *new System.Timers.Timer()
tmr.Interval
= 2000
tmr.Start()
AddHandler
SourceObject( tmr ) SourceEvent( Elapsed )
HandlerObject( *this ) HandlerSr( TimerElapsed )
EndConstructor
BegSr OnStart Access(*Protected) Modifier(*Overrides)
DclSrParm args Type(*String) Rank(1)
Beim Start des Dienstes
die MD5-Klasse erstellen
Try
cMD5Encrypt = *new MD5Encrypt()
EventLog1.WriteEntry( "MD5EnCrypt started" )
Catch Ex Exception
EventLog1.WriteEntry( "Error on instancing MD5EnCrypt –
Check DB-Connection and Files
LEaveSr
EndTry
" )
EndSr
BegSr OnStop Access(*Protected) Modifier(*Overrides)
EventLog1.WriteEntry( "EnCryption service stopped." )
tmr.Stop()
EndSr
Beim Stop Timer beenden
BegFunc OnPowerEvent Access(*Protected) Modifier(*Overrides) Type( *Boolean )
DclSrParm PowerStatus Type( PowerBroadcastStatus )
DclFld Result Type( *Boolean )
Result = *True
LeaveSr Result
EndFunc
BegSr OnContinue
Access(*Protected) Modifier(*Overrides)
tmr.Start()
EndSr
BegSr
TimerElapsed
DclSrPArm
sender
DclSrParm
e
Beim Restart Timer neu
Starten
Type(System.Object)
Type(System.Timers.ElapsedEventArgs)
EventLog1.WriteEntry( "EnCryption service on Loop" )
cMD5Encrypt.LeseSchleife( *byRef EventLog1 )
Handler-Subroutine für
Encryption
endSr
EndClass
-143Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
12.5.MD5EnCryption.VR – Crypt nach MD5
Using
Using
Using
Using
Using
System
System.IO
System.Text
System.Data
System.Security.Cryptography
DB-Verbindung und Datei
implizit eröffnen lassen
BegClass MD5Encrypt Access(*Public)
DclDB
dbCompile
DclDiskFile
Name(MD5File)
DB(dbCompile)
/// Leseschleife
BegSr LeseSchleife
DclSrParm
DBName("*Public/DG NET LOCAL")
File("OPITEC/MD5IN") Type(*Update)
Access(*Public)
log
Type( System.Diagnostics.EventLog )
Org(*Indexed)
By(*reference)
DclFld LoopCounter
*integer2
log.WriteEntry( "EnCryption service Leseschleife" )
try
SETLL MD5File
READ
MD5File
DOWHILE NOT %eof
Key("")
Auf erstem Satz aufsetzen
und Datei durcharbeiten
LoopCounter += 1
MD5OUT = Encrypt( %trim(MD5IN) )
MD5Time = System.DateTime.Now.ToString() + LoopCounter.tostring()
log.WriteEntry( "EnCryption IN:" + MD5IN.Tostring() + " OUT:" +
MD5OUT.Tostring() )
Encrpytion aufrufen und
Daten ausgeben
UPDATE MD5File
READ MD5File
ENDDO
Catch Ex Exception
log.WriteEntry( "Error on EnCryption service" )
EndTry
LeaveSr
EndSr
/// Methode Encryption
BegFunc Encrypt Type(*string)
DclSrParm
Input
Type(*string)
/// Encrypted String
Dclfld strEncrypted
Type(*string)
/// MD5-Objekt erzeugen
DclFld md5Hasher
md5Hasher = MD5.Create()
Type(MD5)
/// ZeichenArray
DclArray
data
Type(*byte)
Rank(1)
data = md5Hasher.ComputeHash(Encoding.Default.GetBytes(Input))
/// Stringbuilder
DclFld sBuilder
Type(StringBuilder)
sBuilder = *new StringBuilder()
/// Schleife um Ergebnis zusammenzubauen
Do
Fromval(0)
Toval(data.length - 1) Index(i)
sBuilder.Append(data(i).ToString("x2"))
ENDDO
/// Encrypted String zurückgeben
LeaveSr sBuilder.tostring()
EndFunc
EndClass
-144Dokument D:\75878992.doc
Type(*integer2)
RPG.NET BESTPRACTICES
12.6.Den Windows-Dienst installieren / deinstallieren
Ein
Windows-Dienst
wird mit dem Programm
INSTALLUTIL
<Programmname>
installiert.
Nach der Installation kann
der
Dienst
gestartet
werden:
-145Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Unser Dienst erstellt sofort ein Eventlog bzw. protokolliert mit:
Die De-Installation erfolgt mit INSTALLUTIL /u <Programmname>
-146Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
13. Hintergrundverarbeitung
Es gibt Situationen in denen eine Verarbeitung im Hintergrund sinnvoll ist. .NET stellt
dafür einen Background-Worker zur Verfügung.
In meinem Beispiel wurde eine Teilstringsuche über einen Hintergrundjob gelöst der die
gefunden Datensätze in einen Arbeitsfile ausgibt welcher direkt vom Programm
eingelesen wird. Der Vorteil ist dass sich die Ergebnisse sofort zeigen und nicht erst
nach dem vollständigen Ende der Suche.
Diese Anforderung wurde bewusst nicht mit SQL sondern mit Zugriff auf Satzebene
gelöst. Üblicherweise ist das eine Situation in der %like% verwendet wird, diese
Möglichkeit wurde in dem Beispiel ausgeklammert.
Im Client-Programm wird sofort nach Start der Suche die Einleseroutine gestartet die
dafür sorgt daß die gefundenen Daten sofort im Grid angezeigt werden.
So ist es möglich daß bereits wenige Augenblicke nach dem Auffinden der ersten
Datensätze gearbeitet werden kann.
Datenlesen
Gibt gefunden Daten
in Grid aus
DataGate – Direktzugriff auf Satzebene
Backgroundworker Datensuche
bgwCALL
-147Dokument D:\75878992.doc
Gibt gefunden Daten
in Member aus
RPG.NET BESTPRACTICES
13.1.Start des BackGroundWorker-Jobs
Das Objekt bgwCall vom Typ System.ComponentModel.BackgroundWorker wird aus
der Toolbox – Bereich Komponenten - auf das Formular gezogen.
/// Suchen wurde gedrückt
BegSr btnSuchen_Click Access(*Private) Event(*this.btnSuchen.Click)
DclSrParm sender *Object
DclSrParm e System.EventArgs
MsgLine.Text
= "Daten werden gesucht - bitte um Geduld"
/// DoEbents für Meldungszeile
DoEvents
/// Abbruch anzeigen und Schalter mit False initialisieren
/// Suchbutton verstecken
btnAbbruch.visible
= *true
btnSuchen.Visible
= *false
Abbruch
= *false
/// Zeit für Membernamen erstellen und Member aufbauen lassen
MemberName = DateTime.Now.ToString("mmss")
if not cPartner.CreateMember( *byRef MemberName )
cLog.NeuerLogEintrag( cPartner.Fehler )
Endif
Der Event
/// Backgroundjob zum erstellen der Daten starten
bgwCALL.RunWorkerAsync()
RunWorkerAsync
wird am BackGroundworkerObjekt gestartet
/// Daten des Backgrondjobs einlesen
if not cPartner.PartnerListe( *byref dtPAR, *byref Abbruch, MemberName )
cLog.NeuerLogEintrag( cPartner.Fehler )
Endif
/// Ergenbismeldung ausgeben
If Abbruch
msgLine.Text
= dtPAR.Rows.Count + " Datensätze gefunden –
Suche wurde abgebrochen"
Else
msgLine.Text
= dtPAR.Rows.Count + " Datensätze gefunden - Suche beendet"
Endif
/// Ergebnismeldung in Log ausgeben
cLog.NeuerLogEintrag( msgLine.Text )
/// Member auf AS/400 über Backgroundjob löschen
bgwDELMbr.RunWorkerAsync()
Auch das Löschen des
Members wird über eine
Backgroundworker gemacht
EndSr
-148Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
13.2.Der Programmaufruf für den Worker-Job
Die Eventsubroutine DoWork führt das Programm aus.
Der Worker wird an den Job übergeben.
/// Background - Worker für CALL
BegSr bgwCALL_DoWork Access(*Private) Event(*this.bgwCALL.DoWork)
DclSrParm sender *Object
DclSrParm e System.ComponentModel.DoWorkEventArgs
/// worker-Objekt aus dem Parameter holen
DclFld worker Type(BackgroundWorker)
worker = sender *as BackgroundWorker
/// Logeintrag für Start machen
cLog.NeuerLogEintrag( "Start PartnerCALL - Events : " + chkEvents.Checked.ToString()
)
/// hier wird die Methode aufgerufen, der Worker wird übergeben
if not cPartner.PartnerCALL ( worker, MemberName,
txtART.Text,
txtSUCHBEGRIFF.Text, +
txtNAME1.Text, +
txtNAME2.Text, +
txtLAND.Text, +
txtANSPRECHPERSON.Text )
/// Logeintrag bei Fehler machen
cLog.NeuerLogEintrag( cPartner.Fehler )
Endif
EndSr
13.3.Der Programmende des Worker-Job’s
Der Event RunWorkerCompleted wird automatisch bei Ende des Workerjobs aufgerufen.
/// Fertigstellungsmeldung des Workers ermöglicht neue Suche
BegSr bgwCALL_RunWorkerCompleted Access(*Private) Event(*this.bgwCALL.RunWorkerCompleted)
DclSrParm sender *Object
DclSrParm e System.ComponentModel.RunWorkerCompletedEventArgs
/// stellt die normale Ansicht der Buttons wieder her
btnSuchen.Visible
= *true
btnAbbruch.visible
= *false
EndSr
-149Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
14. DataGate aus VB oder C# verwenden
ASNA hat für die Integration des System i in .NET ein umfangreiches Set an Klassen erstellt. Diese
Technologie kann nicht nur aus RPG.NET sondern auch ‚vom Rest der Welt‘ verwendet werden.
Diese Klassen sind in den ASNA-Namespaces ASNA.DATAGATE.CLIENT enthalten.
Im Vorläuferprodukt ‚Visual RPG‘ der 90’er – Jahre waren ähnliche Routinen enthalten die auch
als DatagateComponentSuite am Markt angeboten und gut angenommen wurden.
Diese, auf dem Microsoft-Component-Object-Model basierende Zugriffstechnologie wurde aus
VB, Delphi, etc. verwendet um auf die iSeries zuzugreifen.
In diesem Abschnitt sehen wir uns die wichtigsten Objekte der ASNA-Namespaces aus dem
Blickwinkel eines VB.NET oder C#.NET Entwicklers an und vergleichen dazu die Routinen die wir
mit RPG.NET erstellt haben.
Diese einfache Beispielanwendung greift auf Satzebene auf das
System i zu und liest den nächsten Satz ein oder greift über eine
Artikelnummer direkt auf einen Satz zu.
14.1.1. Deklarationen in VB – Vergleich RPG
Bild 14-1 Hallo System i in VB
mit DataGate
Deklarationsbereich in VB:
' deklarieren der DB-Verbindung
Dim dbLocal As New ASNA.DataGate.Client.AdgConnection("*Public/AVRTraining_Local")
' jede Datei braucht einen FileAdapter über den die Zugriffe gemacht werden
Dim faART00 As New ASNA.DataGate.Client.FileAdapter()
' für Zugriffe mit Schlüssel wird die KeyTable deklariert
Dim ktART00 As ASNA.DataGate.Client.AdgKeyTable
' das DataSet gibt den eingelesenen Datensatz zurück
Dim dsART00 As ASNA.DataGate.Client.AdgDataSet
Instanzierung in VB:
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles MyBase.Load
' Eröffnen der DB-Verbindung
' für den Produktionseinsatz sollte ein Try/Catch-Block eingebaut werden
' um Fehler abzufangen
dbLocal.Open()
' die Eigenschaften des File-Adapters werden gesetzt
' Zugriffsmodus auf LESEN
faART00.AccessMode = ASNA.DataGate.Common.AccessMode.Read
' DB-Verbindung an den FileAdapter übergeben
faART00.Connection = dbLocal
' Dateiname zuweisen
faART00.FileName = "*LIBL/ART00"
' eröffnen des File-Adapters - hier wird die Struktur der Tabelle eingelesen
' auch hier wäre im Produktionseinsatz ein Try/Catch-Block sinnvoll da hier
' ein Eröffnungsfehler auftreten kann
faART00.OpenNewAdgDataSet(dsART00)
' erstellen der KeyTable aus dem Satzformat der Tabelle
ktART00 = dsART00.NewKeyTable("RART00")
End Sub
-150Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Codeblock 14-1 Zugriff über DataGate auf eine System i Tabelle
Für jede Datei werden ein FileAdapter und ein DataSet erzeugt – für den Zugriff über Schlüssel
wird eine KeyTable benötigt. In RPG.NET werden diese Klassen implizit mit jedem DCLDISKFILE
erstellt.
Deklarationsbereich in RPG.NET – Instanzierung wird von RPG.NET implizit gemacht
DclDb
DclDiskFile
dbLocal
ART00
DBName("*Public/AVRTraining_Local")
Type(*Input) Org(*Indexed) DB(dbLocal)
File("*libl/ART00")
Codeblock 14-2 Deklaration der Files mit RPG.NET
14.1.2. Sequentieller Zugriff in VB – Vergleich RPG
Sequentieller Zugriff mit VB.NET
Private Sub btnNaechsterArtikel_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles btnNaechsterArtikel.Click
Try
' einlesen des nächsten Datensatzes - übergeben werden
' ADG-DataSet für den Datensatz
' Einstellung der Positionierung - nächster Satz
READ nächster
' Einstellung Sperre - keine Sperre
faART00.ReadSequential( dsART00,
ASNA.DataGate.Common.ReadSequentialMode.Next,
ASNA.DataGate.Common.LockRequest.NoLock
)
Satz
' die eingelesenen Felder in einem String ausgeben
lblBezeichnung.Text = dsART00.ActiveRow("ARTANU").ToString() + " " +
dsART00.ActiveRow("ARTBEZ").ToString()
Catch ex As Exception
lblBezeichnung.Text = "EOF !"
' bei EOF werden die Schlüsselfelder ge-cleart
SETLL
ktART00.Row.Delete()
' und auf den ersten Satz zugegriffen - abhängig vom Schlüssel
faART00.SeekKey(ASNA.DataGate.Common.SeekMode.First, ktART00)
MessageBox.Show("Dateiende erreicht")
End Try
End Sub
Codeblock 14-3 Sequentieller Zugriff mit VB.NET
Sequentieller Zugriff mit RPG.NET
BegSr btnRead_Click Access(*Private) Event(*this.btnRead.Click)
DclSrParm sender *Object
DclSrParm e System.EventArgs
READ
ART00
If %EOF
lblBezeichnung.Text
= "EOF !"
SETLL ART00 Key(*loval)
MsgBox Msg("Dateiende erreicht")
ELSE
lblBezeichnung.Text
= %char(ARTANU) + " " + ARTBEZ
ENDIF
-151Dokument D:\75878992.doc
an Dateibeginn
RPG.NET BESTPRACTICES
EndSr
Codeblock 14-4 Sequentieller Zugriff mit RPG.NET
-152Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
14.1.3. Direktzugriff in VB – Vergleich RPG
Direktzugriff mit VB.NET
Private Sub btnSuchen_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles btnSuchen.Click
Try
' Schlüsseltabelle mit Felder für Direktzugriff füllen
ktART00.Row.Item("ARTANU") = txtArtikelNr.Text
Catch ex As Exception
' dieser Fehler tritt bei der Zuweisung auf - Typenfehler - etc.
MessageBox.Show("Artikelnummer ungültig")
Return
End Try
Try
' Direktzugriff auf den Datensatz der Tabelle - übergeben werden
' ADG-Dataset für den Datensatz
' Positionierung - gleich dem Key
CHAIN
' Sperre - keine Sperre
' Key-Table
faART00.ReadRandomKey(
dsART00,
ASNA.DataGate.Common.ReadRandomMode.Equal,
ASNA.DataGate.Common.LockRequest.NoLock,
ktART00)
' die eingelesenen Felder in einem String ausgeben
lblBezeichnung.Text = dsART00.ActiveRow("ARTANU").ToString() + " " +
dsART00.ActiveRow("ARTBEZ").ToString()
Catch ex As Exception
lblBezeichnung.Text = "NOT FOUND !"
Return
End Try
End Sub
Codeblock 14-5 Direktzugriff mit VB.NET
Direktzugriff mit RPG.NET
BegSr btnChain_Click Access(*Private) Event(*this.btnChain.Click)
DclSrParm sender *Object
DclSrParm e System.EventArgs
TRY
CATCH
ARTANU = txtArtikelnummer.Text
ex Exception
lblBezeichnung.Text
= "Nummer ungültig"
LeaveSr
EndTry
CHAIN ART00
If %Found
key(ARTANU)
lblBezeichnung.Text
= %char(ARTANU) + " " + ARTBEZ
lblBezeichnung.Text
= "NOT FOUND !"
ELSE
ENDIF
EndSr
Codeblock 14-6 Direktzugriff mit RPG.NET
-153Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
14.2.WinDialog – Aufruf von iSeries-Programmen
Das Beispiel wurde bereits in RPG.NET programmiert – hier sollen die Unterschiede zwischen
RPG.NET und VB herausgearbeitet werden.
Die Logik befindet sich in einem Projekt – Namespace DATEN das in
VB nachprogrammiert wurde.
14.2.1. Deklaration von iSeries-Programmen in VB
Bild 14-2 Wartungsdialog in
VB.NET
Public Class ART00
' Datenbank-Deklaration
Dim dbLocal As New ASNA.DataGate.Client.AdgConnection("*Public/INFOCOM2")
' Deklaration der Objekte für den Zugriff auf die Tabelle
Dim faART00 As New ASNA.DataGate.Client.FileAdapter()
Dim ktART00 As ASNA.DataGate.Client.AdgKeyTable
Dim dsART00 As ASNA.DataGate.Client.AdgDataSet
' Objekte für den Zugriff auf das iSeries-Programm
Dim prog As ASNA.DataGate.Client.As400Program
Dim Parms As ASNA.DataGate.DataLink.ProgParm()
Deklaration des Programmobjektes
und der Parameterliste
' Zugriff über SQL
Dim dbConn As New OleDb.OleDbConnection
Dim da As OleDb.OleDbDataAdapter
Dim ds As New DataSet
Public Sub New()
' bei Instanzierung die DB eröffnen
dbLocal.Open()
' den FileAdapter, das DataSet und die Keytabelle instanzieren
faART00.AccessMode = ASNA.DataGate.Common.AccessMode.Read
faART00.Connection = dbLocal
faART00.FileName = "*LIBL/ART00"
Instanzierung des Programmobjektes
faART00.OpenNewAdgDataSet(dsART00)
ktART00 = dsART00.NewKeyTable("RART00")
und der Parameterliste
' das Programmobjekt instanzieren
prog = New ASNA.DataGate.Client.As400Program(dbLocal, "*Libl/ART056")
' die Parametertabelle erstellen
Parms = New ASNA.DataGate.DataLink.ProgParm() { _
New ASNA.DataGate.DataLink.ProgParm(
New ASNA.DataGate.DataLink.ProgParmType("Nummer", 0,
ASNA.DataGate.Common.FieldType.NewPacked(6, 0)), _
ASNA.DataGate.Common.DataDirection.InputOutput), _
New ASNA.DataGate.DataLink.ProgParm(
New ASNA.DataGate.DataLink.ProgParmType("Lager", 0,
ASNA.DataGate.Common.FieldType.NewPacked(6, 2)), _
ASNA.DataGate.Common.DataDirection.InputOutput), _
New ASNA.DataGate.DataLink.ProgParm(
New ASNA.DataGate.DataLink.ProgParmType("Menge", 0,
ASNA.DataGate.Common.FieldType.NewPacked(6, 2)), _
ASNA.DataGate.Common.DataDirection.InputOutput) _
}
' die Parametertabelle an das Programmobjekt binden
prog.AppendParms(Parms)
Parameterliste an
Programmobjekt binden
' den SQL-ConnectionString erstellen
dbConn.ConnectionString = "Provider=IBMDA400.DataSource.1;Data Source=INFOCOM2;
User ID=neich; Password=xxx;Catalog Library List=NXTGEN"
-154Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
dbConn.Open()
End Sub
Codeblock 14-7 Aufruf eines Programmes mit VB.NET
14.2.2. Aufruf von iSeries-Programmen in RPG
Die Deklaration der Parameterliste kann im Deklarationsbereich der Klasse erfolgen oder auch
lokal bei Aufruf.
DclDb
dbRuntime
DBName("*Public/INFOCOM2")
Access( *private )
DclConst
cServerProgramm
Value("*libl/ART132")
Access( *private )
DclPlist
plServerProgramm
DclParm ANU
Type(*packed)
DclParm BEZ
Type(*char)
DclParm PRE
Type(*packed)
DclParm LAG
Type(*packed)
DclParm MWC
Type(*char)
DclParm CDE
Type(*char)
DclParm EOF
Type(*char)
DclParm ERR
Type(*char)
Len(
Len(
Len(
Len(
Len(
Len(
Len(
Len(
6,0 )
50 )
9,2 )
6,2 )
1 )
3 )
1 )
1 )
Codeblock 14-8 Deklaration einer Parameterliste mit RPG.NET
In der Routine wird das Programm aufgerufen, die Parameter werden beim Aufruf deklariert wie
es in RPG üblich ist.
BegFunc
LeseVerfuegbarenBestand
Type( *packed )
DclSrParm
Nummer
Type( *packed )
Len( 6,2 )
Len( 6,0 )
/// die Menge über Random-Funktion festlegen
Menge = DateTime.Now.Second
CALL
Pgm( "*Libl/ART056" ) DB( dbRuntime )
DclParm Nummer
DclParm Lagerstand
Type( *packed )
DclParm Menge
Type( *packed )
Err( *extended )
Len( 6,2 )
Len( 6,2 )
If NOT %error
LeaveSr Lagerstand
Else
LeaveSr *zero
Endif
EndFunc
Codeblock 14-9 Aufruf eines System i Programmes mit RPG.NET
14.2.3. Aufruf von iSeries-Programmen in VB
Public Function LeseVerfuegbarenBestand(ByVal Nummer As Decimal) As Decimal
Dim Lager As Decimal
Dim Menge As Decimal
Menge = DateTime.Now.Second
' füllen der Paramterfelder aus lokalen und übergebenen Variablen
prog.ObjectToParm(Nummer, "Nummer")
prog.ObjectToParm(Lager, "Lager")
prog.ObjectToParm(Menge, "Menge")
' ausführen des Programms
prog.Execute()
' Feldwert aus Parameter einlesen
-155Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Lager = Convert.ToDecimal(
prog.ParmToObject( System.Type.GetType("System.Decimal"), "Lager" )
)
Return Lager
End Function
Codeblock 14-10 Aufruf eines Programmes mit VB.NET
15. Die Beispielanwendung WinDialog in C#.NET
Die Sprache C# ist standardisiert und vielleicht deshalb die am meisten verwendete Sprache in
.NET. Bis auf die Syntax ändert sich gegenüber VB.NET gar nichts. Hier ist das Programm ART00
in C#.
using System;
using System.Collections.Generic;
using System.Text;
namespace Daten
{
public class ART00
{
// deklarieren der Objekte für DB-Verbindung und des File-Adapters
private ASNA.DataGate.Client.AdgConnection dbLocal;
private ASNA.DataGate.Client.FileAdapter faART00;
private ASNA.DataGate.Client.AdgDataSet dsART00;
private ASNA.DataGate.Client.AdgKeyTable ktART00;
// deklarieren der Objekte für den AS/400-Programmaufruf
private ASNA.DataGate.Client.As400Program prog;
private ASNA.DataGate.DataLink.ProgParm[] Parms;
// deklarieren der Objekte für die SQL-Verbindung
private System.Data.OleDb.OleDbConnection dbConn;
private System.Data.OleDb.OleDbDataAdapter da;
private System.Data.DataSet ds;
// deklarieren der Datenklasse und der ArbeitsFelder
private ArtikelDaten cArtikeldaten;
private decimal Lager;
private decimal Menge;
// Programmcode für die Klasse ART00
public ART00()
{
// instanzieren der DB-Verbindung
dbLocal = new ASNA.DataGate.Client.AdgConnection("*Public/INFOCOM2");
dbLocal.Open();
// instanzieren des File-Adapters, des DataSets und der KeyTable
faART00 = new ASNA.DataGate.Client.FileAdapter();
faART00.Connection = dbLocal;
faART00.FileName = "*LIBL/ART00";
faART00.AccessMode = ASNA.DataGate.Common.AccessMode.Read;
faART00.OpenNewAdgDataSet(out dsART00);
ktART00 = dsART00.NewKeyTable("RART00");
// instanzieren des Programmobjektes
prog = new ASNA.DataGate.Client.As400Program(dbLocal, "*Libl/ART056");
ASNA.DataGate.DataLink.ProgParm[] Parms = new ASNA.DataGate.DataLink.ProgParm[]
{
/// erstellen der Programmparameter
new ASNA.DataGate.DataLink.ProgParm(
new ASNA.DataGate.DataLink.ProgParmType("Nummer", 0,
ASNA.DataGate.Common.FieldType.NewPacked(6, 0)),
ASNA.DataGate.Common.DataDirection.InputOutput) ,
new ASNA.DataGate.DataLink.ProgParm(
new ASNA.DataGate.DataLink.ProgParmType("Lager", 0,
ASNA.DataGate.Common.FieldType.NewPacked(6, 2)),
ASNA.DataGate.Common.DataDirection.InputOutput) ,
new ASNA.DataGate.DataLink.ProgParm(
new ASNA.DataGate.DataLink.ProgParmType("Menge", 0,
ASNA.DataGate.Common.FieldType.NewPacked(6, 2)),
ASNA.DataGate.Common.DataDirection.InputOutput) ,
-156Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
};
prog.AppendParms(Parms);
// instanzieren und eröffnen der SQL-Verbindung
dbConn = new System.Data.OleDb.OleDbConnection();
dbConn.ConnectionString = "Provider=IBMDA400.DataSource.1;Data Source=INFOCOM2;
User ID=neich; Password=xxx;Catalog Library List=NXTGEN";
dbConn.Open();
}
// Methode LISTE
public System.Data.DataTable Liste()
{
ds = new System.Data.DataSet();
da = new System.Data.OleDb.OleDbDataAdapter("Select * from NXTGEN.ART00", dbConn);
da.Fill(ds);
return ds.Tables[0].Copy();
}
// Methode ARTIKELDATEN deklarieren
public class ArtikelDaten
{
public decimal Nummer;
public string Bezeichnung;
public decimal Preis;
public decimal Lagerstand;
public string MwstCode;
public decimal Verfuegbar;
public System.Drawing.Image Bild;
}
// Methode LESEN gibt die Datenklasse ARTIKELDATEN zurück
public ArtikelDaten Lesen( decimal Nummer )
{
// erstellen der DatenKlasse
cArtikeldaten = new ArtikelDaten();
// zuweisen der Nummer in die KeyTable
ktART00.Row["ARTANU"] = Nummer;
try {
// Datensatz über Schlüssel einlesen - EOF durch TRY/CATCH abgesichert
faART00.ReadRandomKey(dsART00,
ASNA.DataGate.Common.ReadRandomMode.Equal,
ASNA.DataGate.Common.LockRequest.NoLock,
ktART00);
}
catch (Exception ex) { return cArtikeldaten; }
// Datenklasse mit Feldwerten füllen
cArtikeldaten.Nummer = Convert.ToDecimal(dsART00.ActiveRow["ARTANU"]);
cArtikeldaten.Bezeichnung = dsART00.ActiveRow["ARTBEZ"].ToString();
cArtikeldaten.Preis = Convert.ToDecimal(dsART00.ActiveRow["ARTPRE"]);
cArtikeldaten.Lagerstand = Convert.ToDecimal(dsART00.ActiveRow["ARTLAG"]);
cArtikeldaten.MwstCode = dsART00.ActiveRow["ARTMWC"].ToString();
cArtikeldaten.Verfuegbar = LeseVerfuegbarenBestand(cArtikeldaten.Nummer);
cArtikeldaten.Bild = LeseBild(cArtikeldaten.Nummer);
// Datenklasse zurückgeben
return cArtikeldaten;
}
// private Funktion liest für eine Artikelnummer den verfügbaren Bestand ein
private decimal LeseVerfuegbarenBestand(decimal Nummer)
{
Menge = System.DateTime.Now.Second;
// Felder in Paramter übernehmen
prog.ObjectToParm(Nummer, "Nummer");
prog.ObjectToParm(Lager, "Lager");
prog.ObjectToParm(Menge, "Menge");
// Programm aufrufen
prog.Execute();
// Rückgabewert aus Parameterobjekt einlesen und zurückgeben
return Convert.ToDecimal(
prog.ParmToObject(System.Type.GetType("System.Decimal"), "Lager")
);
-157Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
}
// Bild einlesen
private System.Drawing.Image LeseBild(decimal Nummer)
{
return System.Drawing.Image.FromFile("C:\\AVRTraining\\Bilder\\" +
Nummer.ToString() + ".jpg");
}
}
}
-158Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
16. Programminstallation
16.1.Versionskonflikte zwischen DLL-Versionen lösen
Bei Verwendung von unterschiedlichen Compilerversionen innerhalb eines
Unternehmens kommt es vor dass referenzierte DLL’s auf ältere Compiler-DLL’s
aufbauen und bei der Umwandlung der Programme folgender Hinweis kommt:
------ Erstellen gestartet: Projekt: AssemblyZuordnen, Konfiguration: Debug Any CPU -----Der Konflikt zwischen ASNA.System.Condition, Version=8.1.419.0, Culture=neutral,
PublicKeyToken=cc5be03abdd0c649 und ASNA.System.Condition, Version=8.1.390.0, Culture=neutral,
PublicKeyToken=cc5be03abdd0c649 kann nicht aufgelöst werden. Auswahl von ASNA.System.Condition,
Version=8.1.419.0, Culture=neutral, PublicKeyToken=cc5be03abdd0c649 nach dem Zufallsprinzip.
…
Nachdem wir nur im Ausnahmefall wollen dass DLL‘s nach dem Zufallsprinzip
zugeordnet werden legen wir die zu verwendende Version über die APP.CONFIG fest:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="ASNA.System.Condition" culture="neutral"
publicKeyToken="cc5be03abdd0c649"/>
<bindingRedirect oldVersion="8.1.390.0" newVersion="8.1.419.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="ASNA.DataGate.Client.Security" culture="neutral"
publicKeyToken="c16fa022756bd74b"/>
<bindingRedirect oldVersion="8.1.390.0" newVersion="8.1.419.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="ASNA.DataGate.Ole" culture="neutral"
publicKeyToken="caa6424d9c6983b8"/>
<bindingRedirect oldVersion="8.1.390.0" newVersion="8.1.419.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="ASNA.VisualRPG.Runtime" culture="neutral"
publicKeyToken="d7106be54d30c861"/>
<bindingRedirect oldVersion="8.1.390.0" newVersion="8.1.419.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="ASNA.DataGate.Client" culture="neutral"
publicKeyToken="78aac8f1f3f86b73"/>
<bindingRedirect oldVersion="8.1.390.0" newVersion="8.1.419.0"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>
Empfehlung:
Es ist sinnvoll innerhalb eines Unternehmens mit derselben Compilerversion zu arbeiten!
-159Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
17. Interfaces
Interfaces sind, wie der Name schon sagt Schnittstellen. In einem Softwareprojekt
werden Interfaces verwendet um ein klares Schichtenmodell zu planen und somit
Verantwortlichkeiten festzulegen.
Im Interface werden Eigenschaften und Methoden von Klassen festgelegt aber nicht
implementiert. Somit kann zur Laufzeit eines Programmes entschieden werden welche,
von mehreren zur Verfügung stehenden Klassen die Arbeit übernimmt.
Eine typische Anwendung von Interfaces sind die Schnittstellen zu Office-Programmen
oder zur Datenzugriffsschicht.
Anwendungsprogramm
Objekt-Server
Excel9
Excel11
Excel12
Hier ist das Anwendungsprogramm, das steuert über eine Objekt-Serverklasse welche
der Klassen Excel9, Excel11 oder Excel12 die Arbeit übernimmt.
Die Beispiele mit Office sind nicht zufällig gewählt da es durch die verschiedenen OfficeVersionen immer wieder zu Problemen durch geänderte Funktionalität und
Parameteranzahl kommen kann.
-160Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
17.1.Beispielanwendung UseInterfaces
In dieser Beispielanwendung wurde ein Beispiel auf dem Objekt Auto aufgebaut.
Das Objekt Auto wird in einem Interface beschrieben:
Using System
Using System.Text
DclNamespace MeineInterfaces
BegInterface IAuto Access(*Public)
BegProp Farbe Type( System.Drawing.Color )
BegGet
EndGet
endProp
BegProp Bild Type( System.Drawing.Image)
BegGet
EndGet
EndProp
BegProp AnzahlPlaetze Type( *integer2 )
BegGet
EndGet
EndProp
EndInterface
Jede dieser Eigenschaften muss von der Klasse die das Interface Auto implementiert
unterstützt werden. Wenn die Unterstützung nicht vollständig ist wird die Klasse nicht
kompiliert.
Using System
Using System.Text
DclNamespace MeinAudi
BegClass Auto Access(*Public)
DclFld
img
BegProp
Farbe
BegGet
Implements(MeineInterfaces.IAuto)
Type( System.Drawing.Image )
Type( System.Drawing.Color )
Access( *Public )
Implements(MeineInterfaces.IAuto.Farbe)
LeaveSr System.Drawing.Color.Silver
EndGet
endProp
BegProp
Bild
Type( System.Drawing.Image) Access( *Public )
Implements(MeineInterfaces.IAuto.Bild)
LoadPicture
LeaveSr img
File( "Audi.bmp" ) Target( img )
AnzahlPlaetze
Type( *integer2 )
Access( *Public )
Implements(MeineInterfaces.IAuto.AnzahlPlaetze)
BegGet
EndGet
EndProp
BegProp
BegGet
LeaveSr 2
EndGet
EndProp
EndClass
Der Name der Klasse und der Eigenschaften ist nebensächlich, wichtig ist die
IMPLEMENTS-Anweisung.
Natürlich können Ereignisse und Methoden ebenso implementiert werden wie hier die
Eigenschaften, durch die Konzentration auf Eigenschaften ist das Beispiel übersichtlich
und daher leicht verständlich.
-161Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
Der Objektserver übernimmt die Aufgabe die Objekte zur Verfügung zu stellen.
Using System
Using System.Text
DclNamespace MeinObjectServer
BegClass ObjectServer Access(*Public)
BegFunc
GetAuto
DclSrParm
Code
Type( MeineInterfaces.iAuto )
Type( *string )
Access( *Public )
Select
When Code = "A"
LeaveSr *new MeinAudi.Auto()
When Code = "M"
LeaveSr *new MeinMercedes.Auto()
EndSl
LeaveSr *new MeinPorsche.Auto()
EndFunc
EndClass
Hier sind die Deklarationen und der Aufruf aus dem Hauptprogramm
DclFld cObjectServer
DclFld cAuto
Type( MeinObjectServer.ObjectServer )
Type( MeineInterfaces.IAuto )
new()
…
BegSr rb_CheckedChanged Access(*Private)
Event(
*this.radioButton1.CheckedChanged,
*this.radioButton2.CheckedChanged,
*this.radioButton3.CheckedChanged)
DclSrParm sender *Object
DclSrParm e System.EventArgs
DclFld MeinRadioButton
Type( Radiobutton )
MeinRadiobutton = sender *as Radiobutton
cAuto = cObjectServer.GetAuto( MeinRadiobutton.Tag.ToString() )
txtFarbe.BackColor
txtPlaetze.Text
pbBild.Image
= cAuto.Farbe
= cAuto.AnzahlPlaetze
= cAuto.Bild
EndSr
Hier wird dem Objektserver eingesetzt um zur Laufzeit ein Objekt auf Basis des
Interfaces zu instanzieren. Siehe Beispiel:
-162Dokument D:\75878992.doc
RPG.NET BESTPRACTICES
17.2.Referenzstrukturen
Natürlich müssen die Referenzen innerhalb der Solution entsprechend strukturiert sein.
Hier ist die Hauptanwendung UseInterfaces – sie referenziert auf die Interfaces und den
ObjektServer.
MeineInterfaces braucht auf nichts zu
referenzieren da es sich hier nur um die
Schnittstellenbeschreibung handelt die
von allen Klassen implementiert wird.
Der ObjektServer hingegen muss das Interface
und alle Implementierungen referenzieren
Hier als Beispiel die Implementierung des IAutoInterfaces durch MeinAudi. Es genügt die
Interfaces zu referenzieren.
-163Dokument D:\75878992.doc
Herunterladen
Explore flashcards