OReilly c sharp in a nutshell dec 2002 ISBN 3897212994 pdf

299_titelei.fm Seite i Mittwoch, 20. November 2002 9:44 09

C#
IN A NUTSHELL


299_titelei.fm Seite ii Mittwoch, 20. November 2002 9:44 09


299_titelei.fm Seite iii Mittwoch, 20. November 2002 9:44 09

C#

IN A NUTSHELL

Peter Drayton, Ben Albahari & Ted Neward

Deutsche Übersetzung von
Dorothea Reder & Jürgen Key

Beijing · Cambridge · Farnham · Köln · Paris · Sebastopol · Taipei · Tokyo


299_titelei.fm Seite iv Mittwoch, 20. November 2002 9:44 09

Die Informationen in diesem Buch wurden mit größter Sorgfalt aufbereitet.
Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und
Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für
eventuell verbliebene Fehler und deren Folgen.
Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind
möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im wesentlichen nach

den Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung,
Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
Kommentare und Fragen können Sie gerne an uns richten:
O’Reilly Verlag
Balthasarstr. 81
50670 Köln
Tel.: 0221/9731600
Fax: 0221/9731608
E-Mail:
Copyright der deutschen Ausgabe:
© 2003 by O’Reilly Verlag GmbH & Co. KG
Die Originalausgabe erschien 2002 unter dem Titel
C# in a Nutshell im Verlag O’Reilly & Associates, Inc.

Die Darstellung eines Jungfernkranichs im Zusammenhang
mit dem Thema C# ist ein Warenzeichen von O’Reilly & Associates, Inc.
Microsoft, .NET, Visual Basic .NET, Visual Studio .NET und Windows
sind geschützte Warenzeichen der Microsoft Corporation.

Bibliografische Information Der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der
Deutschen Nationalbibliografie; detailierte bibliografische Daten
sind im Internet über abrufbar.

Übersetzung und deutsche Bearbeitung: Dorothea Reder, Bornheim & Jürgen Key, Ilmenau
Lektorat: Alexandra Follenius & Lars Schulten, Köln
Korrektorat: Friederike Daenecke, Zülpich
Fachgutachten: Uwe Komoss, Kaarst, Christian Pogea, Ulm & Sven Riedel, Clausthal
Satz: Frank Wassen, reemers publishing services, Krefeld; www.reemers.de
Umschlaggestaltung: Emma Colby, Pam Spremulli & Melanie Wang, Boston

Produktion: Geesche Kieckbusch, Köln
Belichtung, Druck und buchbinderische Verarbeitung:
Druckerei Kösel, Kempten; www.koeselbuch.de
ISBN 3-89721-299-4
Dieses Buch ist auf 100% chlorfrei gebleichtem Papier gedruckt.


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Inhalt

Vorwort .

xiii

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Teil I: Programmieren mit C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1: Einführung in C# und das .NET Framework

. . .
Die Programmiersprache C# . . . . . . . . . . . . . . . . . . . . . . . . .
Das .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ECMA-Standardisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2: Grundlagen von C#

. . .
Das erste C#-Programm . . . . . .

Bezeichner und Schlüsselwörter
Grundlegendes zu den Typen . .
Werttypen und Referenztypen .
Vordefinierte Typen . . . . . . . .
Arrays . . . . . . . . . . . . . . . . .
Variablen und Parameter . . . . .
Ausdrücke und Operatoren . . .
Anweisungen. . . . . . . . . . . . .
Namensräume . . . . . . . . . . . .

3: Typ-Erzeugung in C#
Klassen. . . . . . . . . .
Vererbung. . . . . . . .
Zugriffsmodifikatoren
Structs . . . . . . . . . .
Interfaces . . . . . . . .
Enums . . . . . . . . . .

Inhalt

.
.
.
.
.
.

.
.
.

.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

. 3
. 4
. 7
11

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

14

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.

.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.

.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.

.
.

49

14
15
16
19
25
30
32
35
38
46

49
60
67
68
69
72

v


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

4: Fortgeschrittene C#-Features .

Delegates. . . . . . . . . . . . . . . . .
Delegates versus Funktionszeiger .
Delegates versus Interfaces . . . . .
Events . . . . . . . . . . . . . . . . . . .
Operatoren überladen . . . . . . . .
Try-Anweisungen und Exceptions
Attribute . . . . . . . . . . . . . . . . .
Unsicherer Code und Zeiger . . . .
Präprozessordirektiven . . . . . . . .
XML-Dokumentation . . . . . . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

75
.
.
.
.
.
.
.
.
.
.

75
77
77
77
80

83
87
89
92
93

Teil II: Programmieren mit dem .NET Framework . . . . . 101
5: Überblick über die Framework Class Library .
Kerntypen . . . . . . . . . . . . . . . . . . . .
Text . . . . . . . . . . . . . . . . . . . . . . . .
Collections . . . . . . . . . . . . . . . . . . . .
Streams und I/O . . . . . . . . . . . . . . . .
Netzwerk-Programmierung . . . . . . . . .
Threads . . . . . . . . . . . . . . . . . . . . . .
Sicherheit. . . . . . . . . . . . . . . . . . . . .
Reflection und Metadaten . . . . . . . . . .
Assemblies . . . . . . . . . . . . . . . . . . . .
Serialisierung . . . . . . . . . . . . . . . . . .
Remoting . . . . . . . . . . . . . . . . . . . . .
Web Services . . . . . . . . . . . . . . . . . .
Datenzugriff . . . . . . . . . . . . . . . . . . .
XML . . . . . . . . . . . . . . . . . . . . . . . .
Grafik . . . . . . . . . . . . . . . . . . . . . . .
Rich Client-Anwendungen . . . . . . . . .
Web-basierte Anwendungen . . . . . . . .
Lokalisierung (Globalization). . . . . . . .
Konfiguration . . . . . . . . . . . . . . . . . .
Advanced Component Services . . . . . .
Diagnose und Debugging . . . . . . . . . .
Zusammenarbeit mit unmanaged Code .

