C Sharp Shortcut - Programmieren im .NET-Framework mit der C Sharp Beta 2

296 Pages·2016·3.2 MB·English

by  Committee on End Points for Spent Nuclear Fuel and High-Level Radioactive Waste in Russia and the Un, Lorenz Patrick A

Patrick A. Lorenz
C# Shortcut
Programmierung im .NET Framework
mit der C# Beta 2
Der Autor
Patrick A. Lorenz
Projektleiter Internet, combit GmbH, Konstanz, www.combit.net
http://www.hanser.de
Alle in diesem Buch enthaltenen Informationen wurden nach bestem Wissen zusammengestellt
und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind
die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie
irgendeiner Art verbunden. Autor und Verlag übernehmen infolgedessen keine Verantwortung
und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der
Benutzung dieser Informationen – oder Teilen davon – entsteht, auch nicht für die Verletzung von
Patentrechten, die daraus resultieren können.
Ebenso wenig übernehmen Autor und Verlag die Gewähr dafür, dass die beschriebenen Verfahren
usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen,
Warenbezeichnungen usw. in diesem Werk berechtigt also auch ohne besondere Kennzeichnung nicht
zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung
als frei zu betrachten wären und daher von jedermann benutzt werden dürften.
Die Deutsche Bibliothek – CIP-Einheitsaufnahme
Ein Titeldatensatz für diese Publikation
ist bei Der Deutschen Bibliothek erhältlich.
Dieses Werk ist urheberrechtlich geschützt.
Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches,
oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des
Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren), auch nicht für
Zwecke der Unterrichtsgestaltung, reproduziert oder unter Verwendung elektronischer Systeme
verarbeitet, vervielfältigt oder verbreitet werden.
© 2002 Carl Hanser Verlag München Wien
Gesamtlektorat: Fernando Schneider
Copy-editing: Manfred Sommer, München
Herstellung: Monika Kraus
Umschlaggestaltung: Büro für Text und Gestaltung herbert und herbertsfrau, Augsburg
Datenbelichtung, Druck und Bindung: Kösel, Kempten
Printed in Germany
ISBN 3-446-21959-5
Inhalt
1 Einführung............................................................................................................... 13
1.1 Wer sollte dieses Buch lesen? ................................................................................... 13
1.2 Was Sie brauchen ...................................................................................................... 14
1.3 Warum eine neue Sprache? ....................................................................................... 14
1.4 Das .NET Framework................................................................................................ 15
1.4.1 Installation der Beta 2.................................................................................. 16
1.5 Die Beispiele aus dem Buch...................................................................................... 18
1.5.1 Beispiele kompilieren .................................................................................. 18
1.5.2 Editoren ....................................................................................................... 18
1.6 Kontakt zum Autor.................................................................................................... 22
2 Erste Schritte in C# ................................................................................................. 25
2.1 Notation..................................................................................................................... 25
2.2 GROSS oder klein? ................................................................................................... 26
2.3 Variablen................................................................................................................... 27
2.4 Konstanten ................................................................................................................ 28
2.5 Einfache Datentypen ................................................................................................. 28
2.6 Einfache Datentyp-Konvertierung............................................................................. 29
2.7 Kommentare.............................................................................................................. 30
2.8 Namespaces............................................................................................................... 30
2.9 Konsolen-Applikationen ........................................................................................... 33
2.10 Die Methode Main .................................................................................................... 34
2.11 Hallo Welt ................................................................................................................. 35
3 Klassen & objektorientierte Programmierung – Teil I ........................................ 39
3.1 Was ist ein Objekt? ................................................................................................... 39
3.2 Was ist eine Klasse?.................................................................................................. 40
3.3 Instanziierung einer Klasse........................................................................................ 41
3.4 Terminierung eines Objekts ...................................................................................... 42
3.5 Deklaration einer neuen Klasse ................................................................................. 43
6 _________________________________________________________________ Inhalt
3.5.1 Dynamisch versus statisch........................................................................... 46
3.5.2 Eigenschaften deklarieren............................................................................ 48
3.5.3 Methoden deklarieren .................................................................................. 53
3.5.4 Ereignisse deklarieren.................................................................................. 56
3.5.5 Das Schlüsselwort this................................................................................. 62
3.5.6 Modifikatoren.............................................................................................. 63
3.5.7 Konstruktor.................................................................................................. 67
3.5.8 Destruktor.................................................................................................... 72
3.5.9 Attribute ...................................................................................................... 74
4 Bedingungen ............................................................................................................ 79
4.1 Das if-Konstrukt........................................................................................................ 79
4.2 Das switch-Konstrukt................................................................................................ 82
4.3 Bedingungsoperator .................................................................................................. 86
5 Schleifen ................................................................................................................... 89
5.1 Die for-Schleife ......................................................................................................... 89
5.2 Die while-Schleife..................................................................................................... 91
5.3 Die do-Schleife ......................................................................................................... 92
5.4 Die foreach..in-Schleife............................................................................................. 92
5.5 Die Anweisungen break und continue....................................................................... 94
6 Sprunganweisungen ................................................................................................ 99
6.1 break.......................................................................................................................... 99
6.2 continue..................................................................................................................... 99
6.3 goto ......................................................................................................................... 100
6.4 return....................................................................................................................... 101
6.5 throw ....................................................................................................................... 102
7 Operatoren............................................................................................................. 105
7.1 Mathematische Standard-Operatoren ...................................................................... 105
7.2 Mathematische Kurz-Operatoren ............................................................................ 108
7.3 Zuweisungsoperatoren ............................................................................................ 110
7.4 Noch mehr Mathematik mit der Klasse System.Math ............................................. 112
7.5 Logische Operatoren ............................................................................................... 115
7.5.1 Vergleichsoperatoren................................................................................. 115
7.5.2 Verknüpfungsoperatoren ........................................................................... 116
7.5.3 Negationsoperator...................................................................................... 118
7.5.4 Bitweise (binäre) Operatoren..................................................................... 118
7.6 Typenoperatoren ..................................................................................................... 123
Inhalt _________________________________________________________________ 7
7.6.1 typeof......................................................................................................... 123
7.6.2 is ................................................................................................................ 126
7.6.3 as................................................................................................................ 127
7.6.4 is versus as................................................................................................. 128
8 Arbeiten mit Zeichenketten .................................................................................. 131
8.1 Der Datentyp string ................................................................................................. 131
8.1.1 Einfache Zuweisungen............................................................................... 131
8.1.2 Escape-Zeichen.......................................................................................... 132
8.1.3 Formatierungen.......................................................................................... 134
8.1.4 String-Eigenschaften ................................................................................. 136
8.1.5 Weitere String-Operationen....................................................................... 138
8.2 Die Klasse StringBuilder......................................................................................... 148
8.2.1 StringBuilder-Eigenschaften...................................................................... 149
8.2.2 StringBuilder-Methoden ............................................................................ 150
8.3 Reguläre Ausdrücke ................................................................................................ 152
8.3.1 Der Aufbau von regulären Ausdrücken ..................................................... 153
8.3.2 Die Klasse Regex....................................................................................... 157
8.3.3 Die Regex-Optionen .................................................................................. 164
8.3.4 Erweiterte Parsing-Möglichkeiten ............................................................. 166
9 Erweiterte Datentypen .......................................................................................... 171
9.1 Arrays...................................................................................................................... 171
9.1.1 Initialisierung und Zugriff auf Arrays........................................................ 171
9.1.2 Mehrdimensionale Arrays ......................................................................... 174
9.1.3 Eigenschaften und Methoden der Array-Klasse ........................................ 177
9.2 Collections .............................................................................................................. 181
9.2.1 ArrayList ................................................................................................... 182
9.2.2 Hashtable ................................................................................................... 183
9.2.3 Queue ........................................................................................................ 185
9.2.4 SortedList .................................................................................................. 187
9.2.5 Stack .......................................................................................................... 188
9.3 Strukturen................................................................................................................ 189
9.4 Aufzählungen .......................................................................................................... 192
9.4.1 Standard-Aufzählungen ............................................................................. 192
9.4.2 Flag-Aufzählungen .................................................................................... 194
10 Konvertierungen.................................................................................................... 199
10.1 Konvertierung von numerischen Werten................................................................. 199
10.2 Konvertierung zu string........................................................................................... 201
8 _________________________________________________________________ Inhalt
10.3 Konvertierung von Verweistypen............................................................................ 204
10.4 Die Klasse Convert ................................................................................................. 209
11 Fehlerbehandlung ................................................................................................. 217
11.1 Was ist eine Ausnahme? ......................................................................................... 217
11.2 Das try..catch..finally-Konstrukt ............................................................................. 219
11.3 Die Klasse Exception .............................................................................................. 223
11.4 Ausnahmen auslösen............................................................................................... 225
11.5 Ausnahmen (kontrolliert) weiterreichen.................................................................. 228
11.6 Eigene Ausnahmen definieren................................................................................. 230
11.7 Zusammenfassung................................................................................................... 234
12 Klassen & objektorientierte Programmierung – Teil II..................................... 237
12.1 Überladungen .......................................................................................................... 237
12.2 Vererbung ............................................................................................................... 241
12.2.1 Einfache Vererbungen ............................................................................... 242
12.2.2 Überschreiben von Klassen-Mitgliedern ................................................... 244
12.2.3 Verbergen von Klassen-Mitgliedern.......................................................... 247
12.2.4 Konstruktoren und die Vererbung ............................................................. 248
12.2.5 Klassen versiegeln ..................................................................................... 252
12.2.6 Abstrakte Klassen...................................................................................... 253
12.3 Schnittstellen ........................................................................................................... 256
12.3.1 Deklaration einer Schnittstelle................................................................... 256
12.3.2 Implementierung einer Schnittstelle .......................................................... 257
12.3.3 Noch ein tierisches Beispiel....................................................................... 257
12.3.4 Mehrere gleichnamige Schnittstellen-Mitglieder....................................... 261
12.4 Benutzerdefinierte Operatoren erstellen .................................................................. 262
12.4.1 Arithmetische Operatoren.......................................................................... 262
12.4.2 Vergleichsoperatoren................................................................................. 266
12.4.3 Konvertierungsoperatoren ......................................................................... 270
13 Weitergehende Programmierung......................................................................... 277
13.1 Arbeiten mit Threads............................................................................................... 277
13.2 Reflections .............................................................................................................. 281
13.2.1 Eine Eigenschaft dynamisch abfragen ....................................................... 281
13.2.2 Eine Methode dynamisch aufrufen ............................................................ 282
13.2.3 Eine Methode mit Parametern dynamisch aufrufen................................... 283
13.2.4 Alle Eigenschaften und Methoden auflisten .............................................. 284
13.3 Arbeiten mit dem CodeDOM.................................................................................. 286
13.3.1 Ein Programm dynamisch erstellen ........................................................... 286
Vorwort
Eigentlich hatte ich gar nicht vor, mich derart intensiv mit C# zu beschäftigen. Das
Thema war ursprünglich ein anderes. Doch wie jeder, der sich mit dem .NET
Framework beschäftigt, bin auch ich nicht um die neue Sprache C#
herumgekommen. Was also anfänglich nur als eine grobe Übersicht geplant war,
hat sich sehr schnell zu einer ausführlichen Einführung in das Flaggschiff der .NET-
Sprachen entwickelt. Ich bin mit dieser Entwicklung durchaus zufrieden, denn ohne
diesen Ausflug würden Sie heute nicht das erste deutschsprachige Buch zur .NET
und zur C# Beta 2 in den Händen halten.
C# ist eine völlig neue Sprache, die mit dem ungeheuren Potenzial eines
Weltkonzerns daherkommt. Das erlebt man nicht alle Tage, und ich persönlich habe
die Entwicklung und die teilweise heftigen Diskussionen der vergangenen knapp 12
Monate mit Interesse und Spannung verfolgt. Wer als Windows-Entwickler am Ball
der Zeit bleiben will, wird sich mit .NET und C# auseinandersetzen müssen. Und
wenn diese neue Vision von Microsoft Ihr Berufsleben nicht heute beeinflusst, dann
sicherlich morgen.
C# vereint die herausragenden Merkmale der aktuellen Microsoft Pro-
grammiersprachen Visual C++ und Visual Basic. Die Kombination dieser
beiden Sprachen in Verbindung mit einem standardisierten Klassen-Framework ist
sinnvoll und wird es Ihnen als Entwickler leichter machen, Anwendungen für
verschiedene Umgebungen wie Desktop, Internet oder gar mobile Systeme zu
entwickeln. Auch die Arbeit im Team wird letztlich durch das Zusammenrücken
der Sprachen viel einfacher und effektiver.
Wenn Sie dieses Buch gekauft haben, dann sind Sie vermutlich oder hoffentlich an
einer ganz neuen Sprache interessiert. Eine Sprache mit dem Potenzial, andere
Sprachen vielleicht nicht völlig, zumindest aber in den Hauptbereichen der
Entwicklung zu verdrängen. Sie tun daher gut daran, sich mit diesem Buch einen
Überblick zu verschaffen. Wenn Sie bereits mit Sprachen wie C, C++ oder Java
gearbeitet haben, wird Ihnen jedenfalls die Syntax bekannt vorkommen. Dennoch
gibt es viel Neues zu lesen und zu lernen. Die Kenntnisse verschiedener Konzepte
um .NET sind zum Verständnis der Sprache einfach unerlässlich.
10 _____________________________________________________________ Vorwort
Dieses Buch soll sowohl erfahrenen Entwicklern als auch Einsteigern mit eher
geringen Programmiererfahrungen ein kompakter, aber dennoch umfassender
Einstieg in die Sprache C# sein. Ich habe mich bemüht, alle wesentlichen Aspekte
klar gegliedert zusammenzufassen. Die vielen Beispiele, die auf der bucheigenen
Website zum Download zur Verfügung stehen, vereinfachen den praktischen
Einstieg in die Sprache. Die sprachorientierte Gliederung ermöglicht zudem die
Verwendung als Nachschlagewerk und Referenz, wann immer Sie bei der Arbeit
Unterstützung benötigen.
Sie halten mit diesem Buch mein Erstlingswerk in den Händen. Es ist mir daher
sehr wichtig, Ihre Meinung zu hören. Nehmen Sie dieses Angebot bitte wahr und
schreiben Sie mir, wann immer Sie etwas zu diesem Buch loswerden möchten. Die
E-Mail-Adresse sowie die URL der bereits angesprochenen Website finden Sie in
der Einführung weiter unten. Ein zweites Buch, das sich ebenfalls mit dem
Themenkomplex .NET auseinandersetzt, ist übrigens bereits in Arbeit und wird
voraussichtlich Anfang 2002 nach dem Release von .NET erscheinen. Weitere
Informationen hierzu finden Sie zu gegebener Zeit ebenfalls auf der Website zum
Buch.
Ich möchte an dieser Stelle nicht versäumen, einige Dankesworte an diejenigen zu
richten, die dieses Projekt ermöglicht haben. Mein Dank gilt meinem Lektor
Fernando Schneider, der mich quasi entdeckt und vom Fleck weg engagiert hat. Er
ist an die Zusammenarbeit sicherlich nicht blauäugig, aber doch mit sehr viel
Vertrauen herangegangen und hat dafür meinen Respekt verdient. Ich möchte auch
meinem Arbeitgeber, der combit GmbH, danken, dass Sie es mir ermöglicht haben,
neben meiner regulären Arbeit an diesem Buch zu werkeln. Einen besonderen Dank
und einen lieben Gruß möchte ich an meine Familie richten. Neben meiner Mutter
und meinen Großeltern sind es nicht zuletzt auch meine Katzen Filou und Shari, die
mich motiviert und inspiriert haben. Sie werden im Laufe des Buches verstehen,
was ich meine. Viele Grüße übrigens auch an Mr. Jingles; die Cineasten unter Ihnen
wissen, wen ich meine.
Es bleibt mir, Ihnen viel Spaß an der Lektüre dieses Buches und viel Erfolg bei der
Arbeit mit .NET und C# zu wünschen.
Patrick A. Lorenz
Konstanz, im Oktober 2001