Delphi und Visual C#.pdf - Informatik

2. Visuelle Programmiersprachen
Delphi und Visual C#
Windows-Programmierung
Das Struktogramm für die Lösung quadratischer Gleichungen lässt sich durch eine
Liste von Anweisungen realisieren. Das verwundert nicht, weil man ahnt, dass ein
Prozessor ja nur einen Befehl nach dem andern abarbeiten kann. Programmieren in
diesem Sinn wäre daher das Notieren eventuell sehr langer Anweisungslisten.
Mit Delphi und Visual C# betreten wir jedoch das Land der Windowsprogrammierung.
Und da ist alles anders:
Alle Aktionen laufen objekt- und ereignisorientiert ab. Schluss mit der Befehlsliste!
Das bedeutet, dass das Betriebssystem ständig darüber wacht, ob der Benutzer
irgend etwas mit Tastatur (Maus, USB-Ports etc) tut. Das klappt gut, solange der
Rechner nicht „abgestürzt“ ist, also nicht mehr auf Eingaben reagieren kann oder will.
Gibt der Benutzer etwas ein, so sollte sich, falls diese Eingabe vom Programmierer
vorgesehen wurde, ein Programmteil zuständig „fühlen“ und auf dieses Ereignis
reagieren.
Um diese Art der Programmierung zu verstehen, sollten Sie mindestens die
folgenden drei Begriffe kennenlernen: Objekte, Eigenschaften, Methoden und
Ereignisse.
Besonders der Objekt-Begriff wird in Kapitel 5 ausführlich behandelt werden. Hier soll
daher nur soviel, wie unbedingt nötig erklärt werden.
• Objekte (Objects):
Das sind zunächst alle Elemente der Windows-Bedienungsoberfläche.
Betrachten wir der Einfachheit halber nur visuelle Benutzerschnittstellen, dann
hat man es in Delphi mit diesen Objekten zu tun:
o Formulare:
Das sind zum Beispiel Windowsfenster wie das schon recht
komplizierte Word-Fenster, das Sie gerade geöffnet haben.
Die Menge der Formulare wird mit TForm bezeichnet. Darin können
Grafiken, Text oder andere Komponenten enthalten sein.
o Komponenten:
Da gibt es Menus (TMenu),
Schaltflächen bzw. Buttons (TButton),
Textfelder bzw Edits (TEdit)......
(Welche Komponenten erkennen Sie
im Formular rechts?)
o Sonstige Objekte:
Dazu gehören z.B. der Bildschirm
(TScreen) und der Drucker (TPrinter).
125

• Eigenschaften (Properties):
Das sind Dinge wie Farbe (Color), Breite (Width) oder Schrift (Font) des
Objekts. Jedes Objekt hat „seine“ Eigenschaften.
Manche muss kann man nur in der Entwurfzeit,
andere nur zur Laufzeit verändern.
Beispiel: Hier wurde zur Entwurfzeit festgelegt, dass
das Formular rot sein soll. Auch die Aufschrift
(Caption) wurde festgelegt („Formular soll rot sein“)
Hier lässt sich die Farbe durch den Befehl
Form1.color:= clgreen;
auch zur Laufzeit verändern. Dabei ist Form1 der
Name des Formulars. Auch er gehört zu den
Eigenschaften!
• Methoden (Methods):
Der Begriff meint das „Verhalten“ des Objekts auf
bestimmte Ereignisse. Diese können vom Benutzer
ausgelöst werden. Aber auch das Programm selbst
kann Methoden auslösen.
Beispiel: Immer wenn eine Taste gedrückt wird, soll
die Farbe zwischen rot, grün und blau umgeschaltet
und die Aufschrift entsprechend verändert werden.
Damit haben Sie selbst eine Methode für das
Formular programmiert. ( Beispiel:
FarbeAendern.exe)
Objekte können bestimmte Methoden auch „besitzten“. Mit der Methode „Hide“
für Formulare kann man die Eigenschaft visible der Formulars von true auf
false setzten. Das Ergebnis der Methode ist nicht schwer zu erraten. (Beispiel:
Form_Hide.exe )
.
• Ereignisse (Events):
Das sind alle Nachrichten, die vom Objekt empfangen
werden. Im obigen Fall also die Nachricht, dass eine
Taste gedrückt wurde. Diese Ereignisse sind das Herz
jeder Windowsprogrammierung. Sie sind die
Schnittstelle zwischen Programm und Benutzer. Die
Fähigkeit auf Ereignisse zu reagieren wird in
Ereignisbehandlungsroutinen (Event Handler) erledigt.
Noch ein Beispiel: Wenn man mit der Maustaste auf den obigen Knopf drückt,
soll das Formular grün werden. Hier hat ganz offensichtlich schon einer
gedrückt! Das Ereignis ist schon eingetreten und das Progamm hat
entsprechend reagiert.
Holen Sie sich zur Anschauung das Programm FarbwechselKnopfdruck.exe
aus dem Tauschverzeichnis.
Ein wichtiger Tipp: Wenn Sie wissen wollen, welche Eigenschaften, Methoden und
Ereignisse ein visuelles Objekt hat, dann setzten Sie es auf das Formular, markieren
es und drücken dann Taste F 1 .
126

Delphi mit Oracle
Delphi an der Schule
Informatiklehrer an den Gymnasien werden häufig mit folgender Schüler-Frage
konfrontiert:
Warum behandeln alle Lehrer als Programmiersprache Delphi im Informatikunterricht?
Es gibt doch so viele ander Sprachen!
Die Frage ist berechtigt! Zwar gibt es hie und da auch Lehrer, die Java unterrichten.
Bisher muss man sie aber noch mit der Lupe suchen.
Hier der Versuch einer Antwort:
• Es gibt viele gute Lehrbücher für Delphi.
• Delphi beruht auf Object Pascal und das kennen viele Lehrer noch vom
Studium.
• Die ersten Schritte in Delphi sind recht einfach.
• Es ist alles so schön bunt ;-))
Das sind sicher alles gute Argumente. Leider hat man aber keine Schüler gefragt. Bei
vielen ist im Moment C++ oder C# hoch im Kurs. Manche beschäftigen sich aber
eigentlich nur mit PHP und HTML und wollen nur darüber etwas hören. (Von denen,
die eigentlich nur Computerspiele im Unterricht machen wollen, soll hier keine Rede
sein!!)
Und dann gibt es eine kleine (aber feine!) Menge von Lehrern, die sich ganz und gar
nicht für Delphi begeistern können. Und auch sie haben handfeste Gründe. Es geht
ihnen eigentlich nicht um Delphi, sondern sie hadern mit all den graphischen Fertigprodukten,
wie Visual Basic oder Visual C#.
Damit Sie das nachvollziehen können, machen wir nun ein kleines Experiment:
Öffnen Sie Delphi 7. Dann
sehen Sie dies:
Jetzt ist wichtig, dass Sie
sich genau an die folgenden
Anweisungen halten:
Gehen Sie zu file / save
project as
und wählen Sie einen neuen
Ordner namens „Test“ auf
D:
Dann müssen Sie zwei mal
auf „Speichern“ drücken.
Beim ersten Mal sieht es so
aus:
127

Hier speichern Sie
offensichtlich eine Datei
namens Unit1.pas ab.
Beim zweiten Mal wird eine
Datei namens Project1.dpr
ebenfalls dort
abgespeicher.
Nun erzeugen wir durch
Drücken auf den grünen
Pfeil (er bedeutet
„run“und leitet die
Kompilierung ein) oben
links eine „Programmdatei“.
Sie erhält autmatisch den
Namen Project1.exe. Ein
sehr anspruchsloses
Programm!
Es tut rein garnichts. Man
sieht ein Fenster das leer
ist. Man kann es eigentlich
nur wieder wegklicken oder
minimieren bzw auf den
gesamten Bildschirm
vergrößern :
Und jetzt werfen Sie einen Blick in den Ordner Test in
dem alle Dateien dieses „Programms“ versammelt sind.
Richtig, - es sind acht (!!) Dateien! Die meisten kann
man mit Delphi ansehen. Tun Sie das!
Ahnen Sie, weshalb diesen Daten-Erzeugungs-
Vorgang manche überhaupt nicht gut finden?
Selbst bei den banalsten Vorgängen laufen bestimmte
Automatismen ab, von denen man nichts weiß. Damit
wird einem „das Heft aus der Hand genommen“.
Sicher ist es gut gemeint: Man will dem Programmierer zeitraubende und langweilige
Arbeiten ersparen. Damit erkauft man sich jedoch den Nachteil, dass besonders
Programmier-Anfänger beim ersten auftretenden Problem überhaupt nicht verstehen,
was nun denn wieder nicht geht. „Delphi spinnt!“ , bekommt man dann recht häufig
zu hören.
So kommt es, dass manche Lehrerinnen und Lehrer bei den Schulnetz-
128