Compiler- und Werkzeugunterstützung .
Einrichten der Laufzeitumgebung . . . . .
Native Betriebssystemfähigkeiten . . . . .
Undokumentierte Typen. . . . . . . . . . .

6: String-Verarbeitung .

. . . . . . .
Die Klasse String . . . . . . . . . . . . . . .
Die Klasse StringBuilder . . . . . . . . . .
Unterstützung für reguläre Ausdrücke .
Grundlagen regulärer Ausdrücke . . . .

vi

.
.
.
.
.

103

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.

103
104
104
104
105
105
105
106
106
106
107
107
108
108
108
108
109
109
110
110
110
110
111
111
111
112

113

113
116
116
118

Inhalt


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Prozedurale und ausdrucksbasierte Muster . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Kochbuch für reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

7: Collections .

. . . . . . . . . . .
Iterieren über Collections. . . . .
Standard-Collection-Interfaces .
Vordefinierte Collection-Klassen
Ordnen von Instanzen. . . . . . .
Erzeugen von Hash-Werten . . .

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.

.
.
.
.

.
.
.
.
.
.

126

.
.
.
.
.
.

.
.
.
.
.
.

.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.

.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.

.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.

. . . . . . . . . . . . . . . . . . . . .
Zugriff auf XML-Dokumente . . . . . . . . . . .
Parsen eines XML-Streams . . . . . . . . . . . .
Knoten mit XPath auswählen . . . . . . . . . .
Transformieren eines Dokuments mit XSLT .

.
.

.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.

.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.

.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.

.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.

.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.

.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.

.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

. . . . . . . . . . . . . . . . . . . . . .
Was ist Serialisierung? . . . . . . . . . . . . . . . . . . . . .
Unterstützung der Serialisierung im .NET Framework
Explizite Serialisierung . . . . . . . . . . . . . . . . . . . .
Implizite Serialisierung . . . . . . . . . . . . . . . . . . . .
[Serializable] . . . . . . . . . . . . . . . . . . . . . . . . . . .
[NonSerialized]. . . . . . . . . . . . . . . . . . . . . . . . . .
IDeserializationCallback . . . . . . . . . . . . . . . . . . .
ISerializable. . . . . . . . . . . . . . . . . . . . . . . . . . . .
[Serializable] und ISerializable . . . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

8: XML-I/O .

9: Netzwerk-Programmierung

. . . .
Programmiermodelle für Netzwerke . . . . .
Request/Response-Architektur . . . . . . . . .
HTTP-spezifische Unterstützung . . . . . . . .
WebClient . . . . . . . . . . . . . . . . . . . . . . .
Hinzufügen neuer Protokoll-Handler . . . . .

Die Benutzung von TCP, UDP und Sockets .
Die Benutzung des DNS. . . . . . . . . . . . . .

10: Streams und I/O

. . . .
Streams und Speichermedien
Kapseln roher Streams. . . . .
Verzeichnisse und Dateien . .
Isolierter Speicher. . . . . . . .

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.

.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.

.
.
.
.

.
.
.
.
.

11: Serialisierung .

12: Assemblies .

. . . . . . . . . . . . . . . . . . . .
Elemente einer Assembly . . . . . . . . . . . . . .
Assemblies und Module . . . . . . . . . . . . . . .
Sichtbarkeit von Typen und Typ-Referenzen .
Benennen und Signieren von Assemblies . . .

Inhalt

.
.
.
.
.

.

.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

126

131
132
135
137

139
.
.
.
.

139
143
143
146

149
.
.
.
.
.
.
.

149
149
150
151
151

152
153

154
.
.
.
.

154
156
158
162

165
.
.
.
.
.
.
.
.
.

165
166
166
167
168

169
169
170
171

175
.
.
.
.

175
176
176
177

vii


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Auflösen und Laden von Assemblies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Deployment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Rechte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

13: Reflection

. . . . . . . . . . . . . . . . . . . .
Typ-Hierarchie . . . . . . . . . . . . . . . . . . .

Typen, Member und eingebettete Typen . .
Den Typ einer Instanz ermitteln . . . . . . . .
Direkter Zugriff auf einen Typ . . . . . . . . .
Reflection über eine Typ-Hierarchie . . . . .
Späte Bindung . . . . . . . . . . . . . . . . . . .
Fortgeschrittene Benutzung von Reflection.
Erzeugung neuer Typen zur Laufzeit . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

. . . . . . . . . .
Sprachunterstützung . . . . . . . . . . . . . . . . . . . . . .
Compiler-Unterstützung . . . . . . . . . . . . . . . . . . . .

Laufzeitunterstützung . . . . . . . . . . . . . . . . . . . . . .
Vordefinierte Attribute . . . . . . . . . . . . . . . . . . . . .
Definieren eines neuen benutzerdefinierten Attributs .
Abfragen eines benutzerdefinierten Typs zur Laufzeit.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.

.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.

14: Benutzerdefinierte Attribute

15: Speichermanagement

. . .
Der Garbage Collector . . . . . . . .
Optimierungstechniken . . . . . . .
Finalizer . . . . . . . . . . . . . . . . .
Die Methoden Dispose und Close.

182

183
184
184
185
186
188
189

191
191
192
192
193
195
196

198

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

. 203
. . 203
. . 206
. . 207

