Programmieren in C#: Von den ersten Gehversuchen bis zu den Sieben-Meilen-Stiefeln

331 Pages·2004·14.415 MB·German

by  Dr. rer. nat. habil. Jörg Witte (auth.)

Jorg Witte
Programmieren in C#
Jorg Witte
Programmieren in C#
Von den ersten Gehversuchen bis
zu den Sieben-Meilen-Stiefeln
Teubner
B. G. Teubner Stuttgart· Leipzig· Wiesbaden
Bibliografische Information der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliographie;
detaillierte bibliografische Daten sind im Internet Ober <http://dnb.ddb.de> abrufbar.
Dr. rer. nat. habil. Jorg Witte
Geboren 1957 in Frankfurt am Main. Studium der Mathematik und Physik an der FU-Berlin. 1988
Diplom in Mathematik. 1991 Promotion und 1997 Habilitation. 1988 - 1993 wissenschaftlicher
Mitarbeiter der FU-Berlin. 1988 -1992 Vorlesungen vor Informatikstudenten an der Technischen Fach
hochschule Berlin. ab 1993 Vorlesungen an der FU-Berlin. 1998 Forschungs-und Lehraufenthalt an der
Middle East Technical University. Ankara. ab 2000 Dozent fOr Programmiersprachen in der beruflichen
Fortbildung.
1. Auflage Juli 2004
Aile Rechte vorbehalten
© B. G. Teubner Verlag / GWV Fachverlage GmbH. Wiesbaden 2004
Der B. G. Teubner Verlag ist ein Unternehmen von Springer Science+Business Media.
www.teubner.de
Das Werk einschlieBlich aller seinerTeile ist urheberrechtlich geschOtzt. Jede Verwertung
auBerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Ver
lags unzulassig und strafbar. Das gilt insbesondere fOr Vervielfaltigungen. Obersetzun
gen. Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen
Systemen.
Die Wiedergabe von Gebrauchsnamen. Handelsnamen. Warenbezeichnungen usw. in diesem Werk
berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme. dass solche Namen im Sinne
der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten waren und daher von
jedermann benutzt werden dOrften.
Umschlaggestaltung: Ulrike Weigel. www.CorporateDesignGroup.de
Gedruckt auf saurefreiem und chlorfrei gebleichtem Papier.
ISBN-13:978-3-519-00471-4 e-ISBN-13:978-3-322-80073-2
DOl: 10.1007/978-3-322-80073-2
Vorwort
Dieses Buch ist aus einer Vorlesung entstanden, die ich im Sommersemester 2003 an der FU
Berlin gehalten habe. Es flossen auch Erfahrungen ein, die ich als Dozent in der beruflichen
Weiterbildung sammeln konnte. Die Studenten und Lehrgangsteilnebmer besaBen keine Vor
kenntnisse in der Programmiersprache C# und nur zum Teil Kenntnisse in einer anderen Pro
grammiersprache. Auch an den Leser werden keine Voraussetzungen gestellt. Lediglich die
Fiihigkeit zum logischen und abstrakten Denken solIte er mitbringen. Mit einer Portion ge
sunden Menschenverstand sowie Interesse kann der Leser sehr tief in die Materie eindringen.
Dieses Buch unterscheidet sich daher von vielen anderen Biichern iiber Programmierspra
chen. Nicht selten wird der unbedarfte Leser mit einem iiber tausendseitigen Werk erschlagen,
das eher filr Experten gescbrieben ist. Aber wie wird man ein Fachmann filr eine Program
miersprache?
Programmieren ist auch eine Fertigkeit, die nicht nur theoretisch gelernt werden kann. Ein
Musikinstrument zu spielen, lernt man auch nicht ausschlieBlich in der Notenschule, sondern
durch regelm1iBiges Dben. Dem Schiller muss aber auch gezeigt werden, wie er das machen
solI. Eine Fiihigkeit muss vorgefiibrt werden, so dass sie nachgeahmt werden kann.
Daher wird hier der Sachverhalt an vielen Beispielen verdeutlicht. Durch erganzende Dbun
gen erhiilt der Leser die Moglichkeit, das Erlernte auszuprobieren. Es w!ire aber zu kurz ge
griffen, das Erlernen einer Programmiersprache ausschlieBlich als den Erwerb eines hand
werklichen Geschicks anzusehen. SchlieBlich ist eine Programmiersprache eine Sprache, mit
der Informationen ausgedriickt werden konnen. Es konnen sehr komplexe Datenstrukturen
und Operationen auf ihnen dargestelIt werden. Ein fundiertes theoretisches Riistzeug ist uner
liisslich. 1m Gegensatz zu einigen Biichern filr Einsteiger werden hier keine Kochrezepte
vorgestelIt, die es nur mechanisch, ohne Sinn und Verstand anzuwenden gilt.
Eine Sprache - insbesondere eine Programmiersprache - besteht neben ihren Wortern aus
einer Vielzahl von Regeln, wie die Worter zu verwenden sind. Eine Programmiersprache
besitzt sowohl vorgegebene Worter als auch die Moglichkeit, Bezeichner selbst zu definieren.
Es ist sogar moglich, eigene Verwendungsregeln zu definieren. All dieses sollte aber durch
dacht geschehen. Daher wird auch ein grundlegendes Verstlindnis vermittelt. Zusammenhiinge
und Anwendungsmoglichkeiten der sprachlichen Ausdrucksmittel werden dargestellt.
Der Leser solIte durch die LektUre in die Lage versetzt werden, die sprachlichen Mittel und
Programmiertechniken selbst zu beurteilen und einzuordnen. Auch Beziige zu den auBer-
6 Vorwort
sprachlichen Anforderungen an ein Programm herzustellen, geMrt zu den Kompetenzen, die
der Leser sich aneignen kann.
Berlin, Marz 2004 Jl>rg Witte
7
Inhaltsverzeichnis
Vorwort ............................................................................................................. 5
Inhaltsverzeichnis .............................................................................................. 7
1 EinfUhrung in die objektorientierte Programmierung ............................. 11
2 Warum eine neue Programmiersprache? ................................................ 15
3 Ein erstes Beispielprogramm .................................................................. 17
4 Darstellung von Daten ............................................................................ 23
4.1 Grundlagen ...................................................................................... 23
4.2 Hexadezimalsystem ......................................................................... 23
4.3 Wert- und Verweistypen ................................................................. 24
5 Das NET-Framework .............................................................................. 26
5.1 Intermediate Language .................................................................... 26
5.2 Die Standardklassenbibliothek ........................................................ 27
6 Vordefinierte Datentypen ........................................................................ 28
6.1 Grundlagen ...................................................................................... 28
6.1.1 Der logischeTyp ...................................................................... 31
6.1.2 Der Zeichentyp ........................................................................ 31
6.1.3 Die Ganzzahltypen .................................................................. 31
6.1.4 Die Gleitkommazahlen ........................................................... 32
6.1.5 Dezimale ................................................................................. 32
6.1.6 Strings ..................................................................................... 32
6.1.7 Die Klasse obj ect ................................................................ 33
6.1.8 Konstanten .............................................................................. 34
6.1.9 Darstellung von Werten durch Bytezustande .......................... 34
6.2 Typenkonvertierung ........................................................................ 35
7 Arrays ...................................................................................................... 39
8 Operationen und Ausdriicke .................................................................... 47
8.1 Arithmetische Operatoren .............................................................. .48
8.2 Vergleichsoperatoren ...................................................................... 49
8.3 Logische Operatoren ....................................................................... 50
8.4 Bitweise Operatoren ........................................................................ 52
8.5 Zuweisungsoperatoren .................................................................... 54
8.6 Sonstige Operatoren ........................................................................ 55
8.6.1 Der Type-Cast-Operator.. ........................................................ 55
8 Inhaltsverzeichnis
8.6.2 Der Fragezeichenoperator ....................................................... 55
8.6.3 Vorrangregeln und Assoziativitat ........................................... 56
8.6.4 Ausdrucksanweisungen ........................................................... 57
9 Statische Methoden und Variablen ......................................................... 59
10 Programmsteuerung ............................................................................ 67
10.1 Verzweigungen ............................................................................... 67
10.2 Schleife n ......................................................................................... 77
10 .2.1 Grundlagen .............................................................................. 77
10.2.2 Die for-Schleife ....................................................................... 77
10.2.3 Die while-Schleife .................................................................. 80
10.2.4 Die do-Schleife ....................................................................... 82
10.3 Die Befehle break und continue .......................................... 83
11 Klassen und Objekte ........................................................................... 87
11.1 Definition und Verwendungsweise ................................................. 87
11.2 Instanzmethoden ............................................................................. 90
11.3 ParameterUbergabe als Wert oder Verweis ..................................... 93
11.4 Params-Parameter ........................................................................... 96
11.5 Lebensdauer und Sichtbarkeit von Variablen ................................. 97
11.6 Uberladen von Methoden ................................................................ 99
11.7 Uberladen von Operatoren ............................................................ 101
11.8 Konstruktoren ............................................................................... 103
11.9 ZerstOren von Objekten ................................................................. 109
12 Vererbung ......................................................................................... 113
12.1 Einfiihrung .................................................................................... 113
12.2 Ableiten einer Klasse .................................................................... 113
12.3 ~onvertierungen zwischen Basis-und abgeleiteten Klassen ........ 119
12.4 Uberlagem von Methoden ............................................................ 123
12.4.1 Polymorphie .......................................................................... 123
12.4.2 Virtuelle Methoden ............................................................... 124
12.4.3 Abstrakte Methoden .............................................................. 127
12.4.4 Versteckte Methoden ............................................................ 129
12.4.5 Versiegelte Methoden und Klassen ...................................... 132
13 Eigenschaften und Indexer. ............................................................... 134
13.1 Eigenschaften ................................................................................ 134
13.2 Indexer .......................................................................................... 137
14 Interfaces ........................................................................................... 139
14.1 Grundlagen .................................................................................... 139
14.2 Definition ...................................................................................... 142
14.3 Verwendung .................................................................................. 143
9
14.4 Polymorphie .................................................................................. 151
14.5 Explizite Implementation .............................................................. 157
14.6 Ableiten von Interfaces ................................................................. 158
15 Geschachtelte Klassen ....................................................................... 160
15.1 Grundlagen .................................................................................... 160
15.2 Innere Klassen ............................................................................... 164
15.3 Innere Klassen mit einem Interface ............................................... 16 7
16 Exceptions ......................................................................................... 170
16.1 Grundlagen .................................................................................... 170
16.2 Ausnahmehandlung ....................................................................... 170
16.3 Die Klasse System. Exception ....................................................... 180
16.4 Das Werfen von Ausnahmen ........................................................ 181
16.5 Die SchlUsselworter checked und unchecked ............................... 183
17 Strukturen, Enumerationen und Boxing ............................................ 185
17.1 Strukturen ...................................................................................... 185
17.2 Enumerationen .............................................................................. 188
17.3 Boxing ........................................................................................... 191
18 Streams und Dateioperationen .......................................................... 193
18.1 Einfiihrung .................................................................................... 193
18.2 Die Klasse Stream ......................................................................... 194
18.3 Die Klasse FileStream ................................................................... 197
18.4 Die Klassen TextWriterund Streamwriter .................................... 201
18.5 Die Klassen TextReader und StreamReader ................................. 207
18.6 Die Klasse FileInfo und DirectoryInfo ......................................... 210
18.7 Die Klassen BinaryReader und BinaryWriter ............................... 217
18.8 Die Klassen BufferedStream und MemoryStream ........................ 220
19 Attribute ............................................................................................ 226
19.1 Metadaten ...................................................................................... 226
19.2 Verwendung von Attributen .......................................................... 228
20 Delegaten und Ereignisse .................................................................. 233
20.1 Einfiihrung und Motivation ........................................................... 233
20.2 Definition und Verwendungsweise eines Delegaten ..................... 238
20.3 Ereignisse ...................................................................................... 250
21 GrundzUge der Windowsprogrammierung ........................................ 259
21.1 Einfiihrung in graphische Benutzeroberflachen und
Windowsanwendungen ............................................................................. 259
21.2 Ereignissteuerung .......................................................................... 263
21.3 Graphische Steuerelemente ........................................................... 266
21.4 Modale Dialogfenster .................................................................... 271
10 Inhaltsverzeichnis
21.5 Mentis ............................................................................................ 282
21.6 Maus- und Tastaturereignisse ....................................................... 286
21.7 Die Ereignisse Load und Paint und die Klasse Graphics .. 299
21.8 Benutzerdefinierte Steuerelemente ............................................... 317
22 Vergleich mit den Sprachen c++ und Java. ...................................... 325
23 Stichwortverzeichnis ......................................................................... 328
11
1 Einffihrung in die objektorientierte Programmie
rung
Ein Computerprogramm wird hiiufig als eine Menge von Anweisungen beschrieben. Obwohl
diese Charakterisierung sicher nicht hinreichend ist - ein Kochbuch konnte man ebenso be
schreiben -, vermittelt sie doch ein anflingliches Verstlindnis. Durch die Anweisungen sol1en
Daten verarbeitet werden. Ein Informatikstudent besucht daher im Grundstudium stets die
Vorlesung ,,Datenstrukturen und Algorithmen". Unter einem Algorithmus versteht man die
schrittweise und prllzise Anleitung zur Losung eines Problems. Bekannt sind beispielsweise
diverse Sortieralgorithmen. Sie konnen etwa dazu verwendet werden, die Eintriige einer Ad
ressendatei in alphabetischer Reihenfolge der Namen zu sortieren.
Durch Software sollen gewisse Aufgaben, etwa betriebswirtschaftliche oder naturwissen
schaftliche, technische Aufgaben, gelost werden. Ein nicht unerheblicher Anteil der Software
entwicklung besteht daher in der moglichst exakten Beschreibung der Aufgaben, die eine
Software bewiiltigen sol1. Dazu bedient man sich einer Sprache. I. A. verwendet man dabei -
eventue11 auch nur im ersten Anlauf - die Umgangssprache. Diese ist nicht immer sehr ein
deutig. Die Bedeutung sprachlicher AuBerungen hangt oft von dem Zusammenhang abo Zu
ibm ziihlen auch auBersprachliche Umstlinde sowie das Vorverstlindnis der an einem Gesprach
beteiligten Personen. Hier liegen nicht zu unterschiitzende Fehlerque11en der Softwareent
wicklung. Zu den Aufgaben miissen Losungsstrategien entwickelt werden, die dann letztlich
in einer Programmiersprache formuliert werden. Hier liegen weitere Fehlerque11en.
Durch eine Programmiersprache soll eine Maschine gesteuert werden, die nur die Symbole 0
und 1 "versteht". In den Anflingen der Programmierung wurden Programme in der Tat mit
nur diesen beiden Symbolen geschrieben. Man bediente sich dabei bestenfalls einiger Abkiir
zungen, die jeweils fUr eine Sequenz von Nullen und Einsen steht. Sprachen, die aus solchen
AbkOrzungen bestehen, nennt man Assembler. Assemblercode ist nicht nur sehr schwer nach
zuvollziehen, sondem komplexe und umfangreiche Software ist mit ibm kaum zu erste11en.
Es wurden daher die Hochsprachen entwickelt, die erst in Maschinencode iibersetzt werden
miissen. Programme, die dieses leisten, nennt man Compiler.
Die objektorientierten Programmiersprachen kommen menschlichem konzeptione11en Denken
am Niichsten. Die Losung einer Aufgabe durch ein Computerprogramm ist aus dieser Sicht
weniger fehleranfiillig. Der Ubergang von der umgangssprachlichen Beschreibung einer Auf
gabe zu der Darste11ung ihrer Bearbeitung in einer Programmiersprache ist nicht nur einfacher
und eleganter, sondem es konnen auch zunehmend komplexere Aufgaben gemeistert werden.
Das menschliche Denken bedient sich Begriffe, zwischen denen in der Sprache Beziehungen
ausgedriickt werden. Dabei werden - mehr oder weniger scharf - Objekte des Denkens oder