Administratoren nachfragen, ob man nicht noch das alte Pascal in Windows XP
installieren kann.
Das funktioniert vielleicht sogar mit einer virtuellen Windows 98 Oberfläche, - der
Aufwand ist jedoch unnötig, denn Java ist nicht schlechter und ist vor allem
kostenlos!
Delphis Lebenslauf
Die folgenden Zeilen stellen nur einen stark vereinfachten Ablauf der Delphi-
Geschichte dar.
(Die systematische Einordnung der Sprache haben wir schon in Kapitel 2.0
behandelt)
Bis anfang der 80-iger Jahre gab es im Wesentlichen BASIC-, C-, Fortran- und
Pascal-Compiler. All diese Sprachen waren auf der Grundlage von MS-DOS sehr
umständlich zu bedienen. Das lag vor allem daran, dass MS-DOS nicht multitaskfähig
war. Mit anderen Worten: Die Technik, durch timesharing mehrer Tasks
„gleichzeitig“ ablaufen zu lassen, gab es in MS-DOS nicht.
Zudem waren die genannten Sprachen vor allem wegen des stattlichen Preises nur
für den professionellen Einsatz sinnvoll.
(Die privaten Nutzer und Schulen verwendeten den zu MS-DOS mitgelieferten sehr
langsamen Microsoft BASIC-Interpreter – wohin gegen die Universitäten mit dem
teuren Pascal-Compiler arbeiteten.)
Weshalb waren die Compiler „umständlich“? Sie dürfen nicht vergessen, dass es zu
der damaligen Zeit kaum Festplatten gab. Sie waren einfach zu teurer. Man musste
sich mit Disketten der maximalen Speichergröße von 1,4 MB begnügen. So blieb ein
mehrfacher Disketten-Wechsel nicht aus!
1983 endlich brachte Anders Hejlesberg Turbo-Pascal heraus. (Dem Namen werden
Sie noch einige Male begegnen!)
Dass diese Programmier-Sprache zum Standard wurde, hat mehrere Gründe:
• Relativ güngstig zu kaufen
• Sehr kleiner Speicherbedarf: 60 kB!!!
• Dadurch kein Diskettenwechsel mehr nötig
• Verwirklichung eines IDE-Konzepts (IDE = Integrierte Entwicklungsumgebung)
Es mag Sie erstaunen, aber in den Jahren 1983 bis 1990 wurden zwischen 70% und
80% aller Programme in Turbo-Pascal geschrieben!!
Um einschätzen zu können, wie stark sich die Programmiersprachen in den letzten
Jahren entwickelt haben, muss man sich vor Augen halten, dass bis etwa 1985 eine
Programmiersprache aus einem Editor, einem Compiler, einem Linker und einer
Bibliothek bestand.
Mit dem Editor gab man den Programm-Quelltext ein. Der Compiler übersetzte
diesen Quelltext in Prozessorbefehle, der Linker verband das „Compilat“ mit den
vorgefertigten Teilen der Bibliothek. Eine Bibliothek ist hier eine Sammlung von
129

vorgefertigten Funktionen. Die Sammlung geht von A wie Ausgabe über G wie
Gleitkomma bis Z wie Zeichnen von Linien. Die .NET Bibliothek, die wie einige Seiten
später im Zusammenhang mit C# behandeln werden, ist solch eine Bibliothek.
Für jeden der oben beschriebenen Prozesse musste man eine riesige Diskette (5¼inch:
380kB - 1,2 MB!!) in das Laufwerk schieben. Bis das Programm schließlich
fertig war, hatte man vielleicht mehr als hundert Mal die Disketten gewechselt!
Vor allem war es sehr zeitaufwändig und schwierig, Fehler zu lokalisieren. Selbst
kleinste grafische Bestandteile des Programms erforderten einen riesigen
Programmieraufwand. Um die Hilfe der Programmiersprache in Anspruch zu
nehmen, musste man wieder mit Disketten jonglieren. Die Hilfe für die Bibliothek war
freilich wieder auf anderen Disketten. Kurzum: Programmieren war ziemlich öde und
erforderte vom Programmierer ein erhebliches Maß an Frustrationstoleranz!
Heute freilich sieht die Sache erheblich besser aus. Eine Programmiersprache hat,
wie wir schon im letzten Kapitel erfahren haben, in der Regel eine Integrated
Development Environment, also eine Integrierte Entwicklungsumgebung, kurz: IDE.
In einer IDE sind die oben genannten Komponenten, wie Editor, Compiler bzw.
Interpreter und Linker zusammengefasst. Darüber hinaus gibt es einen Debugger,
einen visueller Designer und eine integrierte Hilfe für die Programmiersprache und
die Bibliothek. Der Programmierer gibt nur den Quelltext ein, drückt auf den
besagten grünen Pfeil und die ganzen Prozesse laufen mehr oder weniger
vollautomatisch ab. Mehr noch: Wenn der Compiler Fehler findet, dann werden diese
aufgelistet und der Vorgang gestoppt.
Es gab 7 Versionen der Sprache Turbo-Pascal. Die IDE der 6.Version sah so
beispielsweise so aus:
(Bild-Quelle: www.schulen.freiepresse.de )
Erst 1991 kam, parallel zur Version 6, Turbo-Pascale für Windows in die Läden.
Wäre Windows nicht der Quasi-Standard geworden, so hätte diese
Programmiersprach wohl kaum einer gekauft, denn mit dem in C programmierten
130

Windows war Turbo-Pascal keine Freude! Die Vorteile der Sprache waren dahin.
Dennoch: Derart umständlich und langsam, konnte auch die Portierung in Windows
als Kaufargument nicht mehr lange überzeugen.
Mit Version 7 kam die Firma Borland ins Spiel. Die Sprache hieß nun Borland-Pascal.
Vermutlich war das Microsoftsche Visual Basic Vorbild für die nächste Version von
Pascal, die jetzt Delphi genannt wurde, wobei man den zugrunde liegenden Code
weiterhin Object-Pascal nennt.
In Delpi wurde, wie in Visual Basic, das sogenannte RAD-Prinzip (Rapid-
Application-Development) verwendet. Man klickt sich seine Anwendungen mit der
Maus zusammen und ein Großteil des nötigen Programmcodes wird automatisch
generiert. Genau das haben Sie ja oben schon kennengelernt!
Ganz im Gegensatz zu den Sprachen Java und PHP findet in Objekt-Pascal eine
strenge Typenprüfung statt. Durch sie und durch die sehr gute Lesbarkeit des Codes
wird die Gefahr nicht gewollten Verhaltens des Programms verringert.
Bleibt zu klären, woher der Name Delphi kommt. Angeblich liegt dies daran, dass
Delphi sehr stark im Erzeugen von Datenbanken ist. Die bekannteste Datenbank
heißt Oracle. Von da ist es nicht mehr weit zu Orakel und schließlich Delphi! (Gibt es
etwa jemanden, der dies nicht verstanden hat?!?)
Behalten wir die Vorteile von Delphi im Auge und schreiben unser erstes „Hallo
Welt!“ – Programm.
Programmieren in Delphi
Starten wir Delphi und verkleinern wir mit der Maus das Form1-Fenster. Dann sehen
wir dies:
131

Dabei ist die Unit1 offensichtlich der Teil, in den man den Pascal-Programm-Code
schreibt oder von Delphi schreiben lässt.
Platzieren wir einen Button irgendwo auf dem Formular mit Namen Form1: Mit
linker Maustaste anklicken und auf dem Formular erneut klicken. Dann sieht das
Formular so aus:
Da liegt er nun unser Button mit
Name Button1. Ein Schaltknopf auf
den man klicken kann.
Auf der linken Seite der Delphi-Programmoberfläche gibt es ein
sehr wichtiges Instrument: Den Projektinspektor!
Hier können Sie alle „Eigenschaften“ (Properties) des Buttons
einstellen. Ein Beispiel: Wenn man unter der Eigenschaft
Caption den Text „Hier drücken!“ schreibt, so sieht der
Schaltknopf so aus:
Wer nun noch die Schrift verändern will,
stellt diese unter der Eigenschaft Fonts
ein.
Frage: Was ist der Unterschied zwischen den Eigenschaften
Caption und Name?
Bevor man weiter arbeitet sollte man unbedingt das Projekt
speichern. Speichern Sie den bisherigen Stand in einem
Ordner namens 03_HalloWelt. (Wie das geht ist zwei Seiten
weiter oben gezeigt!)
Dann drücken wir den
grünen Pfeil, um das
Progrämmchen
kompilieren zu
lassen. Nun bekommt
man eine exe-Datei,
die geöffnet wie links
dargestellt aussieht.
Leider kann man auf den Button drücken sooft man will, - es
passiert einfach nichts!
Und das liegt daran, dass wir dem
Button noch kein Onclick –
„Ereignis“ mitgegeben haben.
Schauen Sie sich nochmal den
132

Objektinspektor an: Hier gibt es auch einen Tab „Events“. Leider steht hier noch
nichts. Das werden wir sofort ändern:
Gehen Sie zurück in den Programmier-Modus und führen Sie einen Doppelklick auf
dem Button aus.
Jetzt passiert zweierlei:
1. Es gibt einen Eintrag unter Events :
Da steht das Ereignis „Button1Click“.
Ist doch wunderbar, diese Automatik!
2. In Unit1 erscheint wie von Zauberhand ein Zusatz:
procedure TForm1.Button1Click(Sender: TObject);
begin
end;
Und zwischen begin und end schreiben wir den Auftrag, dem wir dem Programm
geben wollen:
Showmessage(‚Hallo Welt!);
Dann noch alles speicher mit
Zu guter Letzt kompilieren und das Programm sollte die Welt grüßen:
Somit haben Sie Ihr erstes Delphi-Programm geschreiben!
Aber haben Sie es auch verstanden? Was bedeutet beispielsweise
procedure TForm1.Button1Click(Sender: TObject); ?
Auch wenn das Thema „Objektorientierte Programmierung“ erst später behandelt
werden wird, so sollten Sie dennoch den Hintergrund für diese Schreibweise kennen:
• „procedure“ ist klar, oder? Wenn nicht: Es soll heißen, dass in den folgenden
Zeilen zwischen begin und end ein Programm bzw Unterprogramm
ausgeführt werden soll. Wie Sie gelernt haben, wird die procedure von einem
Ereignis ausgelöst werden (In diesem Fall dem Knopfdruck).
• „TForm1“ ist ein Objekt. Dieses hat, wie wir oben dargelegt haben, bestimmte
Eigenschaften, Methoden und Ereignisse.
• „TForm1.Button1Click“ besagt, dass das Ereignis Button1Click des Buttons1
dem Objekt TForm1 zugeordnet ist.
133