. .
Aufrufe in DLLs . . . . . . . . . . . . . . .
Das Marshaling einfacher Typen. . . .
Marshaling von Klassen und Structs .
In- und Out-Marshaling . . . . . . . . .
Callbacks von unmanaged Code. . . .
Simulieren einer C-Union . . . . . . . .
Structs auf ein Binär-Format abbilden
Vordefinierte Attribute für DLLs . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
Binden von COM- und C#-Objekten . . . . . . . . . . .
COM-Objekte für C# zur Verfügung stellen. . . . . . .
C#-Objekte für COM zur Verfügung stellen. . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

. 220
. . 220
. . 220
. . 221

16: Threads .

. . . . . . . . . .
Thread-Synchronisierung .
Verbreitete Thread-Typen .
Asynchrone Delegates . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.

.

.
.
.
.

17: Integration nativer DLLs

18: Integration von COM-Komponenten .

viii

182

.
.
.
.
.
.
.
.
.

198
199
200
201

209
.
.
.
.
.
.
.
.

209
210
211
212
212
213
215
216

Inhalt


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

COM-Abbildung in C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Attribute für die Zusammenarbeit mit COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Unterstützung von COM+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

19: Diagnose .

. . . . . . . . . . . . . . . . . . .
Unterstützung für Logging und Assertions .
Bedingte Kompilierung . . . . . . . . . . . . .
Debugger-Integration . . . . . . . . . . . . . .
Prozesse, Threads und Stacks . . . . . . . . .
Event-Logs . . . . . . . . . . . . . . . . . . . . .
Performance-Counter . . . . . . . . . . . . . .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.

.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.

.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.

.
.
.
.
.
.

226
.
.
.
.
.
.

.
.
.
.
.
.

226
228
229
230
232
235

Teil III: Sprach- und Tool-Referenz . . . . . . . . . . . . . . . . . . . . . . 239

20: C#-Sprachreferenz .

21: Referenz zu XML-Dokumentations-Tags
.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.

.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

23: C#-Entwicklungswerkzeuge

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

249

. . . . . . . . . . . . . . . . . .

22: Namens- und Programmierkonventionen in C# .
Groß-/Kleinschreibung
Mechanismen . . . . . .
Wortwahl . . . . . . . . .
Namensräume . . . . . .

241

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.

.
.
.

.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.

.
.
.
.
.

.
.
.
.
.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

253
.
.
.
.

.
.
.
.

253
255
256

257

259

Teil IV: API-Schnellreferenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
24: So verwenden Sie diese Schnellreferenz .

. . . . . . . . . . . . . . . . . . 297
Finden eines Eintrages in der Schnellreferenz . . . . . . . . . . . . . . . . . . . . . . . . . . 297
Wie Sie einen Eintrag der Schnellreferenz lesen sollten . . . . . . . . . . . . . . . . . . . . 298

25: Microsoft.Win32
26: System

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

303

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

313

27: System.Collections .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .

436

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

445

28: System.Collections.Specialized
29: System.Diagnostics

Inhalt

419

ix


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

30: System.Globalization .
31: System.IO

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

487

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

508

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

538

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

544

32: System.IO.IsolatedStorage.
33: System.Net

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

575

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

589

34: System.Net.Sockets
35: System.Reflection

36: System.Reflection.Emit

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .

661

. . . . . . . . . . . . . . . . . . . . . . . . . . .

690

37: System.Runtime.InteropServices .
38: System.Runtime.Serialization .

. . . . . . . . . . . . . . . . .

702

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

707

39: System.Runtime.Serialization.Formatters
40: System.Text.

. . . . . . . . . . . . . . . . . . . . . . . . .

715

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

723

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

743

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

746

41: System.Text.RegularExpressions .
42: System.Threading .
43: System.Timers .
44: System.Xml.

630

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

784

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

792

45: System.Xml.XPath
46: System.Xml.Xsl

Teil V: Anhänge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 797
A: Reguläre Ausdrücke .
B: Formatangaben

x

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

799

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

804

Inhalt


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

C: Marshaling von Daten .
D: Schlüsselwörter in C# .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

810

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

812

E: Namensräume und Assemblies
F:

. . . . . . . . . . . . . . . . . . . . . . . . . .

Index zu den Typen, Methoden,
Eigenschaften, Events und Feldern .

Index

Inhalt

817

. . . . . . . . . . . . . . . . . . . . . .

823

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

873

xi


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Vorwort
Dieses Buch ist eine Schnellreferenz zu der neuen Programmiersprache C# von Microsoft. Es
soll neben dem Computer und auf Reisen Ihr treuer Begleiter sein und Sie beim Programmieren unterstützen. Die erste Version von C# wurde nach einer umfangreichen Beta-Testphase
im Januar 2002 als Teil von Visual Studio .NET und des .NET Framework veröffentlicht.
C# in a Nutshell ist in vier Teile (und sechs Anhänge) aufgeteilt. Teil I ist eine Einführung in
die Programmiersprache C# und die .NET Common Language Runtime (CLR). Ohne
Umschweife werden Sie schnell mit der Programmiersprache C# vertraut gemacht, angefangen
bei ihren Datentypen bis hin zu allen Anweisungen und Features, die diese moderne, komponentenorientierte Sprache auszeichnen.
In Teil II sehen Sie, wie Sie C# zusammen mit den wichtigsten Klassen der .NET Framework

