Kompaktkurs C# 7
von: Hanspeter Mössenböck
dpunkt, 2018
ISBN: 9783960886815
Sprache: Deutsch
344 Seiten, Download: 2325 KB
Format: PDF, auch als Online-Lesen
Geleitwort | 5 | ||
Vorwort | 7 | ||
Inhalt | 7 | ||
Zielpublikum | 8 | ||
Inhalt | 9 | ||
1 C# und das .NET-Framework | 15 | ||
1.1 Ähnlichkeiten zwischen C# und Java | 15 | ||
1.2 Unterschiede zwischen C# und Java | 17 | ||
1.3 Das .NET-Framework | 18 | ||
Abb. 1–1 Grobarchitektur des .NET-Frameworks | 19 | ||
Common Language Runtime | 19 | ||
Abb. 1–2 Quellcode, CIL-Code und Maschinencode | 20 | ||
Assemblies | 20 | ||
Abb. 1–3 Vom Compiler erzeugtes Assembly Prog.exe | 21 | ||
ADO.NET | 22 | ||
ASP.NET | 22 | ||
Web-Services | 23 | ||
1.4 Übungsaufgaben | 24 | ||
2 Erste Schritte | 25 | ||
2.1 Hello World | 25 | ||
2.2 Gliederung von Programmen | 26 | ||
Abb. 2–1 Gliederung von Programmen | 26 | ||
Programme aus mehreren Dateien | 26 | ||
2.3 Symbole | 27 | ||
2.4 Übungsaufgaben | 30 | ||
3 Typen | 31 | ||
Abb. 3–1 Typenhierarchie | 31 | ||
Tabelle 3–1 Werttypen und Referenztypen | 32 | ||
3.1 Einfache Typen | 32 | ||
Tabelle 3–2 Einfache Typen | 32 | ||
Abb. 3–2 Kompatibilitätsbeziehung zwischen einfachen Typen | 33 | ||
3.2 Enumerationen | 33 | ||
3.3 Arrays | 34 | ||
Abb. 3–3 Ausgefranste und rechteckige mehrdimensionale Arrays | 35 | ||
3.4 Strings | 37 | ||
Tabelle 3–3 Stringoperationen (Auszug) | 38 | ||
3.5 Structs | 38 | ||
3.6 Klassen | 39 | ||
Tabelle 3–4 Klassen versus Structs | 40 | ||
3.7 object | 40 | ||
3.8 Boxing und Unboxing | 41 | ||
Abb. 3–4 Boxing eines int-Werts | 41 | ||
3.9 Übungsaufgaben | 42 | ||
4 Ausdrücke | 45 | ||
Tabelle 4–1 Operatoren nach Priorität geordnet | 45 | ||
4.1 Arithmetische Ausdrücke | 45 | ||
4.2 Vergleichsausdrücke | 46 | ||
4.3 Boolesche Ausdrücke | 47 | ||
4.4 Bit-Ausdrücke | 47 | ||
4.5 Shift-Ausdrücke | 47 | ||
4.6 Überlaufprüfung | 48 | ||
4.7 typeof | 48 | ||
4.8 sizeof | 49 | ||
4.9 Übungsaufgaben | 49 | ||
5 Deklarationen | 51 | ||
5.1 Deklarationen in Namensräumen | 52 | ||
5.2 Deklarationen in Klassen, Structs und Interfaces | 53 | ||
5.3 Deklarationen in Enumerationstypen | 54 | ||
5.4 Deklarationen in Blöcken | 54 | ||
5.5 Übungsaufgaben | 56 | ||
6 Anweisungen | 57 | ||
6.1 Leeranweisung | 57 | ||
6.2 Zuweisung | 57 | ||
6.3 Methodenaufruf | 58 | ||
6.4 if-Anweisung | 58 | ||
6.5 switch-Anweisung | 59 | ||
6.6 while-Anweisung | 60 | ||
6.7 do-while-Anweisung | 60 | ||
6.8 for-Anweisung | 60 | ||
6.9 foreach-Anweisung | 61 | ||
6.10 break- und continue-Anweisungen | 62 | ||
6.11 goto-Anweisung | 62 | ||
Abb. 6–1 Endlicher Automat | 63 | ||
6.12 return-Anweisung | 63 | ||
6.13 Übungsaufgaben | 64 | ||
7 Ein-/Ausgabe | 65 | ||
7.1 Ausgabe auf den Bildschirm | 65 | ||
7.2 Formatierte Ausgabe | 65 | ||
Platzhalter-Syntax | 66 | ||
Tabelle 7–1 Die wichtigsten Formatierungscodes | 67 | ||
Stringformatierung | 67 | ||
Vereinfachte Platzhalter in Formatstrings | 68 | ||
7.3 Ausgabe auf eine Datei | 68 | ||
7.4 Eingabe von der Tastatur | 69 | ||
7.5 Eingabe von einer Datei | 69 | ||
7.6 Lesen der Kommandozeilenparameter | 70 | ||
7.7 Übungsaufgaben | 71 | ||
8 Klassen und Structs | 73 | ||
8.1 Sichtbarkeitsattribute | 74 | ||
8.2 Felder | 76 | ||
Statische Felder | 76 | ||
Abb. 8–1 Statische und nicht statische Felder | 77 | ||
8.3 Methoden | 77 | ||
Statische Methoden | 78 | ||
Parameter | 78 | ||
Variable Anzahl von Parametern | 80 | ||
Überladen von Methoden | 81 | ||
Optionale Parameter | 82 | ||
Benannte Parameter | 83 | ||
8.4 Konstruktoren | 84 | ||
Konstruktoren in Klassen | 84 | ||
Konstruktoren in Structs | 85 | ||
Statische Konstruktoren | 86 | ||
8.5 Destruktoren | 86 | ||
8.6 Properties | 87 | ||
8.7 Indexer | 90 | ||
8.8 Überladene Operatoren | 92 | ||
Tabelle 8–1 Überladbare Operatoren | 93 | ||
Konversionsoperatoren | 94 | ||
8.9 Kurzform für Methoden | 95 | ||
8.10 Geschachtelte Typen | 96 | ||
8.11 Partielle Typen | 97 | ||
8.12 Partielle Methoden | 98 | ||
8.13 Statische Klassen | 99 | ||
8.14 Unterschiede zu Java | 99 | ||
8.15 Übungsaufgaben | 100 | ||
9 Vererbung | 103 | ||
9.1 Deklaration von Unterklassen | 103 | ||
9.2 Kompatibilität zwischen Klassen | 105 | ||
Tabelle 9–1 Statischer und dynamischer Typ einer Variablen | 105 | ||
9.3 Überschreiben und Verdecken von Elementen | 106 | ||
9.4 Dynamische Bindung | 109 | ||
Dynamische Bindung und Verdecken von Methoden | 110 | ||
Das Problem der zerbrechlichen Basisklassen | 110 | ||
9.5 Konstruktoren in Ober- und Unterklasse | 112 | ||
Tabelle 9–2 Impliziter Aufruf des parameterlosen Konstruktors der Basisklasse | 112 | ||
9.6 Abstrakte Klassen | 113 | ||
Abstrakte Properties und Indexer | 113 | ||
9.7 Versiegelte Klassen | 114 | ||
9.8 Die Klasse Object | 115 | ||
9.9 Übungsaufgaben | 117 | ||
10 Interfaces | 119 | ||
10.1 Deklaration und Verwendung von Interfaces | 119 | ||
Abb. 10–1 Arbeiten mit einem Objekt versus Arbeiten mit einer Interfacevariablen | 120 | ||
10.2 Operationen auf Interfaces | 121 | ||
10.3 Erweiterung von Interfaces | 122 | ||
Abb. 10–2 Abhängigkeiten zwischen ISimpleReader, IReader, Terminal und File | 122 | ||
10.4 Namenskonflikte | 123 | ||
10.5 Interface IDisposable | 124 | ||
using-Anweisung | 125 | ||
10.6 Übungsaufgaben | 125 | ||
11 Delegates und Events | 127 | ||
11.1 Einfache Delegates | 127 | ||
11.2 Multicast-Delegates | 128 | ||
11.3 Erzeugen von Delegate-Werten | 128 | ||
Vereinfachte Delegate-Zuweisung | 129 | ||
11.4 Ereignisse (Events) | 130 | ||
11.5 Anonyme Methoden | 131 | ||
11.6 Übungsaufgaben | 133 | ||
12 Ausnahmen | 135 | ||
12.1 try-Anweisung | 135 | ||
12.2 Ausnahmeklassen | 137 | ||
Abb. 12–1 Auszug aus der Hierarchie der Ausnahmeklassen | 138 | ||
12.3 Auslösen von Ausnahmen | 138 | ||
Abb. 12–2 Suche nach einer passenden catch-Klausel | 139 | ||
12.4 Ausnahmen in aufgerufenen Methoden | 140 | ||
12.5 Ausnahmen in Multicast-Delegates | 140 | ||
Abb. 12–3 Suche nach einer catch-Klausel in Zusammenhang mit Delegates | 140 | ||
12.6 Übungsaufgaben | 141 | ||
13 Namensräume und Assemblies | 143 | ||
13.1 Namensräume | 143 | ||
C#-Namensräume versus Java-Pakete | 144 | ||
Abb. 13–1 Pakete werden in Java auf Verzeichnisse abgebildet, Namensräume in C# nicht | 145 | ||
13.2 Assemblies | 146 | ||
13.2.1 Assemblies und Module | 146 | ||
Abb. 13–2 Assembly A.exe, bestehend aus drei Modulen | 147 | ||
13.2.2 Versionierung von Assemblies | 147 | ||
Private und öffentliche Assemblies | 147 | ||
Starke Namen | 148 | ||
Versionsnummer | 148 | ||
Abb. 13–3 A.exe merkt sich die Versionsnummer von Lib.dll | 149 | ||
Signierte Assemblies | 149 | ||
Abb. 13–4 Signieren eines Assemblies | 150 | ||
Abb. 13–5 Überprüfung der Unterschrift eines Assemblies | 150 | ||
13.2.3 Assemblies versus Namensräume | 150 | ||
Abb. 13–6 Ein Assembly, bestehend aus den Klassen A.C2 und B.C3 sowie aus einem Icon | 151 | ||
13.3 Übungsaufgaben | 151 | ||
14 Generische Bausteine | 153 | ||
14.1 Generische Typen | 154 | ||
14.2 Constraints | 155 | ||
Konstruktor-Constraints | 156 | ||
14.3 Vererbung bei generischen Typen | 156 | ||
Zuweisungskompatibilität zwischen generischen Typen | 157 | ||
Überschreiben von Methoden | 158 | ||
Laufzeittypprüfungen | 158 | ||
14.4 Generische Methoden | 158 | ||
14.5 Generische Delegates | 159 | ||
14.6 Nullwerte | 161 | ||
14.7 Ko- und Kontravarianz bei generischen Typen | 161 | ||
Typsichere Kovarianz | 162 | ||
Abb. 14–1 Kovarianz bei generischen Typen | 163 | ||
Typsichere Kontravarianz | 163 | ||
Abb. 14–2 Kontravarianz bei generischen Typen | 164 | ||
Beispiel | 164 | ||
Abb. 14–3 Beispiel-Klassenhierarchie | 164 | ||
14.8 Was geschieht hinter den Kulissen? | 165 | ||
14.9 Unterschiede zu Java | 165 | ||
14.10 Übungsaufgaben | 166 | ||
15 Threads | 169 | ||
15.1 Die Klasse Thread | 169 | ||
Beispiel | 171 | ||
15.2 Zustände eines Threads | 172 | ||
Abb. 15–1 Zustandsübergangsdiagramm eines Threads | 172 | ||
15.3 Abbrechen eines Threads | 173 | ||
15.4 Thread-Synchronisation | 174 | ||
Abb. 15–2 Zwei Threads führen gleichzeitig die Anweisung x = x + 1 | 174 | ||
Die lock-Anweisung | 174 | ||
Die Klasse Monitor | 176 | ||
Wait und Pulse | 176 | ||
Abb. 15–3 Systemverklemmung bei Verwendung von Pulse statt PulseAll | 178 | ||
15.5 Übungsaufgaben | 179 | ||
16 Iteratoren | 181 | ||
16.1 Allgemeine Iteratoren | 181 | ||
yield-Anweisung | 183 | ||
16.2 Spezifische Iteratoren | 183 | ||
Übersetzung spezifischer Iteratoren | 185 | ||
16.3 Übungsaufgaben | 186 | ||
17 Attribute | 187 | ||
17.1 Schreibweise von Attributen | 187 | ||
17.2 Parameter von Attributen | 188 | ||
17.3 Attribute für spezifische Programmelemente | 189 | ||
17.4 Attribut Serializable | 190 | ||
Abb. 17–1 Ursprüngliche Liste und neue Liste nach Serialisierung und Deserialisierung | 191 | ||
17.5 Attribut Conditional | 192 | ||
17.6 Attribut DllImport | 193 | ||
Abb. 17–2 Ein von einer Native-Funktion erzeugtes Fenster | 193 | ||
17.7 Deklaration eigener Attribute | 194 | ||
17.8 Übungsaufgaben | 195 | ||
18 Dokumentationskommentare | 197 | ||
18.1 XML-Elemente | 197 | ||
Beispiel | 198 | ||
18.2 Erzeugte XML-Datei | 199 | ||
18.3 Übungsaufgaben | 200 | ||
19 Auszug aus der .NET-Klassenbibliothek | 201 | ||
Tabelle 19–1 Auszug der Namensräume und Typen der .NET-Bibliothek | 202 | ||
19.1 Hilfsklassen | 202 | ||
StringBuilder | 202 | ||
Math | 203 | ||
Random | 204 | ||
Convert | 204 | ||
19.2 Collections | 205 | ||
Abb. 19–1 Auszug der wichtigsten Collection-Typen | 205 | ||
Array | 206 | ||
ArrayList | 206 | ||
Hashtable | 208 | ||
ListDictionary | 209 | ||
SortedList | 209 | ||
Stack | 210 | ||
Queue | 210 | ||
BitArray | 211 | ||
Iterieren über Collections | 212 | ||
Generische Collection-Typen | 213 | ||
19.3 Ein-/Ausgabe | 214 | ||
Datenströme | 214 | ||
Abb. 19–2 Hierarchie der Stream-Klassen | 215 | ||
Reader | 216 | ||
Abb. 19–3 Reader-Klassen (Auszug) | 216 | ||
Writer | 217 | ||
Abb. 19–4 Writer-Klassen (Auszug) | 217 | ||
File und FileInfo | 218 | ||
Abb. 19–5 Auszug aus den Klassen File und FileInfo | 218 | ||
Directory und DirectoryInfo | 218 | ||
Abb. 19–6 Auszug aus den Klassen Directory und DirectoryInfo | 219 | ||
19.4 Reflection | 220 | ||
Type | 220 | ||
Assembly | 222 | ||
19.5 Übungsaufgaben | 224 | ||
20 LINQ | 227 | ||
20.1 Motivation | 227 | ||
20.2 Lambda-Ausdrücke | 228 | ||
Lambda-Ausdrücke als Parameter | 229 | ||
Lambda-Ausdrücke als Prädikate | 230 | ||
Lambda-Ausdrücke mit mehreren Parametern | 230 | ||
Lambda-Ausdrücke mit Anweisungsblöcken | 231 | ||
Beispiele | 232 | ||
20.3 Erweiterungsmethoden | 232 | ||
20.4 Objektinitialisierer | 234 | ||
Initialisierer für Collections | 235 | ||
20.5 Anonyme Typen | 236 | ||
Schlüsselwort var | 237 | ||
20.6 Query-Ausdrücke | 238 | ||
Query-Syntax | 239 | ||
Laufvariablen | 240 | ||
Gruppierung | 241 | ||
Joins | 242 | ||
Gruppen-Joins | 244 | ||
let | 244 | ||
20.7 LINQ und XML | 245 | ||
XElement und XAttribute | 245 | ||
Erzeugen von XML-Daten aus einer Wertefolge | 246 | ||
Erzeugen einer Wertefolge aus XML-Daten | 246 | ||
20.8 Übungsaufgaben | 247 | ||
21 Asynchrone Methoden und Parallelität | 249 | ||
21.1 Asynchronität | 249 | ||
Abb. 21–1 Synchrone und asynchrone Methodenaufrufe | 249 | ||
21.2 Tasks | 250 | ||
21.3 Asynchrone Methoden | 252 | ||
Abb. 21–2 Ablauf von DoAsync() | 252 | ||
Abb. 21–3 Ablauf von DoAsync() | 253 | ||
Umwandlung von synchronen in asynchrone Methoden | 254 | ||
Einschränkungen und Hinweise | 255 | ||
Asynchronität in Schleifen | 256 | ||
Abb. 21–4 Asynchrone Operation in einer Schleife | 256 | ||
Weiteres Beispiel | 257 | ||
Abb. 21–5 Verzahnter Steuerfluss beim Aufruf von DoAsync(), GetAsync() und ReadAsync() | 258 | ||
21.4 Explizite Parallelität | 258 | ||
21.5 Übungsaufgaben | 260 | ||
22 Tupel | 261 | ||
22.1 Tupel-Typen | 261 | ||
22.2 Zuweisungen | 262 | ||
22.3 Anwendungen | 263 | ||
Funktionen mit mehreren Rückgabewerten | 263 | ||
Tupel-Typen als Typparameter | 264 | ||
Tupel-Typen als Projektionen | 264 | ||
22.4 Zerlegung von Tupeln | 265 | ||
Zerlegung unter Weglassung einzelner Elemente | 266 | ||
22.5 Dekonstruktoren für Klassen und Structs | 266 | ||
22.6 Übungsaufgaben | 267 | ||
23 Pattern Matching | 269 | ||
Pattern Matching in switch-Anweisungen | 270 | ||
24 Interoperabilität mit COM | 273 | ||
24.1 COM-Objekte von .NET aus ansprechen | 274 | ||
Erzeugen eines Assemblies (tlbimp) | 274 | ||
Abb. 24–1 Ansicht von MyLibNET.dll in ildasm | 275 | ||
Registrieren der COM-Objekte (regsvr32) | 275 | ||
Benutzung des Assemblies | 276 | ||
Spät gebundener Methodenaufruf | 276 | ||
24.2 .NET-Assemblies von COM aus ansprechen | 277 | ||
Früh gebundener Methodenaufruf | 277 | ||
Spät gebundener Methodenaufruf | 279 | ||
24.3 Übungsaufgaben | 279 | ||
Abb. 24–2 Beispiele für Figuren unter Microsoft Agent | 279 | ||
25 Dynamisch getypte Variablen | 281 | ||
25.1 Typ dynamic | 281 | ||
Abb. 25–1 Alle Typen sind mit dynamic kompatibel | 281 | ||
25.2 Operationen auf dynamic-Variablen | 283 | ||
Implementierung der dynamischen Methodensuche | 284 | ||
26 Diverses | 285 | ||
26.1 Null-fähige Werttypen | 285 | ||
Rechnen mit null-fähigen Typen | 287 | ||
Konversion zwischen null-fähigen Typen und Originaltypen | 287 | ||
26.2 Bedingter Zugriff über Referenzen | 288 | ||
Bedingter Aufruf von Delegates | 289 | ||
26.3 using static | 289 | ||
26.4 Geschachtelte Methoden | 290 | ||
26.5 Rückgabe von Funktionswerten by reference | 291 | ||
27 Fallstudien | 293 | ||
27.1 Anwendungen mit grafischer Benutzeroberfläche | 293 | ||
Tabelle 27–1 Einige der in Windows Forms benötigten Typen | 293 | ||
Spezifikation eines Dateivergleichsprogramms | 294 | ||
Abb. 27–1 Benutzeroberfläche des Dateivergleichswerkzeugs | 294 | ||
Erstellen der Benutzeroberfläche mit Visual Studio .NET | 295 | ||
Abb. 27–2 Anlegen eines neuen Projekts | 295 | ||
Abb. 27–3 Entwurfsfläche mit Toolbox-Palette und Property-Fenster | 296 | ||
Tabelle 27–2 Properties der GUI-Elemente des Dateivergleichsprogramms | 297 | ||
Erzeugter Code | 298 | ||
27.2 Ein Web-Service für Börsenkurse | 302 | ||
Abb. 27–4 Eine Applikation holt sich Informationen von verschiedenen Web-Services | 303 | ||
Spezifikation eines Web-Services für Börsenkurse | 303 | ||
Serverseitige Implementierung | 303 | ||
Abb. 27–5 Von .NET generierte Seite zum Testen des Web-Services | 305 | ||
Clientseitige Implementierung | 306 | ||
Abb. 27–6 Aufruf der Web-Service-Methode GetQuote | 307 | ||
27.3 Dynamische Webseiten mit ASP.NET | 307 | ||
Abb. 27–7 Benutzeroberfläche einer Webseite zur Abfrage von Börsenkursen | 308 | ||
Layout der Webseite | 308 | ||
Hintergrundcode | 310 | ||
Einbinden weiterer Klassen | 311 | ||
Benutzung der Webseite | 312 | ||
Interaktive Erstellung von Webseiten | 312 | ||
Weitere Möglichkeiten von ASP.NET | 312 | ||
27.4 Übungsaufgaben | 313 | ||
A Anhang | 315 | ||
A.1 Compileroptionen | 315 | ||
Optionen zur Bestimmung der erzeugten Ausgabe | 315 | ||
Optionen zum Einbinden von Bibliotheken | 316 | ||
Weitere Optionen (Auswahl) | 316 | ||
Beispiele | 317 | ||
Tabelle A–1 Beispiele für den Aufruf des C#-Compilers | 317 | ||
A.2 Werkzeuge unter .NET | 318 | ||
A.2.1 ildasm | 318 | ||
Abb. A–1 Ansicht eines Assemblies Primes.exe in ildasm | 318 | ||
Abb. A–2 Links: Manifest von Primes.exe | 318 | ||
A.2.2 Globaler Assembly-Cache | 319 | ||
Signieren von Assemblies | 319 | ||
Verzögertes Signieren von Assemblies | 320 | ||
Verwaltung des globalen Assembly-Cache | 321 | ||
Abb. A–3 Globaler Assembly-Cache | 321 | ||
A.3 Grammatik von C# | 322 | ||
Tabelle A–2 Metazeichen in Grammatikregeln | 322 | ||
Zeichenmengen | 322 | ||
Namen und Konstanten | 323 | ||
Deklarationen | 323 | ||
Typen | 325 | ||
Anweisungen | 326 | ||
Ausdrücke | 327 | ||
A.4 Unicode und ASCII | 329 | ||
Tabelle A–3 Der ASCII-Zeichensatz (entspricht den ersten 128 Zeichen von Unicode) | 329 | ||
Literatur | 331 | ||
Index | 333 |