• „Sender: TObject“ soll klarstellen, dass die aufrufende Instanz ein Objekt, in
diesem Fall Button1 ist.
Denken Sie jetzt kurz darüber nach, wie Sie bei der Programmierung vorgegangen
sind! Danach lesen Sie die folgenden Zeilen:
Erkenntnisse bezüglich der Windowsprogrammierung:
• Man beginnt die Programmierung mit dem Entwurf einer visuellen Oberfläche.
• Wenn alle Objekte auf der Oberfläche untergebracht sind, müssen diesen ihre
Eigenschaften, die von den voreingestellten Werten abweichen, zugewiesen
werden.
• Die Objekte werden mit Ereignissen verknüpft.
• Jetzt erst wird im alten Sinn „programmiert“, in dem man in die Unit mittels
Pascal-Code die durchzuführenden Methoden schreibt.
Diese Erkenntnisse gelten selbstverständlich auch für Visual C# oder für Visual
Basic.
Vergleichen Sie diese Methode beispielsweise mit dem nicht-grafischen Java und Sie
verstehen sofort, weshalb sich diese Programmiersprachen großer Beliebtheit
erfreuen!
Sehen wir uns diese Eigenschaft / Ereignis / Methode - Charakterisierung am Beipiel
eines Schaltknopfes nochmals an:
Objekttyp TButton (Schaltflächen-Komponente)
Eigenschaften
Caption
Name
Width
Ereignisse
OnClick
OnExit
Methoden
Hide
SetFocus
Click
Text für die Aufschrift des Buttons
Name des Objektes
Länge des Buttons in Pixel
usw.
Das Ereigniss wird ausgelöst, wenn man mit der linken
Maustaste auf den Button klickt.
Das Ereignis wird ausgelöst, wenn die Komponente
verlassen wird.
usw.
Versteckt den Button
Der Fokus wird auf den Button gesetzt
Simuliert einen Mausklick
usw.
134

Wie bereits oben erwähnt, können Sie diese Informationen stets mit der F 1 -Taste
abrufen.
Aufabe 1
Öffnen Sie Delphi. Identifizieren Sie die unten beschriebenen Teile der Oberfläche:
• ein Hauptfenster mit Menüleiste, Symbolleiste und Komponentenpalette.
Hier finden Sie die vorgefertigten Delphi-Komponenten wie z.B. Buttons, Radio-
Buttons usw.
• ein Hauptformular für die zu schreibende Anwendung, in dem Komponenten wie
z.B. Buttons eingefügt werden.
• ein Objektinspektor, mit dessen Hilfe die Eigenschaften und Ereignisse einer
Komponente festgelegt werden.
• ein Quelltexteditor, in welchem der Programmcode bearbeitet wird.
Bevor man nun ein etwas anspruchsvolleres Programm, wie „Hallo Welt“ schreiben
will, sollte man, wie bei Java und PHP auch, die wichtigsten Datentypen kennen. Wie
so oft ist ein Blick zu Wikipedia sehr aufschlussreich:
Elementare Datentypen
Name Größe Wertebereich Beschreibung
Boolean 1 Byte true oder false boolescher Wert
Byte 1 Byte 0 bis 255
Word 2 Byte 0 bis 65535
Cardinal 4 Byte 0 bis 4.294.967.295
ShortInt 1 Byte −128 bis 127
SmallInt 2 Byte −32.768 bis 32.767
LongInt
4 Byte −2 31 bis 2 31 −1
vorzeichenlose 8-Bit-
Ganzzahl
vorzeichenlose 16-Bit-
Ganzzahl
vorzeichenlose 32-Bit-
Ganzzahl
vorzeichenbehaftete 8-Bit-
Ganzzahl
vorzeichenbehaftete 16-Bit-
Ganzzahl
vorzeichenbehaftete 32-Bit-
Ganzzahl
Int64 8 Byte −2 63 bis 2 63 −1
vorzeichenbehaftete 64-Bit-
Ganzzahl
Real48 6 Byte 2,9·10 −39 bis 1,7·10 38 48-Bit-Gleitkommazahl
Single 4 Byte 1,5·10 −45 bis 3,4·10 38 32-Bit-Gleitkommazahl (IEEE
754-float)
Double 8 Byte 5,0·10 −324 bis 1,7·10 308 64-Bit-Gleitkommazahl (IEEE
754-double)
Extended 10 Byte 3,6·10 −4951 bis 1,1·10 4932 80-Bit-Gleitkommazahl
Comp 8 Byte −2 63 bis 2 63 −1 vorzeichenbehaftete 64-Bit-
135

Currency
8 Byte
Char 1 Byte #0 bis #255
WideChar 2 Byte #0 bis #65535
bis 256
ShortString
Byte
AnsiString bis 2
GByte
WideString bis 2
GByte
−922.337.203.685.477,5808 bis
922.337.203.685.477,5807
Aneinanderreihung von bis zu
255 Chars
Aneinanderreihung von bis zu 2 31
Chars
Aneinanderreihung von bis zu 2 30 WideChars
Ganzzahl, mit der über die
FPU gerechnet wird
vorzeichenbehaftete 64-Bit-
Festkommazahl
8-Bit-Zeichen, z. B. ASCII-
/ANSI-Zeichen
16-Bit-Zeichen, z. B. Unicode-
Zeichen
Der Datentyp Real entspricht in Delphi standardmäßig dem Double.
Der Datentyp Integer hängt von der jeweiligen Pascal-Implementierung ab. In 16-Bit-
Implementierungen (z. B. Turbo Pascal) entsprach er einem SmallInt, in 32-Bit-
Implementierungen einem LongInt und in 64-Bit-Implementierungen wird er einem
Int64 entsprechen.
Viele Variablen-Bezeichnungen kennen Sie schon von Java und PHP. Dort war die
Art der verwendeten Variablen nicht all zu wichtig. Man konnte zum Beispiel
ungestraft string mit integer mulitplizieren. Ist das in Delphi auch so?
Aufgabe 2
Erzeugen Sie einen Ordner 04_Multiplikation.
Stellen Sie mit Delphi etwa diese Oberfläche her und speichern Sie alles im Ordner
04_Multiplikation
ab
Jetzt ein Doppelklick auf „Berechnen“. Schreiben Sie folgender Programmcode in
den sich öffnenden procedure-Rumpf:
procedure TForm1.Button1Click(Sender: TObject);
var x,y,Ergebnis: double;
136

egin
x:=strtofloat(Edit1.Text); y:=strtofloat(edit2.Text);
Ergebnis:=x*y;
edit3.text:=floattostr(Ergebnis);
end;
Die fett gedruckten Teile hat Delphi selbst geschrieben.
strtofloat ist eine Methode, die einen übergebene Stringvariable in eine Gleitkomma-
Variable umwandelt. Die Methode ist hier unverzichtbar, da alle Einträge in Editfelder
Stringvariable sind. Und mit denen multipliziert es sich etwas schlecht...
Was bedeuten die verschiedenen Zeilen? Was tut floattostr und wozu wird die
Methode gebraucht?
Überprüfen Sie, ob folgende für Multiplikation in PHP und Java erlaubte
Variablendefinition (x und y) auch in Delphi zugelassen ist, wenn man beide Variable
durch eine Rechenoperation verknüpft:
var x, Ergebnis: double; y:integer;
Erweitern Sie das Programm für weitere Rechenoperationen. (Taschenrechner). Die
Zeichen für die Rechenoperationen unterscheiden sich nicht wesentlich von denen in
Java.
Zum Abschluss wieder unser „Universalproblem“ quadratische Gleichung lösen:
Die Oberfläche erstellt man äußerst komfortabel mit der Maus: Einfach die
gewünschten Komponenten in das Formular ziehen. So kann das Fenster aussehen:
Man benötigt zwei
Eingabe-Komponenten.
Hier ist wie oben auch
TEdit geeignet. Die
Ausgabe-Komponenten
sind hier ebenfalls
Editfelder, könnten aber
auch TLabel sein.
Achten Sie auf gute
Lesbarkeit und
Übersichtlichkeit! Eventuell
die Eigenschaften Font
und Color anpassen!
Doppelklicken Sie auf die
beiden Buttons und fügen
Sie in den Programmrumpf
zum Beispiel diesen Code ein:
137

procedure TForm1.BerechneClick(Sender: TObject);
var diskr, p, q :double;
begin
if (edit1.text = '') or (edit2.text = '') // leere Eingabe vermeiden
then begin edit3.visible :=true; edit3.text:= 'Zunächst p und q angeben!' ; end
else
begin
p:= strtofloat(edit1.text); q:= strtofloat(edit2.text);
diskr:= p*p/4 - q;
if diskr > 0 then //positive Diskriminante : zwei Lösungen
begin
edit3.Visible:= true; edit4.Visible:= true; //sonst sieht man nichts!
label3.Visible:= true; label4.Visible:= true;
edit3.Text:= FloatToStr(-p/2 + sqrt(diskr)); //erste Lösung
edit4.Text:= FloatToStr(-p/2 - sqrt(diskr)); //zweite Lösung
end
else if diskr = 0 then //Diskriminante 0: genau eine Lösung
begin
edit3.Visible:= true; label3.Visible:= true;
edit3.Text:= FloatToStr(-p/2);
end
else
begin
edit3.Visible:= true;
edit3.Text:='Keine Lösung';
end;
end;
end;
Hier der zweite Button:
procedure TForm1.NeueRechnungClick(Sender: TObject);
begin
edit1.Text:=''; edit2.Text:='';
edit3.Visible:= false; edit4.Visible:= false;
label3.Visible:= false; label4.Visible:= false;
end;
Der besseren Lesbarkeit wegen wurden für den Programmcode Farben verwendet.
Dabei ist der fettgedruckte, schwarze Teil immer von Delphi selbst geschrieben.
Aufgabe 3
Versuchen Sie den Quellcode
nachzuvollziehen und erstellen Sie
das Programm. (Ordner
05_quadratischeGleichung )
Schreiben Sie danach, wie bei Java
auch, eine Variante dieses
138