Class Library (FCL) einsetzen, um eine Reihe von häufigen Programmieraufgaben zu lösen,
von der String-Verarbeitung bis hin zur Interaktion mit Legacy-COM-Komponenten. Teil III
enthält einige nützliche Referenzen, darunter eine Zusammenfassung der Syntax von C#, die
in der speziell für dieses Buch und C# Essentials entwickelten Notation vorgestellt wird, sowie
eine Referenz zu nützlichen Kommandozeilen-Tools, die mit Visual Studio .NET und dem
.NET Framework mitgeliefert werden.
Teil IV ist eine Schnellreferenz zu den 21 wichtigsten Namensräumen der FCL und ihren mehr
als 700 Typen, komplett mit Namensraum-Karten, Typbeschreibungen, Member-Signaturen
und nützlichen Querverweisen und Kommentaren. Überdies bietet dieses Buch einen Index
zu Klassen und Methoden, in dem Sie den Typ zu einem bestimmten Member oder den
Namensraum zu einem bestimmten Typ nachschlagen können.

Zielgruppe dieses Buches
Wenn Sie als C#-Programmierer tätig sind, dann gehört C# in a Nutshell unabhängig von
Ihrem gegenwärtigen Erfahrungsstand auf jeden Fall in Ihre Referenzbibliothek. Die gründliche Beschreibung der Sprachelemente, die kompakte Sprach- und Tool-Referenz und der ein-

Vorwort

xiii


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

zigartige, prall gefüllte Leitfaden durch die Core-APIs der FCL helfen Ihnen, mühelos Antworten auf die meisten Fragen zu Syntax und Funktionalität zu finden, denen Sie bei Ihrer Arbeit
begegnen werden.
Wenn Sie bereits Erfahrung in der Programmierung mit Java, C++ oder Visual Basic haben,
aber zum erstenmal mit C# und der CLR zu tun haben, hilft Ihnen dieses Buch, die Grundlagen
von C# rasch zu meistern. Unerfahrene Programmierer sollten jedoch vorher ein Einführungsbuch lesen, z.B. Programmieren mit C# von Jesse Liberty (erschienen im O’Reilly Verlag).

Inhalt dieses Buches
In den Teilen I, II und III dieses Buches werden C#, die .NET CLR und wichtige Tools
beschrieben, die mit dem SDK zum .NET Framework heruntergeladen werden. Teil I, Programmieren mit C#, ist eine Einführung in die Programmiersprache C# und das .NET Framework:
Kapitel 1, Einführung in C# und das .NET Framework
Kapitel 1 gibt einen Überblick über die Programmiersprache C# und das .NET Framework mit besonderem Schwerpunkt auf den wichtigsten Features und Vorteilen dieser
Technologien.
Kapitel 2, Grundlagen von C#
In diesem Kapitel werden die Elemente der Programmiersprache C# eingeführt, darunter
die Datentypen und elementare Konstrukte wie z.B. Ausdrücke und Anweisungen. Im
gesamten Kapitel wird eine Spezialnotation verwendet, um die Syntaxregeln von C# so
zusammenzufassen, daß sie später leicht nachgeschlagen werden können.
Kapitel 3, Typ-Erzeugung in C#
In Kapitel 3 wird beschrieben, wie Sie in C# neue Typen definieren und instantiieren. In
C# sind alle Klassen zugleich Komponenten, die sowohl den ausführbaren Code als auch
die Metadaten verkörpern, die von der CLR zur Laufzeit verwendet werden.
Kapitel 4, Fortgeschrittene C#-Features
Dieses Kapitel erläutert Features von C#, die für die Behandlung von Events und Exceptions, Callbacks, benutzerdefinierten Attributen und anderem mehr zuständig sind.
Der Teil II, Programmieren mit dem .NET Framework, behandelt folgende Themen:
Kapitel 5, Überblick über die Framework Class Library
Kapitel 5 gibt einen Überblick über die Kern-APIs des .NET Framework, soweit sie in diesem Buch behandelt werden. Die APIs selbst werden in Teil IV beschrieben. Im vorliegenden Kapitel wird zusammengefaßt, welche Unterstützung die einzelnen funktionalen
Bereiche der FCL bieten. Außerdem sind hier die Namensräume aufgelistet, zu denen die
jeweiligen Typen gehören.
Kapitel 6, String-Verarbeitung
In diesem Kapitel werden die Typen der FCL beschrieben, die für die String-Verarbeitung
am wichtigsten sind, und es wird gezeigt, wie Sie diese Typen in C# einsetzen. Die FCL
stellt eine breite Palette von Features für die fortgeschrittene String-Verarbeitung zur Verfügung. Außerdem werden die FCL-Typen für das Suchen und Ersetzen mit regulären
Ausdrücken erklärt, die auf den regulären Ausdrücken von Perl 5 beruhen.

xiv

Vorwort


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Kapitel 7, Collections
Kapitel 7 stellt die wichtigsten FCL-Typen für die Arbeit mit gebräuchlichen Datenstrukturen wie Arrays, Hashtables, Wörterbüchern, Stacks und dergleichen vor. Außerdem werden wichtige Collection-Interfaces wie IEnumerable, ICollection und IComparable beschrieben.
Kapitel 8, XML-I/O
In diesem Kapitel wird die integrierte XML-Unterstützung der FCL beschrieben, die
Zusammenhänge zwischen XML und dem I/O-System im allgemeinen erklärt, die Nutzung und Erstellung von XML-Dokumenten in knotenbasierten und Infoset-basierten
Formularen behandelt sowie der Einsatz von XPath erläutert und XSLT vorgestellt.
Kapitel 9, Netzwerk-Programmierung
Die FCL enthält eine Reihe von Typen, die den Zugriff auf Netzwerkressourcen vereinfachen. Kapitel 9 beschreibt den Kern der FCL-Netzwerkunterstützung und gibt eine Vielzahl von Beispielen für die Nutzung der vordefinierten Klassen.
Kapitel 10, Streams und I/O
Dieses Kapitel führt in die integrierte FCL-Unterstützung für die Behandlung von Streams
und I/O ein, erklärt die Zusammenhänge zwischen den abstrakten und konkreten Klassen der Stream-Architektur, zeigt, wie diese Klassen eingesetzt werden, und erläutert die
spezifische Unterstützung für bestimmte Dateisysteme.
Kapitel 11, Serialisierung
Kapitel 11 gibt eine Einführung in die integrierte Unterstützung für Objektserialisierung
und -deserialisierung und zeigt, wie Clients und Objekte an dem Prozeß der Serialisierung und Deserialisierung teilnehmen können.
Kapitel 12, Assemblies
Dieses Kapitel erklärt die Konfiguration und Nutzung von Assemblies, der grundlegenden Einheit für die Weitergabe von Anwendungen in .NET. Ebenfalls erläutert werden
die FCL-Attribute und -Typen zur Verwaltung von Assemblies.
Kapitel 13, Reflection
Kapitel 13 beschreibt die wichtigsten FCL-Typen zur Untersuchung der Metadaten vorhandener Typen mit Hilfe von Reflection. Die Erstellung neuer Typen (und der damit
verbundenen Metadaten) nennt sich Reflection.Emit und wird mit den Typen aus dem
Namensraum System.Reflection.Emit vorgenommen, der ebenfalls in diesem Kapitel
behandelt wird.
Kapitel 14, Benutzerdefinierte Attribute

Typen, Member, Module und Assemblies haben allesamt Metadaten, die von allen wichtigen CLR-Diensten genutzt werden. Diese Metadaten gelten als integraler Bestandteil
einer Anwendung und lassen sich mittels Reflection (siehe Kapitel 13, Reflection)
betrachten. Dieses Kapitel erklärt, wie Sie Anwendungselementen benutzerdefinierte
Metadaten hinzufügen, indem Sie eigene Attribute entwerfen.
Kapitel 15, Speichermanagement
Das .NET Framework bietet eine automatische Garbage Collection für Typen, die nicht
mehr benutzt werden, und ermöglicht es den Programmierern, über C#-Destruktoren
auch eigene Finalizer zur Verfügung zu stellen. Außerdem zeigt dieses Kapitel, wie Sie
mit Dispose()- oder Close()-Methoden hinter einem Objekt aufräumen, dessen Arbeit
beendet ist.

Vorwort

xv


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Kapitel 16, Threads
Kapitel 16 erklärt die Verwendung der FCL-Typen zur Verwaltung von AnwendungsThreads. In C# gibt es eine lock-Anweisung, mit der Sie den Zugriff auf gemeinsame Ressourcen synchronisieren; und in der FCL gibt es die Klasse Monitor, mit der Sie pulse- und
wait-, atomic- und andere Thread-Operationen implementieren.
Kapitel 17, Integration nativer DLLs
Dieses Kapitel erklärt die PInvoke-Dienste, über die C#-Programme mit Legacy-DLLs
interagieren.
Kapitel 18, Integration von COM-Komponenten
Kapitel 18 beschreibt die FCL-Typen und -Attribute, mit denen COM-Objekte für C#-Programme und C#-Objekte für COM verfügbar werden.
Kapitel 19, Diagnose
Da alle Anwendungen eine integrierte Fehlerbehandlung und -meldung erfordern, bietet
das .NET Framework etliche Funktionen, mit denen Sie das Verhalten von Anwendungen

überwachen, Laufzeitfehler entdecken, die Anwendungsumgebung untersuchen, Meldungen über den Status der Anwendung erhalten und eine Integration der vorhandenen
Debugging-Tools bewerkstelligen können. Dieses Kapitel führt in die Debugging- und
Diagnoseunterstützung der FCL ein.
Teil III, Sprach- und Tool-Referenz, behandelt folgende Themen:
Kapitel 20, C#-Sprachreferenz
Kapitel 20 enthält eine kurze alphabetische Auflistung aller Sprachkonstrukte von C# und
ihrer jeweiligen Syntax.
Kapitel 21, Referenz zu XML-Dokumentations-Tags
C# stellt XML-Dokumentations-Tags zur Verfügung, die es Ihnen leichtmachen, eine
Anwendungsdokumentation direkt mit dem Quellcode zu erstellen. In diesem Kapitel
werden die entsprechenden Tags sowie ihre Verwendung vorgestellt.
Kapitel 22, Namens- und Programmierkonventionen in C#
Kapitel 22 schlägt Richtlinien für die Namensgebung sowie für die Groß- und Kleinschreibung von C#-Programmierkonstrukten vor. Diese Richtlinien wurden anhand der
offiziellen Microsoft-Dokumente und der Erfahrungen der Autoren dieses Buchs erarbeitet.
Kapitel 23, C#-Entwicklungswerkzeuge
Dieses Kapitel ist eine Referenz zu nützlichen Kommandozeilen-Tools, die mit Visual Studio .NET und dem .NET Framework ausgeliefert werden. Dazu gehören auch der Compiler und der Debugger.
Die 23 Kapitel der Teile I bis III von C# in a Nutshell machen Sie mit C# und vielen wichtigen
APIs des .NET Framework vertraut. Die zweite Hälfte des Buchs ist der Teil IV, die APISchnellreferenz. Diese ist eine knappe, aber detaillierte API-Referenz zu 21 wichtigen Namensräumen und mehr als 700 Kerntypen einschließlich ihrer Member. Bitte lesen Sie hierzu auf
jeden Fall Kapitel 24, So verwenden Sie diese Schnellreferenz, am Anfang von Teil IV, in dem
erklärt wird, wie Sie aus der Referenz den größtmöglichen Nutzen ziehen.
Teil V, Anhänge, enthält zusätzliche Referenztabellen, darunter die Syntax von regulären Ausdrücken (Anhang A, Reguläre Ausdrücke), Formatangaben (Anhang B, Formatangaben), standardmäßige Datenzuordnung von C# zu COM (Anhang C, Marshaling von Daten), ein Glossar