Programms, bei der die andere Mitternachtsformel für
ax 2 + bx + c = 0 gelöst wird!
Lösung: x 1/2 = (-b +/- sqrt(d)) / (2a) wobei d = b 2 - 4ac
Ordner:06_quadratischeGleichung2.
Wie im letzten Kapitel auch wollen wir uns anhand eines Primzahlprogramms einige
Schleifen in Delphi ansehen.
Die Oberfläche ist schnell zusammengeklickt:
Ein Doppelklick auf den Button und zum Beispiel folgenden Programmcode einfügen:
(Nochmals zur Erinnerung: Die fett gedruckten Zeilen sind von Delphi geschrieben!)
procedure TForm1.Button1Click(Sender: TObject);
var zahl : int64; i,j : cardinal;
begin
zahl:= strtoint64(edit1.text);
if zahl=1 then label1.caption:= 'Die Zahl ist keine Primzahl'
else
if zahl=2 then label1.caption:= 'Die Zahl ist eine Primzahl'
else
if zahl mod 2 = 0 then label1.caption:= 'Die Zahl ist keine Primzahl'
else
begin
i:= 1; j:= 0;
if zahl > 2 then
repeat
i:= i + 2; j:= j + 1;
until (zahl mod i = 0) or (i > zahl div i);
end;
if i > zahl div i then label1.caption:= 'Die Zahl ist eine Primzahl'
else label1.caption:= 'Die Zahl ist keine Primzahl';
end;
139

Es gibt natürlich mehrere Möglichkeiten in Delphi, eine Schleife zu programmieren.
Oben haben wir es mit repeat / until versucht. Hier wird die Bedingung, ob die
Schleife verlassen werden soll, erst nach dem Durchlauf geprüft.
Genauer:
Jede Iteration (Schleife) besteht aus einer Anweisungsfolge, die mehrfach ausgeführt
werden kann und einer Bedingung, die
• als Austrittsbedingung aus der Schleife
oder
• als Eintrittsbedingung für die Schleife dient.
Struktogramm für eine Iterationen mit einer Austrittsbedingung
( repeat....until)
Struktogramm für eine Iterationen mit einer Eintrittsbedingung
(while....do)
Iteration mit Austrittsbedingung
Syntax :
repeat
until
Iteration mit Eintrittsbedingung
Syntax :
while do
140

• Eine Anweisungsfolge muss bei der while-Schleife mit begin/end zu einem
Anweisungsblock geklammert werden.
• Eine repeat-Schleife wird mindestens einmal durchlaufen, eine while-Schleife
muss nicht unbedingt durchlaufen werden.
Iterationen mit einer festen Zahl von Wiederholungen
Beispiel:
for i:=1 to 10 do
begin
dZinsen:=dKapital*dZinssatz/100;
dKapital:=dKapital+dZinsen;
end;
Struktogramm für eine Zählschleife:
Gezählte Iteration (aufwärts)
Syntax :
for := to do
Gezählte Iteration (abwärts)
Syntax :
for := downto do
• Eine for-Schleife kann nur benutzt werden, wenn im Voraus die Anzahl der
Schleifendurchläufe bekannt ist.
• Eine Anweisungsfolge muss bei der for-Schleife mit begin/end zu einem
Anweisungsblock geklammert werden.
Aufgabe 4
141

Erstelle einen Ordner namens 07_Primzahltest bis 10hoch18 und erstelle dort das
Programm Primzahltest wie oben beschrieben.
Aufgabe 5
Um die anderen
Schleifen
kennenzulernen,
versuchen Sie nun mit
Hilfe der obigen
Primfaktorbestimmung
ein Programm zu
schreiben, das eine
gegebene ganze Zahl
(bis 10 18 – also int64) in
ihre Primfaktoren zerlegt.
Die Oberfläche kann
zum Beispiel so
aussehen:
Das Feld rechts heißt „Listbox“ und ist unter Standard zu finden.
Will man die Zahl i auf der Listbox hinzufügen, so lässt sich das mit dieser Zeile
erledigen:
Listbox1.Items.Add(inttostr(i))
Je nach Geschwindigkeit des Rechners kann die Zerlegung einige Zeit (1-2 Minuten)
in Anspruch nehmen. Allerdings nur, wenn man eine sehr große Primzahl
eingegeben hat.
Sollte Ihnen das im Moment noch zu schwer sein, so können Sie den Programmcode
im Tauschverzeichnis finden (08_Primfaktorzerlegung)….
Delphi ganz ohne Optik
Wie wir schon mehrfach erwähnt haben, ist
der ganze optische „Krimskrams“ mit den
vielen Automatismen mitunter eher eine
Last denn eine Hilfe. Will man beispielsweise
einen bestimmten mathematischen
Algorithmus testen, dann wäre eine
Konsole wie bei Java eigentlich viel besser.
Kein Problem. Für die Puristen unter Ihnen
wird folgender Tipp hilfreich sein:
Öffnen Sie Delphi. Gehen Sie zu File / New
/ Other:
Hier wählen Sie Console Application.
(siehe rechts!)
142

Danach öffnet sich ein solches Fenster:
Interessant ist, dass beispielsweise der Object TreeView und der Objectinspector
leer bleiben. Ist ja klar: Wir programmieren eine Konsolenanwendung! Was soll man
da mit Buttons, Edits etc anfangen?!
Aufgabe 6
Erstellen Sie einen Ordner (09_Delphikonsole) und ergänzen Sie mit dem Editor wie
unten angegeben:
143

Speichern Sie das Projekt unter dem Namen „Hallo“. (Dann wird der Name bei
program automatisch angepasst!)
Und nun das Programm
kompilieren!
Kommt Ihnen das bekannt
vor??
Wenn ja, dann schreiben Sie
doch in Delphi eine
Konsolenanwendung für das
Addieren zweier Zahlen
oder, wenn Sie höhere Ziele
haben, wie wäre es mit
einem Konsolenprogramm
für den Primzahltest...????
Zur Hilfe ist nebenstehend der
Pascal-Quellcode für ein
Additionsprogramm angegeben.
Die Ähnlichkeit zu Java und PHP
fällt Ihnen hoffentlich auf!
Noch eine abschließende Frage
hier zu: Weshalb steht einige
Zeilen weiter oben „Pascal-“ und
nicht „Delphi-Quellcode“?
Wir arbeiten doch mit Delphi?!
Delphi entwanzen
Zu einer guten Programmiersprache gehört ein ausgezeichneter Debugger. Denn,
machen Sie sich keine Illusionen, ca. 50% der Programmierzeit ist debug-Zeit! Was
genau ist ein Debugger? Schlagen wir nach bei Wikipedia:
Ein Debugger (von engl. bug) ist ein Werkzeug zum Auffinden, Diagnostizieren und
Beheben von Fehlern in Hardware und Software. Ein Debugger ermöglicht in der
Regel eine Ablaufverfolgung des zu untersuchenden Programmes in einzelnen
Schritten oder zwischen definierten Haltepunkten (Breakpoints). Ist ein Programm auf
diese Weise angehalten, kann der Entwickler die Inhalte von Prozessorregistern und
Variablen einsehen, verändern oder sich den Verlauf der Funktionsaufrufe bis zum
Breakpoint ansehen (callstack). Moderne Debugger (bei kompilierten Sprachen, z.B.
C/C++) haben die Möglichkeit, Änderungen am Quelltext on the fly zu übersetzen
144

und mit diesen Änderungen die Programmausführung fortzusetzen. Diese Technik
wird auch als just in time debugging bezeichnet.
Klingt gut! So gut, dass wir uns gleich weiter unten mit dieser Technik in Delphi
auseinandersetzen werden. Aber zuvor noch eine Warnung: Ein Debugger findet
(prinzipiell) nicht alle Fehler.
Dies wirft die Frage auf: Welche Fehlerarten gibt es denn? Und welche kann der
Debugger finden, welche aber nicht?
Hier eine Aufzählung:
Syntaxfehler
Fehler dieser Art treten während der Compilierung des Programmcodes auf, wenn
gegen die Syntaxregeln von Objekt-Pascal verstoßen wird. Delphi stoppt die
Compilierung nach dem ersten Fehler (oft erst in der Zeile danach), hebt die
entsprechende Zeile farblich hervor und gibt eine entsprechende Fehlermeldung in
der Statuszeile aus. Der eigentliche Fehler kann sich jedoch an einer anderen Stelle
im Programmcode befinden. Ein konkretes Beispiel, das Ihnen vermutlich sehr
bekannt vorkommt:
(Der obige Screenshot ist aus unserem Primzahlprogramm)
Beispiele für Syntaxfehler:
• Als Bezeichner werden reservierte Wörter (z. B. var, begin, end, procedure, etc.)
benutzt.
• Es werden Sonderzeichen vergessen (z. B. Semikolon, Kommata, etc.)
• Reservierte Wörter werden falsch geschrieben
• Unzulässige Operationen bei gewissen Dateitypen (zB.:. sText := 'Hallo' * 'Welt';
ist nicht zulässig);
145

Laufzeitfehler
Diese Fehler treten nicht während der Compilierung, sondern während der
Ausführung der Anwendung auf, wenn das Programm zwar gültige Anweisungen
enthält, diese Anweisungen bei ihrer Ausführung aber Fehler verursachen. Das
Betriebssystem stellt Laufzeitfehler fest und bricht dann die Programmausführung ab.
Erkennen Sie den Fehler? (Variation des Programms „Multiplikation“)
Übrigens: Delphi reagiert bei Division mit Null nicht immer mit einem Laufzeitfehler!
Das können Sie leicht selbst testen. Ändern Sie den Quelltext wie folgt ab:
(Die Eingabefelder sind hier unnötig und daher gelöscht)
Typische Beispiele für Laufzeitfehler sind:
• Division durch 0
• Öffnen einer Datei, die gar nicht exisitiert
• Fehlerhafte Speicherreservierung
146