xvi

Vorwort


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

der C#-Schlüsselwörter (Anhang D, Schlüsselwörter in C#), eine alphabetische Liste der .NETNamensräume und der DLLs, die diese Namensräume enthalten (Anhang E, Namensräume
und Assemblies), sowie einen Index der Typen und Member, in dem Sie Methoden oder Felder nachschlagen können, um zu sehen, mit welchem Typ sie definiert sind.

Voraussetzungen für dieses Buch
Um mit C# zu programmieren, müssen Sie zunächst eine der vielen Editionen von Visual Studio .NET auf Ihrem System installiert haben (Standard, Professional, Enterprise oder Architect)
oder das .NET Framework SDK heruntergeladen und eingerichtet haben. Visual Studio stellt
eine umfangreiche interaktive Entwicklungsumgebung zur Verfügung, die viele Aufgaben der
C#-Programmierung erleichtert, vor allem die Entwicklung von Windows-Clients, serverseitigen Webanwendungen und Web Services. Außerdem bietet Visual Studio eine hervorragende
Unterstützung für das Debugging und das Projektmanagment von Anwendungen.
Wenn Sie das .NET Framework SDK auf Ihrem System installiert haben, können Sie allerdings
auch mit einem einfachen Editor wie z.B. emacs, SharpDevelop oder Microsoft Notepad die
C#-Programme schreiben und sie mit den in Kapitel 23, C#-Entwicklungswerkzeuge, beschriebenen Kommandozeilen-Tools debuggen und ausführen.
Um das .NET Framework SDK (gegenwärtig eine 131-MByte-Datei) herunterzuladen, gehen
Sie zu />Wenn dieses Buch in die Regale der Buchhändler gelangt, dürfte es jedoch auch bereits möglich sein, das .NET Framework SDK auf CD zu erwerben.

Konventionen
In diesem Buch gelten die folgenden typographischen Konventionen.
Kursiv wird verwendet für:

·
·
·
·
·
·
·
·

Verzeichnispfade und Dateinamen
Domain-Namen und URLs

Neue Begriffe, die definiert werden

Nichtproportionalschrift wird verwendet für:

Codebeispiele und Ausgaben
Namen und Schlüsselwörter in C#-Programmen, einschließlich Methoden- oder Feldnamen, Variablennamen und Klassennamen
XML- und HTML-Element-Tags
Registry-Schlüssel

Nichtproportionalschrift kursiv wird verwendet für:

Parameternamen oder Platzhalter, die im Programm durch einen tatsächlichen Wert
ersetzt werden

Vorwort

xvii


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

An mehreren Stellen in diesem Buch finden Sie einfache Grammatikangaben zu vielen, aber
nicht allen in diesem Buch eingeführten Sprachkonstrukten. So können Sie die Grammatik
eines bestimmten Konstrukts und seine zulässigen Kombinationsmöglichkeiten schnell überblicken. In der Syntax dieser Grammatik wird mit den XML-Häufigkeitsoperatoren (?, * und +)
konkreter angegeben, wie oft ein Element in einem bestimmten Konstrukt auftreten kann:
x
x

Zeigt an, daß x wörtlich verwendet werden soll (Nichtproportionalschrift).

Zeigt an, daß der Programmierer für x einen entsprechenden Wert einsetzt (Nichtproportionalschrift Kursiv).

x?

Zeigt an, daß x null oder einmal auftreten kann.

x*

Zeigt an, daß x null Mal oder mehrmals (durch Kommata getrennt) auftreten kann.

x+

Zeigt an, daß x einmal oder mehrmals (durch Kommata getrennt) auftreten kann.

[...]

Zeigt eine logische Zusammenfassung von Codeelementen an, soweit diese nicht implizit
mit {}, () oder [] zusammengefaßt sind.
[x|y]

Zeigt an, daß nur ein Element aus einer Auswahl von Codeelementen auftreten darf.

Dieses Icon zeigt einen Hinweis an, also eine wichtige Nebenbemerkung zum
Text.

Weitere Literatur zu diesem Thema
O’Reilly & Associates und der O’Reilly Verlag verlegen eine ganze Reihe von Büchern über C#
und .NET, darunter auch mehrere ergänzende Bücher zu dem vorliegenden Band. Empfehlenswert sind aus der .NET-Reihe von O’Reilly unter anderem:

·

·
·
·
·
·

Programmieren mit C# von Jesse Liberty
.NET Framework Essentials, Second Edition, von Thuan Thai und Hoang Q. Lam
VB.NET Language in a Nutshell, Second Edition, von Steven Roman, Ron Petrusha und
Paul Lomax
Programming Visual Basic .NET von Dave Grundgeiger
Programming ASP.NET von Jesse Liberty und Dan Hurwitz
C# and VB.NET Conversion Pocket Reference von Jose Mojica