Logische Fehler
Diese Art von Fehler wird vom Compiler nicht wahrgenommen. Es sei denn, der
logische Fehler führt zu einem Laufzeitfehler.
Ein einfaches Beispiel:
Will man die natürlichen Zahlen von 1 bis N addieren, so benötigt man eigentlich
keine Schleife, denn es gibt dafür eine leicht herzuleitende Formel: N*(N+1)/2
Ist etwa N=5 so errechnet man mit der Formel: 1+2+3+4+5 = 5*6/2=15
Will man dennoch die Formel durch eine Schleife überprüfen, so könnte Quelltext
und Formular so aussehen:
Der Compiler verrichtet seine Arbeit klaglos, beim Klicken auf den Button „Berechne“
scheint sich der Rechner aber „aufzuhängen“. (Unterprechen kann man den Vorgang
durch Run / Program Reset )
Wo steckt der Fehler?
Die Meisten werden es sofort sehen: An der while-Schleife stimmt etwas nicht.
Um den Debugger ins Spiel zu bekommen, spielen wir jedoch zunächst den
Ahnungslosen ( was sicher Einige erfreuen wird ;-) )
147

Mit Hilfe eines Debuggers kann man nämlich
überprüfen, was genau mit den Variablen
passiert. Dazu muss man lediglich einen
Haltepunkt im Quelltext platzieren, ab dem
dann das Programm in Einzelschritten
kontrolliert weiterlaufen soll. Den blauen Punkt
links an der betreffenden Zeile anklicken und
fertig!
Auswerten der Variableninhalte
Startet man das Programm, so wird es an dem Haltepunkt gestoppt. Nun können
Variableninhalte überprüft werden, indem man mit der Schaltfläche oder mit F7
den nächsten Schritt durchführen lässt. Zuvor sollten Sie allerdings mit Strg+F7 das
Evaluate/Modify-Fenster starten. Dort tragen Sie in der ersten Zeile die zu
untersuchende Variable namens E ein.
Nach jedem Schleifendurchlauf drücken Sie nun auf Evaluate. Dabei werden Sie
bemerken, dass sich E überhaupt nicht verändert.
Vermutlich ist Ihnen spätestens jetzt klar, dass die Schleifenvarible i immer gleich
bleibt. Lösung: i müsste eigentlich immer um 1 größer werden, daher i:=i+1;
einfügen.
Tipp:
Will man mehrere Variable gleichzeitig überwachen, so wählt man besser das Watch
List-Fenster. Und das geht so:
148

Mit Strg+F5 das Watch
List-Fenster starten.
Gleichzeitig erscheint dann
ein zweites Fenster
(Watch Properties) in das
Sie alle zu überprüfenden
Variablennamen eintragen
können.
(Siehe Bild!)
Hier sieht man direkt, dass sich i nicht ändert.
Aufgabe 7
Schreiben Sie das Programm 12_Summenformel und testen Sie den Debugger wie
oben gezeigt. (Natürlich können Sie auch ein eigenes Programm, dass nicht recht
laufen will, für den Test verwenden!)
149

Visual C# 2005 ist .NET
Weshalb nun noch eine zweite visuelle Windows- Programmiersprache, wenn Delphi
doch weitgehend zufriedenstellend funktioniert?
Dafür gibt es mehrere Gründe:
• Auch hier soll, wie im letzten Kapitel erkannt werden, dass sich die beiden
Sprachen nicht wesentlich unterscheiden. Kennt man Eine, so ist die Andere
auch kein Problem.
• Wir arbeiten in der Schule im Moment mit Delphi 7. Ab Delphi 8 wird die
überaus praktische Microsoft Plattform .NET („Dot-Net“) unterstützt. (Dazu
gleich mehr.) Leider hat Borland ab dieser Version für Mehrplatz-Linzenzen
die Einrichtung eines Lizenzen-Servers gefordert. Weil der sehr umständlich
einzurichten ist und weil zudem der Preis für eine Schullizenz nicht gerade ein
Schnäppchen genannt werden kann, verzichten die meisten Schulen
zugunsten von Visual C# oder Visual C++. Microsoft verschenkt die Beiden in
der Express-Version. Diese ist absolut ausreichend für den Unterricht und
kann zudem .NET.
• Vielleicht gefällt manchen C# besser während die Anderen eher Delphi
bevorzugen. Lernt man beide kennen, so kann jeder selbst urteilen!
• Das Hilfe-System mit IntelliSens und Onlinehilfe ist deutlich besser, als bei
Delphi 7.
(Zum zweiten Punkt eine kurze Bemerkung:
Schon einmal hat Microsoft etwas verschenkt. Das MS-DOS-Betriebssystem! Die
Folgen sind bekannt: Nun zahlen 90% der Computer-Käufer für viel Geld ein
Betriebssystem Vista, das mit den schon gekauften und völlig zufriedenstellenden
Programmen aus der XP-Zeit hinten und vorne nicht funktioniert und, wie wenn das
nicht reichen würde, auch noch die Rechte des Benutzers erheblich einschränkt.
Linux und die Anderen helfen leider nur bedingt. Man würde den Schritt ja gerne
wagen, wenn man sich nicht so sehr an Windows, das allseits kompatible
Betriebssystem, gewöhnt hätte! Daher bleibt die Konsequenz: Hier hat Borland ein
klassisches Eigentor geschossen……)
.NET Framework (Gerüst)
Was genau ist das .NET Framework?
Anfang 2000, als Microsoft .NET der erstaunten Öffentlichkeit vorstellte, wusste
vermutlich nicht einmal Bill Gates selbst, was genau man unter .NET verstehen soll!
Vielleicht haben Sie schon einmal vom Begriff COM (Component Object Model) im
Zusammenhang mit Windowsprogrammierung gelesen oder gehört.
Es ist eine inzwischen veraltete Microsoft- proprietäre Plattform, die ein Interface
150

(Schnittstelle) anbietet, mit der die Programmierer auf die Fähigkeiten des jeweiligen
COM-Objekts zugreifen können. Diese Plattform wurde von der .NET-Plattform
abgelöst.
Die Ablösung war nötig, weil das plattformunabhängige Java mit seiner VM (Virtual
Maschine) für fast alle Hochsprachen eine Schnittstellen für eine große Anzahl
fertiger Objekte anbot, die die Arbeit des Programmierers erheblich vereinfachte.
Darauf musste Microsoft reagieren. Java drohte nicht nur den Computer, sondern
auch den inzwischen stark gewachsenen Mark der Kleingeräte zu erobern. Gerade
im letzten Bereich war Microsoft so gut wie nicht vertreten!
Außerdem war die gängige Microsoft-Sprache Visual Basic 6 den gewachsenen
Anforderungen nicht gewachsen. Wie sollte sie auch!? VB6 war ja nicht dafür
konzipiert worden Probleme zu lösen, von deren Existenz man zur Entwicklungszeit
noch gar nicht wusste!
Natürlich kann man meist auch mit hinreichend komplizierten Tricks ältere
Programmiersprachen an aktuelle Probleme anpassen. Je länger man sich so behilft,
desto komplizierter wird das Prozedere. Irgendwann ist dann der Punkt gekommen,
an dem man sich eine angepasste Programmiersprache wünscht. Microsoft muss
wohl schon mitte der 90-er Jahre mit der Entwicklung begonnen haben. Denn was
mit .NET und C# das Licht der Welt erblickte, war eine sehr ausgereifte
Klassenbibliothek mit einer geradezu unglaublichen Anzahl an Funktionen.
Im Anfangstadium der Entwicklung allerdings versuchte Microsoft das von der Firma
SUN entwickelte Java zu imitieren. Das war nun gar nicht lustig, denn so begann
Java seine Plattform-unabhängigkeit zu verlieren. (Die Firma SUN strengt
diesbezüglich auch erfolgreich die Gerichte an).
Also holte sich Microsoft die weltbesten Fachleute und ließen sie ein eigenes,
weitgehend plattformunabhängiges Objektmodell entwickeln, das den neuen
Anforderungen der Programmierergemeinde stand halten sollte.
Einen dieser Fachleute kennen Sie: Anders Hejlsberg, den Entwickler von Turbo-
Pascal!!! Er schrieb nun die speziell für .NET konzipierte Sprache C#. Was für ein
Genie!
Nun dürfen Sie raten: Welchen Sprachen ähnelt C# nicht nur auf den ersten Blick?
Hejlsberg sei Dank: Delphi und Java! Wundert sich da noch jemand?
Der Vorwurf, C# mit .NET sei bei Java abgekupfert, kann nicht aufrecht erhalten
werden. Zu groß ist die Fülle der Klassenbibliotheken bei C#. Davon kann Java nur
träumen! (Seit JDK 5 kann man mitunter eher den gegenteiligen Eindruck
bekommen, dass Java bei C# abgekupfert hat…..)
Für das Verständnis ist wichtig, dass die .NET-Plattform mit ihrer CLI (Common
Language Infrastructure) nun ebenfalls eine Schnittstelle für die wichtigsten
Programmiersprachen darstellt. Wie bei Java wird dies durch Verwendung einer
virtuelle Maschine und der BCL (Base Class Library = gemeinsame Klassenbiliothek)
erreicht. Demnächst kommt .NET in der 3. Version heraus und die Programmierer
wenden sich wieder Microsoft zu, die ihre Programmsprachen ja teilweise
verschenken. Aber das haben wir ja schon eine Seite weiter oben bemerkt….)
Fassen wir zusammen:
151

Das .NET Framework ist gekennzeichnet durch:
• Konsequente Objektorientierung (im Gegensatz zu Delphi!)
• Plattformunabhängiges Softwarekomponentenmodell mit Laufzeitumgebung
und Klassenbibliothek
• Integration einer (transparenten) Verteilungsplattform
• Unabhängigkeit von einer Programmiersprache
• Weit mehr als 10 000 Datentypten (von denen Sie allenfalls 50 brauchen!)
Aufgabe 8
Lesen Sie sich den ausgezeichneten Artikel von Michael Stal (2001) zu .NET und C#
durch. Lassen Sie sich nicht entmutigen, wenn Sie nicht alles auf Anhieb verstehen!
Einen groben Überblick gekommen Sie durch die Lektüre in jedem Fall:
http://www.heise.de/ix/artikel/2001/12/122/
Da wir Kapitel 5 „Objekt-Orientierte Programmierung“ außer mit Delphi und Java an
geeigneter Stelle auch mit Visual C# durchführen, werden Sie auch später noch mit
.NET zu tun haben. Daher ist es kein Schaden, wenn Sie sich hier schon mit einer
Besonderheit vertraut machen:
Das Sicherheitskonzept von .NET ist sehr restriktiv. So es es zum Beispiel ohne die
Voreinstellungen zu ändern, nicht möglich, eine erstellte Release (exe-Datei) von
einem Netzlaufwerk aus durch Doppelklick zu starten. Daher der Tipp:
Arbeiten Sie in C# auf Laufwerk D:/ !!!
So finden Sie heraus welche Version
von .NET Framework auf einem
Windows XP System installiert ist:
• Klicken Sie auf Start, auf
Einstellungen und anschließend
auf Systemsteuerung.
• Doppelklicken Sie in der
klassischen Ansicht auf
Verwaltung.
Wenn Sie nach der anstrengenden Arbeit mal wieder so richtig lachen wollen, dann
klicken Sie folgenden Link an:
http://www.nickles.de/c/n/5645.htm
152

Visual C# 2005
Wenn man C# öffnet, sieht man eine „Begrüßungsseite“, die den unerfahrenen
Programmierer zunächst überfordert:
„Erste Schritte“ werden angezeigt, Neuigkeiten von Entwicklern von C# gilt es zu
bestaunen und schließlich und endlich soll man auch noch ein Feedback geben.
Lassen Sie die großen Fenster links liegen und wählen Sie statt dessen Datei /
Neues Projekt.
Damit am Anfang nicht zu viele Informationen auf Sie prasseln, wollen wir uns
zunächst mit einer Konsolenanwendung begnügen.
Geben Sie, wie hier im Bild auch, als Name HalloConsole1 ein.
Der Editor für den Quelltext ist
links zu sehen.
Auf der rechten Seite erkennt
man den Projektmappen-
Explorer:
153

Für ein Konsolenprogramm, bei dem bisher schlicht nichts passiert, ist das schon
eine Menge Information. Noch mehr wird es bei den Windows-Anwendungen.
Wählen Sie nun Datei / HalloConsole1 speichern unter und geben Sie einen Ordner
auf D: oder Ihrem USB-Stick an.
Schauen Sie sich danach die Dateien an, in denen eigentlich „nichts“ gespeichert ist!
Speichert man nicht ab, dann befinden sich die im Projektmappen-Explorer
angezeigten Dateien nur im RAM (Hauptspeicher), sind also lediglich temporär.
Die auch schon im Projektmappen-Explorer erkennbare relativ komplexe Hierarchie
muss Sie nicht interessieren. Sie ist größtenteils nur für die IDE da.......
Die entscheidende Projektdatei hat die Endung .sln
Wenn man auf sie doppeltklickt, wird das Projekt in C# geöffnet, ähnlich wie bei der
.dpr-Datei in Delphi.
Der Quelltext kommt in die
Program.cs-Datei (entspricht der
.pas-Datei = Unit in Delphi). Diese
kann man auch mit dem normalen
Windows-Editor öffnen.
Probieren Sie es aus!
Wo kommt eigentlich der eigene
Quelltext hin?
Richtig! Hier
dazwischen!
Schließen Sie den Windows-Editor noch nicht. Denn Sie brauchen Ihn für die
folgende
Aufgabe 9
Damit das Programm HalloConsole1 auch etwas tut, schreiben Sie folgenden
Programmcode zwischen die geschweiften Klammern.
string name;
Console.WriteLine("Wie heißen Sie?");
name = Console.ReadLine();
Console.WriteLine("Hallo, " + name + "!");
Einmal machen Sie das mit dem Windows-Editor und dann mit dem C# -Editor.
Wichtig für diese Übung ist, dass sie es selbst eintippen – und nicht etwa mit copy
und paste ans Werk gehen!
Was fällt Ihnen auf?
Die Hilfe in Visual C# 2005 ist fast schon perfekt zu nennen. Auch hier ein Beispiel:
Angenommen, Sie wollen einen Kommentar in den Quelltext schreiben und wissen
nicht wie das bei C# funktioniert.
Wählen Sie Hilfe / suchen und geben Sie in die Suchzeile Kommentar C# ein.
154

Zusätzlich lässt sich die Trefferliste geschickt durch so genannte Filter verkleinen.
Man erkennt sofort, dass es nicht eine Hifle gibt. Vielmehr werden mehrere Quellen
angeboten! (Siehe nächstes Bild rechts). Besonders fällt die sehr ausführliche
deutsche Online-Hilfe auf! Bereits hier sollte sich alles selbst für fortgeschrittene
Programmierer finden lassen.
Links im Bild unten ist ein ausgewähltes Ergebnis zu sehen.
Einfacher geht wirklich nicht!
Ausgesprochen hilfreich ist die bereits erwähnte IntelliSens .
In Aufgabe 9 konnten Sie testen, wie komfortabel die
Eingaben für den Quellcode dadurch werden.
Man muss meist nur ein bis zwei Buchstaben tippen, dann
hilft einem IntelliSens weiter.
Aber damit ist es nicht getan. Die gegebene Hilfe ist auch
kontext-sensitiv, was nichts anderes heißt, dass von den
vielen tausend Möglichkeiten mit .NET nur die sinnvoll
Möglichen gezeigt werden.
Mehr noch: In einem kleinen gelben Fenster werden
Erläuterungen zum gewählten Begriff angezeigt!
Im obigen Beispiel wurden nur die Buchstaben Co für
Console eingegeben.
Wählt man diese Option durch die Enter-Taste und gibt danach einen Punkt gefolgt
von den Buchstaben Wr ein, so wird eine weitere sehr wichtige Hilfe sichtbar:
155

Die gewünschte Funktion WriteLine besitzt eine Parameter-Liste. Das bedeutet, dass
der Funktion Werte übergeben werden und / oder dass sie welche erzeugt. Daher
wird bei Wahl der Option WriteLine gleich eine Klammer für die Parameter
mitgeliefert: WriteLine()
Im kleinen gelben Fenster werden die Arten der möglichen Parameter ebenfalls
angezeigt.
Wenn, wie im Bild unten, von 18 Überladungen geschrieben wird, so heißt dies
lediglich, dass von dieser Funktion 18 Varianten gibt, die den selben Namen haben,
sich aber durch Anzahl und Art der Parameter unterscheiden.
Gehen wir nun davon aus, dass Sie Aufgabe 9 korrekt durchgeführt haben. Dann
haben Sie auch bemerkt, dass der C# - Editor selbst auch schon gewisse Korrekturfunktionen
mit sich bringt: Syntaxfehler etwa werden sofort durch eine Schlangenlinie
gekennzeichnet:
Was ist hier falsch?
Wenn die fünf Zeilen, wie in Aufgabe 9 angegeben, korrekt eingetragen sind, dann
sollte man den Compiler laufen lassen. Wie in Delphi auch geht das mit dem kleinen
grünen Pfeil oder mit F5.
Der Compiler untersucht noch deutlich genauer als der Editor nach Ungereimtheiten
und zeigt eventuelle Fehler in einem weiteren Fenster unter dem Quellcode an.
Hat alles geklappt, dann erscheint die Konsole und tut
genau das, was sie soll.
Würde die letzte, anscheinend sinnlose Zeile fehlen,
dann müssten Sie schon sehr schnell schauen, um zu
sehen, ob die Begrüßung nach Plan verläuft.
So wartet die Anwendung auf eine erneute Eingabe.
Nach dieser verschwindet die Konsole wieder.
Selbstverständlich lässt sich auch ein C# -Code „entlausen“ (debuggen). Und das
geht noch deutlich komfortabler, als in Delphi 7:
Zunächst den Cursor in die Stopp-Zeile setzten. Einen Haltepunkt bekommt man mit
F9. Wie bei Delphi erscheint dann ein roter Punkt auf der linken Seite.
(Wir nehmen hier die Zeile: Console.WriteLine("Hallo, " + name + "!"); )
156

Nun mit F5 bis zum markierten Punkt compilieren lassen. In diesem Fall muss man
bevor es zum Haltepunkt geht, seinen Namen in die Konsole eingeben:
Die Variable name ist somit, wie nebenstehend zu
sehen, konkrekt belegt worden.
Mit F11 geht es jetzt im Einzelschrittmodus weiter
und der Compiler hält am roten Punkt.
Bewegen Sie den Cursor über name.
Wenn Sie einen Augenblick warten, ist ein kleines Popup-Fenster zu sehen. Hier
kann man den Variablen-Inhalt kontrollieren und zu Kontrollzwecken auch abändern.
Die Belegung der Variablen kann man ohne große Umstände im darunter liegenden
Fenster auslesen. Beachten Sie im nächsten Screenshot die Wirkung der Änderung
des Strings der Variablen name:
157