Eine vollständige Liste der .NET-Bücher von O’Reilly und anderer Titel zu Programmierthemen
finden Sie unter .
Außerdem empfehlen wir C# Primer: A Practical Approach, von Stanley B. Lippman
(Addison-Wesley Professional) und Effektiv Java programmieren von Joshua Bloch (auch für
C#-Programmierer exzellent geeignet).

xviii

Vorwort


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Online-Ressourcen zu C#
Auch dieses Buch kann nicht alle Fragen beantworten, die Sie zu C# vielleicht haben. Es gibt

viele Online-Ressourcen, die Ihnen helfen, das Beste aus C# herauszuholen. Folgende Websites sind zu empfehlen:
/>Das Microsoft .NET Developer Center ist die offizielle Website für alles, was mit .NET zu
tun hat, einschließlich der neuesten Version des .NET Framework SDK, der Dokumentation, technischer Fachartikel, Beispielcode, Hinweise auf Diskussionsgruppen und Ressourcen von Fremdherstellern.

Die Support-Seite des .NET Framework-Teams für die Programmierergemeinde. Hier
finden Sie Artikel, Spezifikationen und viele Beispiele, sowohl aus dem .NET Framework-Team als auch von der Programmierergemeinde insgesamt.
/>Die Diskussionsliste von DevelopMentor DOTNET ist der beste Ort für eine unabhängige, offene Diskussion über das .NET Framework. Teilnehmer sind nicht selten hochstehende Ingenieure und Programm-Manager von Microsoft.
/> />Die offiziellen ECMA-Spezifikationen zu C# (ECMA-334) und CLI (ECMA-335).

Das .NET DevCenter im O’Reilly Network, mit Originalartikeln, News und interessanten
Weblogs für .NET-Programmierer.

Das O’Reilly .NET-Center. Schauen Sie öfters hier vorbei, wenn Sie Informationen über
Neuerscheinungen von O’Reilly benötigen. Hier finden Sie Beispielkapitel, Artikel und
andere Ressourcen.
/>Eine Liste von Ressourcen der Fremdhersteller für C#- und .NET Framework-Entwickler.
Es gibt auch im Usenet Diskussionen über .NET, und zwar in der Newsgruppenfamilie microsoft.public.dotnet.* Außerdem kümmert sich die Newsgruppe microsoft.public.dotnet.languages.csharp speziell um C#. Wenn Ihr News-Server diese Gruppen nicht anbietet, finden Sie sie
unter news://msnews.microsoft.com.
Abschließend seien noch zwei interessante Artikel erwähnt:
/>Ein Interview mit dem Erfinder von C#, Anders Hejlsberg, vom O’Reilly-Editor John
Osborn.
/>Ein Vergleich zwischen C# und C++ sowie Java vom Co-Autor dieses Buchs, Ben
Albahari.

Vorwort

xix


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002

Seitenformat: 172,00 x 230,00 mm

So wurde die Schnellreferenz generiert
Teil IV, die API-Schnellreferenz, wurde mit Hilfe der Reflection-API von .NET generiert (die in
Kapitel 13, Reflection, genauer beschrieben ist). Mit Reflection nahmen wir bestimmte Klassen,
Structs, Enums, Delegates und Interfaces der Framework Class Library unter die Lupe und
extrahierten detaillierte Informationen über jeden Typ und seine Member. Danach strukturierten wir diese Informationen als DocBook XML, und aus diesem Format haben wir die Druckversion erstellt.
Jedes angegebene Typlisting wird von einem oder mehreren Absätzen begleitet, die den Typ
und seine wichtigsten Member beschreiben. Diese Beschreibungen geben einen Überblick
darüber, wie Sie den Typ in Ihren eigenen Anwendungen nutzen können, und beschreiben
verwandte Typen, Fallstricke und nützliche Features.

Danksagungen
Ohne die Mithilfe vieler Beteiligter, einschließlich der Familien, der Freunde und der hart
arbeitenden Mitarbeiter von O’Reilly wäre dieses Buch niemals erschienen.
Brian Jepson und Lenny Muellner schrieben die Programme, mit denen Teil IV und der
Anhang F generiert wurden. Brian entwickelte außerdem unter Mithilfe von Ted Neward und
Peter Drayton die Namensraum-Karten, die Sie am Anfang jedes Referenzkapitels als Überblicksdarstellung finden. Peter Drayton schrieb das Programm, mit dem das Material für
Anhang E, Namensräume und Assemblies, generiert wurde. Ted Neward, Matthew MacDonald, Martin Smith, Steve Spainhour und Brian Jepson erstellten die mehr als 700 Namensraum- und Typbeschreibungen, durch die die API-Referenz so wertvoll wird.
Brad Merrill von Microsoft schrieb die Abschnitte über reguläre Ausdrücke und lieferte den
Inhalt für Anhang A, Reguläre Ausdrücke.
Brad Abrams und Mitarbeiter aus seinem .NET Framework-Team trugen zum Entwurf der APIReferenz bei und verbesserten sie durch ihr Fachlektorat ganz entscheident. Weitere technische Gutachter waren Joe Nalewabau und Kerry Loynd von Microsoft.

Peter Drayton
In erster Linie danke ich meiner Frau Julie DuBois, die es immer wieder schafft, daß die Tage,
die ich ohne .NET verbringe, sogar noch schöner sind als die, die ich mit .NET verbringe.
Außerdem danke ich Ben Albahari dafür, daß er den Materialberg zu C# und .NET schon zum
zweiten Mal in weniger als anderthalb Jahren mit mir bewältigt hat; ich danke Ted Neward,
der als Kavallerie immer zur rechten Zeit kam und aus der zweiten Hälfte des Buchs das Bestmögliche machte, und Brian Jepson, Nancy Kotary sowie John Osborn für ihre unermüdliche
Hilfe und Arbeit (sowohl als Verleger als auch in anderer Hinsicht).

Wenn man den Bogen noch etwas weiter spannt, so wurden die Beiträge in diesem Buch
auch durch Kommentare und Anregungen von Simon Fell, Don Box, Brock Allen und all den
anderen klugen und talentierten DevelopMentor-Lehrern, deren Kollege zu sein ich das Glück
habe, um ein Vielfaches besser.
Ich widme dieses Buch meinem Vater Peter Drayton Senior und meiner Mutter Irene Mary
Rochford Drayton, die mir alles mitgaben, um durch die Fährnisse des Lebens zu steuern.

xx

Vorwort


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Ben Albahari
Ich danke zunächst Peter Drayton, der mich bat, an diesem Buch mitzuarbeiten, und der mich
regelmäßig mit seiner Begeisterung mitzieht; den Lektoren von O’Reilly (Brian Jepson, Nancy
Kotary und John Osborn) für ihren Einsatz und die Geduld, die notwendig war, um dieses
Projekt zum Abschluß zu bringen; Ted Neward, der zu uns stieß, als wir den schwierigsten
Teil des Buchs in Angriff nahmen; und meiner Freundin Karen, die mich mit einer Mischung
aus Liebe und Logik motiviert hat.

Ted Neward
Zuallererst danke ich Peter Drayton, der mich einlud (oder nötigte?), bei diesem Projekt mitzuarbeiten. Es hat Spaß gemacht, mit ihm und Ben Albahari an einem Buch zu arbeiten, das, wie
ich hoffe, für Tausende von abtrünnigen C++-, Java- und VB-Programmierern, die zu dieser
neuen Sprache wechseln, von Nutzen sein wird. Zweitens danke ich dem Team von O’Reilly,
das meine erste Zusammenarbeit mit O’Reilly zu einer wunderbaren Erfahrung machte. Drittens gilt mein Dank meinen jetzigen und ehemaligen Studenten, die meine Versuche, ihnen
C# beizubringen, mit Fragen, Diskussionen und Lachen (vielleicht etwas hysterischem Lachen)
begleiteten. Viertens danke ich Don Box und Mike Abercrombie für DevelopMentor und die

herrliche Arbeitsatmosphäre, die sie dort schufen und an der ich teilhaben durfte. Und last but
not least danke ich meiner wunderbaren Familie: Meiner Frau Charlotte und meinen Söhnen
Michael und Matthew, die ihren Papa gern haben, auch wenn er manchmal für eine Weile im
Arbeitszimmer verschwindet.
Auch Ihnen, werter Leser, danke ich, da Sie sich die Zeit nehmen, unser Buch im Rahmen
Ihrer Beschäftigung mit C# zu lesen. Ich hoffe, daß Ihre Bemühungen insofern Früchte tragen,
als Sie durch unser Buch schneller lernen und mehr Zeit mit Ihrer Familie und Ihren Freunden
verbringen können. Auch wenn es banal klingen mag: In dieser »neuen Zeit«, in der wir leben,
sind solche Kontakte mit Gold nicht aufzuwiegen. Und deshalb gehe ich jetzt mit meiner Familie Pizza essen.

Vorwort

xxi


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

TEIL I

Programmieren mit C#


H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

H:/Oreilly/CNet_Nutshell/Cnet.3d vom 20.11.2002
Seitenformat: 172,00 x 230,00 mm

Einführung
in C#

KAPITEL 1

Einführung in C# und das .NET
Framework
Die neue Programmiersprache C# wurde von Microsoft speziell für das .NET Framework entwickelt. Das .NET Framework ist eine Laufzeitumgebung und Klassenbibliothek, die die Entwicklung und den Einsatz moderner, komponentenbasierter Anwendungen massiv erleichtert.
Als im Januar 2002 die endgültige Version des .NET Framework und der Programmiersprache
C# ausgeliefert wurde, hatten sowohl die Plattform als auch die Programmiersprache bereits
die Aufmerksamkeit der Industrie auf sich gezogen und wurden von der Avantgarde der
Microsoft-Nutzer auf breiter Front eingesetzt. Wie kommt es zu diesem Erfolg? Gewiß, C# und
das .NET Framework lösen viele technische Probleme, mit denen Entwickler heutzutage konfrontiert sind, wenn sie versuchen, immer komplexere verteilte Systeme in immer kürzerer
Zeit mit immer weniger Teamkollegen zu erstellen.
Neben den technischen Vorzügen ist jedoch der Hauptgrund dafür, daß C# und das .NET Framework so beliebt sind, die bisher beispiellose Offenheit, die Microsoft an den Tag legt. Von Juli
2000 bis Januar 2002 wurde das .NET Framework öffentlich umfangreich beta-getestet, so daß
Zehntausende von Entwicklern die neue Entwicklungsumgebung einer »Nagelprobe« unterziehen konnten. So konnte Microsoft von den Erfahrungen und dem Feedback der Entwicklergemeinschaft profitieren, ehe die neue Plattform endgültig fertiggestellt wurde.
Außerdem wurden die wichtigsten Spezifikationen für die Programmiersprache und die Plattform von der internationalen Standardisierungsorganisation European Computer Manufacturers Association (ECMA) veröffentlicht, begutachtet und abgesegnet. Diese Standardisierungsbemühungen veranlaßten viele andere Hersteller, C# und die .NET-Plattform auf andere als
Microsoft-Umgebungen zu portieren. Auch im akademischen Bereich ist das Interesse an
Microsoft-Technologien für Forschung und Lehre wieder erwacht.
Obwohl C# und .NET zunächst ganz neu aussehen, beruhen sie auf der soliden Grundlage
einer langjährigen Entwicklungsarbeit. Wenn Sie wissen, wo die Sprache und die Plattform
herkommen, dann verstehen Sie besser, wohin die Reise geht.

Kapitel 1: Einführung in C# und das .NET Framework

3