Wie Sie weiter oben schon gelernt haben, arbeitet .NET mit mehr als 10 000 Datentypen.
Da heißt es Ordnung halten! .NET verwendet daher das Konzept der
Namensräume. Dazu einige Erläuterungen, die sich auf unser kleines Programm
HalloConsole1 beziehen:
• using-Anweisungen verwendet man bei häufig vorkommenden
Namensräumen. using System erspart uns zum Beispiel, den dem
Namensraum System zugeordneten Datentyp Console immer seinen
Namensraum voranzustellen. Also statt System.Console.Readline() dürfen wir
bei Verwendung der Zeile using System einfach Console.Readline()
schreiben.
• Jede Anwendung bekommt ihren eigenen Namensraum. Je nach dem was Sie
eingegeben haben steht hinter namespace Console1 oä.
• Jede Anwendung bekommt eine Datentypdefinition (class program) und eine
Funktion namens Main() und bei Bedarf weitere Datentypendefinitionen mit
auf den Weg. Main() gibt den Start- und den Endpunkt des Programms an.
Name und Deklaration mit dem Teil static sind vorgeschrieben.
Vielleicht der einzige Kritikpunkt für Visual C#:
Für Namensräume dient der Punkt lediglich der besseren Lesbarkeit. System.Text
bedeutet also nicht, dass Text eine Untergruppe von Namensraum System ist!!
System.Text ist mitsamt dem Punkt der Name eines bestimmten Namensraumes.
Man kann den Punkt vermeiden, wenn man innerhalb des Namensraum System
einen weiteren Namensraum Text definiert.
Für Datentypen trennt der Punkt die Hierarchieebenen: System.Console ist kein
eigener Namensraum, sondern der Datentyp Console im Namensraum System!!
Für Methoden trennt der Punkt ebenfalls Hierarchieebenen: Console.ReadLine() ist
eine Methode von Console!
Alles klar?!?
Vermutlich nicht! Daher jetzt
Aufgabe 10
Lesen Sie aufmerksam den Wikipedia-Artikel (19.08.07) über Namensräume durch!
Namensraum (englisch namespace) ist ein Begriff aus der Informatik.
Ein Name identifiziert ein Objekt. Zur eindeutigen Zuordnung ist jedoch der
entsprechende Kontext – eben der Namensraum - zu beachten. Die Beschreibung
geschieht üblicherweise durch die "Punkt"-Notation. Neben der "Punkt"-Notation sind
aber auch andere Zeichen gebräuchlich, z. B. bei Dateinamen "\" oder "/". Einige
Namensräume (z. B. Dateisysteme) sind hierarchisch aufgebaut; d. h. Namensräume
können selbst wieder aus Namensräumen bestehen. Namensräume werden dazu
verwendet, Konflikte bei der Namensvergabe zu verhindern. Graphisch sind
Namensräume mit Bäumen äquivalent; d. h. Namensräume haben eine Wurzel
158

(einen festen, definierten Ausgangspunkt), Knoten (Verzeichnisse) und Blätter
(Objekte).
Die Idee von Namensräumen wird auch in anderen Bereichen unter anderen Namen
verwendet, z. B. in der Telefonie. Jeder Teilnehmer erhält eine individuelle
Rufnummer (z. B. 4711) und diese wird lokal vergeben. Das Telefonnetz ist hierbei in
Unternetze unterteilt, und die Identifikation erfolgt über die Vorwahl. Somit kann jede
Rufnummer mehrfach vergeben werden, sie muss nur innerhalb des Unternetzes
eindeutig sein. Bei einem Anruf im selben Vorwahlbereich reicht somit die Angabe
der Rufnummer 4711. Soll ein Teilnehmer aus dem Vorwahlbereich 0815 kontaktiert
werden, der ebenfalls die Rufnummer 4711 besitzt, so wählt man die 0815 vor. Durch
diese Technik können zwei Teilnehmer die gleiche Rufnummer 4711 besitzen. In
diesem Beispiel wäre die 0815 der Namensraum, 4711 der eigentliche Name, und
das Telefon das identifizierte Objekt.
Beim Erstellen von Programmen kann ein Autor unter Benutzung von
Namensräumen große Programmpakete mit vielen definierten Namen schreiben,
ohne sich Gedanken machen zu müssen, ob die neu eingeführten Namen in Konflikt
zu anderen Namen stehen. Im Unterschied zu der Situation ohne Namensräume wird
hier nicht der ganze Name neu eingeführt, sondern nur ein Teil des Namens, nämlich
der des Namensraumes.
Ein Namensraum ist ein deklaratorischer Bereich, der einen zusätzlichen
Bezeichner an jeden Namen anheftet, der darin deklariert wurde. Dieser
zusätzliche Bezeichner macht es weniger wahrscheinlich, dass ein Namenskonflikt
auftritt mit Namen, die anderswo im Programm deklariert wurden. Es ist möglich, den
gleichen Namen in unterschiedlichen Namensräumen ohne Konflikt zu verwenden,
auch wenn der gleiche Name in der gleichen Übersetzungseinheit vorkommt.
Solange er in unterschiedlichen Namensräumen erscheint, ist jeder Name eindeutig
aufgrund des zugefügten Namensraumbezeichners.
Ein weiteres Beispiel:
Der Namensraum System besitzt zum Beispiel den Datentyp Math. Dieser besitzt
recht viele mathematische Funktionen. Um zu erfahren, welche genau das sind,
können Sie wieder die IntelliSens verwenden. Am besten erzeugen Sie dazu eine
neue Consolenanwendung.
Geben Sie folgende Zeile ein:
Console.WriteLine(Math.
Sobald Sie beim Punkt angekommen sind, sollte es wie folgt aussehen:
159

Das gelbe Fenster zeigt 19 mögliche Parameter für Console.WriteLine() an.
Im weißen Fenster darüber werden die mathematischen Funktionen aufgezählt.
Aufgabe 11
Erstellen Sie eine neue Consolen-Anwendung ConsoleRechnen1 und testen Sie
damit einige Rechnungen.
Beispiel:
Bei Delphiprogrammen landet nach der Compilierung eine exe-Datei im Programmodner,
die man unter Windows auch ohne Delphi starten kann.
Bei Visual C# ist das auch nicht viel anders. Allerdings sollte man
wissen, dass bei Compilation mit F5 (falls keine Fehler da sind) eine
exe-Datei unter bin\Debug zu finden ist. Um eine endgültige Fassung in
den Release-Ordner zu bekommen, muss man mit F6 compilieren. Das Programm
wird dann aber nicht gestartet.
Nun aber zur grafischen Windows-Programmierung:
Wir wählen:
Windows-
Anwendung.
Falls man keine
Namensänderungen
vornimmt und die
„Toolbox“ links mit
dem „Reißnagel“
fixiert, dann sieht der
obere Teil der IDE
(Integrierte
Entwicklungsebene)
so aus:
160

Links sind von Windows XP bekannte Steuerelemente
angebracht. Man zieht sie wie in Delphi einfach auf das
Formular daneben.
Das Fenster rechts oben entspricht in etwa dem
Projektmanager und zeigt alle Teile des Projekts „Hallo Welt“
an.
Darunter (und auch rechts vergrößert) sehen Sie das
Eigenschaften-Fenster der jeweiligen Komponenten. (In
Delphi war das der Objektinspektor). Wenn das Fenster
nicht zu sehen ist, führt man
einen Rechtsklick auf der
gewünschten Komponente
aus und das Fenster
erscheint.
Wenn Sie in der Leiste oben
das „Blitz“-Icon anklicken,
dann sind die zugehörigen
Ereignisse zu sehen.
Oberhalb des Formulars ist
ein Tab namens Form1.cs* zu
erkennen. Hier wird, wie in
der Unit bei Delphi der
Quelltext geschrieben. Wie
üblich wurden hier alle Teile, die C# selbst geschrieben hat, fett gedruckt. Da bleibt
für unser „Hallo Welt“- Programm nicht mehr viel zu tun:
161

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void label2_Click(object sender, EventArgs e)
{
}
}
}
private void button1_Click(object sender, EventArgs e)
{
label1.Text = "Hallo Welt!";
label2.Text = "Alles wie in Delphi, oder?!";
}
Auch in C# gelten die gleichen Grundregeln wie für Delphi:
• Ändern Sie nichts, was C# geschrieben hat!
• Erstellen Sie zuerst einen Ordner und speichern Sie das Projekt mit
Datei/Alle speichern ab!
• Wenn Sie die Arbeit am Projekt beendenen wollen, dann wählen Sie Datei /
Projektmappe schließen.
Wie weiter oben erwähnt, beruhen alle Programme bei imperativen Programmiersprachen
auf drei Techniken. Etwas überspitzt formuliert: Beherrschen sie die drei
genannten Techniken, dann können Sie programmieren. Und das sind die drei:
• Anweisungen
• Schleifen
• Verzweigungen
Natürlich gibt es für jede von ihnen verschiedene Varianten. In C# beispielsweise gibt
es for-, while und do-Schleifen. Das ändert aber nichts daran, dass die Idee immer
die gleiche bleibt: Das mehrfache Durchlaufen eines Programmsegements.
162

Anweisungen haben Sie bereits kennengelernt. (z.B.: label1.Text = "Hallo Welt!";)
Daher jetzt zunächst zu
Schleifen
Ein Schleife braucht man, wenn viele Male der gleiche Programmcode zu
durchlaufen ist. In Mathematik (Klasse 11, 12, 13) werden Folgen und Grenzwerte
behandelt.
Ein Beispiel:
1 1 1
f ( n)
= 1+
+ +… +
2 2
2
2 3 n
Ist zum Beispiel n = 30, so muss die Schleife 30 mal durchlaufen werden. Bei jedem
Druchlauf kommt ein Summand zur bisherigen Summe hinzu. Wir realisieren dies
durch eine for-Schleife:
Ein Doppelklick auf den Button öffnet den Editor und man kann dann den
Programmcode für das „button1_Click“- Ereignis eingeben:
Die oberste Zeile hat der Editor beim Doppelklick selbst geschrieben. Man benötigt
zunächst zwei Variable: Die Summe s und die Grenze n.
Den „Rahmen“ für die for-Schleife muss man nicht selbst erstellen. Vielmehr wählt
man durch einen Rechtsklick die Option Ausschnitt einfügen / Visual C# .
163

In der sich öffnenden Listbox wählt man den gewünschten Code. Meist muss man
dann noch den Code an die vorliegenden Situation anpassen:
Hier ist die Variable length durch n + 1 und
i = 0 duch i = 1 zu ersetzten.
Aufgabe 12
• Was besagt die einzelenen Elemente im Kopf der for-Schleife?
• Wie kann der Programmcode zwischen den geschweiften Klammern
aussehen?
• Weshalb ergibt der Code s = s + 1 / (i * i); als Gesamtsumme immer nur 1 ?
(Kontrollieren Sie durch einen geeigneten Haltepunkt die Speicherinhalte!)
Eine mögliche Lösung:
Testen Sie das Programm!
Vermuten Sie einen Grenzwert?
(n < 1 000 000 000 – sonst
warten Sie eventuell recht lange!)
Der Wertetyp Int64 hat keinen
eigenen Bezeichner in C#.
Man muss ihn daher mit dem
Bezeichner aus .NET aufrufen -
erkennbar am großen Anfangsbuchstaben. Es wäre sicher günstiger gewesen, für n
und i nur den Wertetyp int (von -2.147.483.648 bis 2.147.483.647) zu wählen. Sie
können das ruhig mal testen: Das Programm wird etwas schneller. Kein Wunder: Für
Int64 ( von -9.223.372.036.854.775.808 bis +9.223.372.036.854.775.808 ) müssen,
wie der Name schon sagt, 64 Bit im RAM reserviert werden. Wählen Sie allerdings
dann ein n, das größer ist, als 2.147.483.647, dann passiert etwas merkwürdiges....
164

Die for-Schleifen sind Zählschleifen. Das Verfahren ist immer dann praktisch, wenn
es etwas zu zählen gibt. Manchmal weiß man aber im Voraus gar nicht, wie oft eine
Schleife zu durchlaufen ist. Eine Abbruchbedingung wäre dann wünschenswert:
Durchlaufe die Schleife solange bis diese oder jene Bedingung erfüllt ist.
Die while-Schleife erfüllt genau diesen Zweck!
Als Beispiel soll eine sehr seltsame Folge aus dem Mathematikunterricht herhalten:
f ( n)
= r ⋅ f ( n)
⋅ (1 − f ( n))
; f ( 0) = 0, 5
Für r wählt man zum Beispiel zunächst 2,8.
Aufgabe 13
Berechnen Sie von Hand die nächsten 5 Folgenglieder!
Zugegeben: Das ist ziemlich mühsam! Vor allem müsste man deutlich mehr, als 5
Folgenglieder berechnen, um zu erkennen, worauf die Sache hinausläuft! Leider
kann man ja f(100) nicht berechnen, ohne f(99) zu kennen.....
Machen wir es kurz! Erstellen Sie folgendes Formular:
Soviele Folgenglieder (n) sollen
berechnet und ausgegeben
werden.
Das Ergebnis der Folgenglieder
hängt offensichtlich sehr stark von
der Wahl von r (Textbox links) ab.
Das Textfeld zur Linken ist eine
ListBox.
Ihre wichtigste Eigenschaft ist
Items. Dem konkreten Objekt
listBox1 kann man durch
listBox1.Items.Add() Text
anhängen.
So kann der Programmcode
aussehen:
165

Aufgabe 14
Versuchen Sie den Code nachzuvollziehen und tragen sie ihn in das button1_Click-
Ereignis ein. Wenn Sie eine andere Idee haben: Ausprobieren!
Erstellen Sie eine eigene Folge und prüfen Sie mit einer Variation des obigen
Programms, ob sie konvergent ist (konvergent = hat einen Grenzwert).
Verzweigungen
Nun fehlt als letzter Grundbaustein lediglich die Verzweigung. Führt man sie mit if
…else aus, dann muss man sich an folgende Syntax halten:
if (Bedingung erfüllte)
{
//Anweisungsblock
}
else
{
//Anweisungsblock
}
Testen wir die neu gelernte Thematik durch Erweiterung des obigen Beispiels:
• Das Programm soll stoppen und eine Warnung ausgeben, wenn einer der
TextBoxes leer ist.
• Es sollen nur die letzten s (int) Folgenglieder ausgegeben werden.
• Durch einen Menueintrag soll der Eintrag in der ListBox gelöscht werden
können.
166

So kann das Formular aussehen:
Das Menu-Steuerelement bekommen
Sie durch MenuStrip (siehe oben).
Wenn das neue Steuerelement auf
dem Formular untergebracht ist, kann
man direkt die einzelnen Menu- und
Untermenu-Texte eintragen.
Durch Doppelklick auf einen Eintrag,
wie Liste löschen, geht ein Fenster im
Editor auf und der Rahmen für das
listeLöschenToolStripMenuItem_Click
Ereignis kann programmiert werden.
Suchen Sie im Programmcode unten
die betreffenden Stellen und sehen Sie
sich die Anweisungen zwischen den
geschweiften Klammern an.
Den Vergleichsoperator oder muss
man mit zwei senkrechten Strichen
schreiben: || . Tastenkombination
AltGr + < >-Taste.
private void button1_Click(object sender, EventArgs e)
{
if ((textBox1.Text=="")||(textBox2.Text=="")||(textBox3.Text=="")||(textBox4.Text==""))
{
label2.Text = "Bitte alle Felder ausfüllen!";
}
else
{
Int64 n = Convert.ToInt64(textBox1.Text);
int s = Convert.ToInt32(textBox4.Text); //Angezeigt werden die letzten s Elemente
double r = Convert.ToDouble(textBox2.Text);
double summe_alt = Convert.ToDouble(textBox3.Text);
double summe_neu = 0; Int64 i = 0;
while (i

summe_alt = summe_neu;
i++;
if ((n - i) < s)
{
listBox1.Items.Add(Convert.ToString(summe_neu));
}
}
}
}
private void listeLöschenToolStripMenuItem_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
}
}
private void beendenToolStripMenuItem_Click(object sender, EventArgs e)
{
Application.Exit();
}
Hinweis:
Das Programm wird im Unterricht entwickelt. Denken und schreiben Sie mit. Beim
bloßen Kopieren lernen Sie nichts!
Auch wenn Sie das Skript im Selbststudium durcharbeiten, sollten Sie den
Programmcode selbst schreiben!
Durch die erste if-Abfrage wird verhindert, dass das Programm abstürzt, wenn eine
Textbox leer bleibt. Gegen sinnlose Eingaben, wie n = Hallo, ist das Programm so
allerdings noch nicht geschützt! Dies kann man mit dem try-catch – Block erledigen:
try
{
//Programmcode
}
catch
{
//Bei einer „Ausnahme“ (= „Absturz“) im obigen Programm
//werden alle Speicher freigegeben und man landet hier!
//z.B.:
label1.Text = „Das Programm wäre abgestürzt!“
}
Aufgabe 15
Sichern Sie das obige Programm durch einen try-catch-Block ab!
168

Der obige Screenshot stammt vom Programm „Feigenbaum“ (Tauschverzeichnis).
Auf der x-Achse sind die verschiedenen r-Werte aufgetragen, auf der y-Achse die
Werte der Folge ab dem Folgenelement f(100). Man erkennt, dass für Werte
unterhalb von r = 3 ein Grenzwert existiert. Zwischen r = 3 und r = 3,4 alterniert die
Folge zwischen genau zwei Werten. Danach wird es komplizierter! Um das Verhalten
der Folge genauer zu studieren, kann man im Programm mit der Maustaste in das
Bild zoomen. Das obige Rechteck sieht dann vergrößert so aus:
169

Die Vergrößerungen sehen dem ursprünglichen Bild sehr ähnlich. Man spricht dann
von Selbstähnlichkeit. Sie ist eine wesentliche Eigenschaft von Fraktalen. Zoomt
man noch weiter in das Bild, so erkennt man, dass immer wieder Bereiche existieren,
in denen die Folge nur zwischen wenigen Werten alterniert. Testen Sie
beispielsweise r = 3,5829 mit Ihrem C#-Programm!
170

In Delphi haben Sie bereits ein Programm geschrieben, das überprüft, ob eine
eingegebene natürlich Zahl eine Primzahl ist. Wir verwenden hier den gleichen
Algorithmus. Auf diese Weise können Sie die erlernten Techniken in C# nochmals
etwas vertiefen.
Hier der Quelltext für die button1_Click- Routine.
Sie werden unschwer die Parallelen zu Java und Delphi erkennen!
private void button1_Click(object sender, EventArgs e)
{
string s1 = textBox1.Text;
Int64 zahl = Convert.ToInt64(s1);
label1.Text = "";
if (zahl == 1)
label1.Text = "Die Zahl ist keine Primzahl!";
else
{
if (zahl == 2)
label1.Text = "Die Zahl ist eine Primzahl!";
else
{
if (zahl % 2 == 0)
label1.Text = "Die Zahl ist keine Primzahl!";
else
{
long i = 1;
if (zahl > 2)
{
do
{
i = i + 2;
} while ((zahl % i != 0) & (i*i < zahl));
}
if (i*i > zahl)
else
label1.Text = "Die Zahl ist eine Primzahl!";
label1.Text = "Die Zahl ist keine Primzahl!";
}
}
}
}
171

Das zugehörige Formular kann so aussehen:
(Wer will kann sich das fertige Programm aus dem
Tauschverzeichnis holen!)
Der Einfachheit halber wurde oben auf die an sich
nötige Behandlung der Format-Exception
verzichtet. Nötig ist sie deshalb, weil sonst für
Zahlen wie 32,5 sinnlose Aussagen über prim
oder nicht prim gemacht werden.
Und hier nochmals das Abfangen eines Fehlers:
private void button1_Click(object sender, EventArgs e)
{
string s1 = textBox1.Text;
try
{
Int64 zahl = Convert.ToInt64(s1);
…................................................……..............
}
catch (FormatException) { label1.Text = "Das war keine natürliche Zahl!! "; }
}
}
}
Aufgabe 16
Da nur die Übung den Programmier-Meister macht, erstellen Sie nun mit Hilfe des
obigen Quelltextes und der Visual C# -Hilfe ein Programm zur Bestimmung der
Lösung quadratischer Gleichungen (vergleiche Aufgabe 3).
Tipp:
Es gibt eine Seite von Microsoft, die alle Programmierer ansprechen soll, die mit C#
ein Spiel programmieren wollen. Es gibt dort Tutorials und halb fertige
Programmcodes, so dass man ohne Probleme recht schnell zu eigenen
Programmcode kommt :
http://www.microsoft.com/germany/msdn/coding4fun/antme/default.mspx
172