Mössenböck Kompaktkurs C# 7

1. Auflage 2018
ISBN: 978-3-96088-681-5
Verlag: dpunkt
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Deutsch, 344 Seiten

Das Buch beschreibt in kompakter Form den gesamten Sprachumfang von C# mit den neuen Sprachmerkmalen von C# 7. Es richtet sich an Leser, die bereits Erfahrung mit einer anderen Programmiersprache wie Java oder C++ haben und sich rasch in C# einarbeiten wollen, um damit produktiv zu werden. Neben der Sprache C# behandelt das Buch auch diverse Anwendungen und Fallstudien im .NETFramework. Themen: - Datenstrukturen und Anweisungen - Klassen, Structs, Interfaces und Vererbung - Properties, Indexer und Iteratoren - Delegates und Events - Exception Handling - Threads und Synchronisation - Generische Bausteine - Attribute und Reflection - Assemblies als Softwarekomponenten - Lambda-Ausdrücke - Erweiterungsmethoden - Anonyme Typen - Query-Ausdrücke in LINQ - Asynchrone Methoden und Parallelität - Tupel - Pattern Matching - Auszug aus der .NET-Klassenbibliothek - Fallstudien mit ASP.NET und Web-ServicesZahlreiche Beispiele sowie weit über 100 Übungsaufgaben mit Musterlösungen machen das Buch sowohl für den Einsatz im Unterricht als auch für das Selbststudium geeignet.

Hanspeter Mössenböck ist Professor für Informatik an der Universität Linz und Leiter des Instituts für Systemsoftware. Er beschäf-tigt sich vor allem mit Programmiersprachen, Compilern und Systemsoftware. Als ehemaliger Mitarbeiter von Prof. Niklaus Wirth an der ETH Zürich war er Mitglied des Oberon-Teams, in dem ein Pascal-Nachfolger samt innovativem Betriebssystem entwickelt wurde. Ferner ist er Autor des Compiler-Generators Coco/R, der heute weltweit als Public-Domain-Software eingesetzt wird. Neben einem Forschungsaufenthalt bei Sun Microsystems in Kalifornien hatte er Gastprofessuren in Oxford und Budapest inne. Er ist Verfasser der Bücher 'Sprechen Sie Java?' und 'Objektorientierte Programmierung in Oberon-2' sowie Mitverfasser der Bücher 'Die .NET-Technologie' und 'Ein Compiler-Generator für Mikrocomputer'.

Autoren/Hrsg.

Mössenböck, Hanspeter

Inhaltsverzeichnis

1;Geleitwort;5
2;Vorwort;7
2.1;Inhalt;7
2.2;Zielpublikum;8
3;Inhalt;9
4;1 C# und das .NET-Framework;15
4.1;1.1 Ähnlichkeiten zwischen C# und Java;15
4.2;1.2 Unterschiede zwischen C# und Java;17
4.3;1.3 Das .NET-Framework;18
4.3.1;Abb. 1–1 Grobarchitektur des .NET-Frameworks;19
4.3.2;Common Language Runtime;19
4.3.2.1;Abb. 1–2 Quellcode, CIL-Code und Maschinencode;20
4.3.3;Assemblies;20
4.3.3.1;Abb. 1–3 Vom Compiler erzeugtes Assembly Prog.exe;21
4.3.4;ADO.NET;22
4.3.5;ASP.NET;22
4.3.6;Web-Services;23
4.4;1.4 Übungsaufgaben;24
5;2 Erste Schritte;25
5.1;2.1 Hello World;25
5.2;2.2 Gliederung von Programmen;26
5.2.1;Abb. 2–1 Gliederung von Programmen;26
5.2.2;Programme aus mehreren Dateien;26
5.3;2.3 Symbole;27
5.4;2.4 Übungsaufgaben;30
6;3 Typen;31
6.1;Abb. 3–1 Typenhierarchie;31
6.2;Tabelle 3–1 Werttypen und Referenztypen;32
6.3;3.1 Einfache Typen;32
6.3.1;Tabelle 3–2 Einfache Typen;32
6.3.2;Abb. 3–2 Kompatibilitätsbeziehung zwischen einfachen Typen;33
6.4;3.2 Enumerationen;33
6.5;3.3 Arrays;34
6.5.1;Abb. 3–3 Ausgefranste und rechteckige mehrdimensionale Arrays;35
6.6;3.4 Strings;37
6.6.1;Tabelle 3–3 Stringoperationen (Auszug);38
6.7;3.5 Structs;38
6.8;3.6 Klassen;39
6.8.1;Tabelle 3–4 Klassen versus Structs;40
6.9;3.7 object;40
6.10;3.8 Boxing und Unboxing;41
6.10.1;Abb. 3–4 Boxing eines int-Werts;41
6.11;3.9 Übungsaufgaben;42
7;4 Ausdrücke;45
7.1;Tabelle 4–1 Operatoren nach Priorität geordnet;45
7.2;4.1 Arithmetische Ausdrücke;45
7.3;4.2 Vergleichsausdrücke;46
7.4;4.3 Boolesche Ausdrücke;47
7.5;4.4 Bit-Ausdrücke;47
7.6;4.5 Shift-Ausdrücke;47
7.7;4.6 Überlaufprüfung;48
7.8;4.7 typeof;48
7.9;4.8 sizeof;49
7.10;4.9 Übungsaufgaben;49
8;5 Deklarationen;51
8.1;5.1 Deklarationen in Namensräumen;52
8.2;5.2 Deklarationen in Klassen, Structs und Interfaces;53
8.3;5.3 Deklarationen in Enumerationstypen;54
8.4;5.4 Deklarationen in Blöcken;54
8.5;5.5 Übungsaufgaben;56
9;6 Anweisungen;57
9.1;6.1 Leeranweisung;57
9.2;6.2 Zuweisung;57
9.3;6.3 Methodenaufruf;58
9.4;6.4 if-Anweisung;58
9.5;6.5 switch-Anweisung;59
9.6;6.6 while-Anweisung;60
9.7;6.7 do-while-Anweisung;60
9.8;6.8 for-Anweisung;60
9.9;6.9 foreach-Anweisung;61
9.10;6.10 break- und continue-Anweisungen;62
9.11;6.11 goto-Anweisung;62
9.11.1;Abb. 6–1 Endlicher Automat;63
9.12;6.12 return-Anweisung;63
9.13;6.13 Übungsaufgaben;64
10;7 Ein-/Ausgabe;65
10.1;7.1 Ausgabe auf den Bildschirm;65
10.2;7.2 Formatierte Ausgabe;65
10.2.1;Platzhalter-Syntax;66
10.2.1.1;Tabelle 7–1 Die wichtigsten Formatierungscodes;67
10.2.2;Stringformatierung;67
10.2.3;Vereinfachte Platzhalter in Formatstrings;68
10.3;7.3 Ausgabe auf eine Datei;68
10.4;7.4 Eingabe von der Tastatur;69
10.5;7.5 Eingabe von einer Datei;69
10.6;7.6 Lesen der Kommandozeilenparameter;70
10.7;7.7 Übungsaufgaben;71
11;8 Klassen und Structs;73
11.1;8.1 Sichtbarkeitsattribute;74
11.2;8.2 Felder;76
11.2.1;Statische Felder;76
11.2.1.1;Abb. 8–1 Statische und nicht statische Felder;77
11.3;8.3 Methoden;77
11.3.1;Statische Methoden;78
11.3.2;Parameter;78
11.3.3;Variable Anzahl von Parametern;80
11.3.4;Überladen von Methoden;81
11.3.5;Optionale Parameter;82
11.3.6;Benannte Parameter;83
11.4;8.4 Konstruktoren;84
11.4.1;Konstruktoren in Klassen;84
11.4.2;Konstruktoren in Structs;85
11.4.3;Statische Konstruktoren;86
11.5;8.5 Destruktoren;86
11.6;8.6 Properties;87
11.7;8.7 Indexer;90
11.8;8.8 Überladene Operatoren;92
11.8.1;Tabelle 8–1 Überladbare Operatoren;93
11.8.2;Konversionsoperatoren;94
11.9;8.9 Kurzform für Methoden;95
11.10;8.10 Geschachtelte Typen;96
11.11;8.11 Partielle Typen;97
11.12;8.12 Partielle Methoden;98
11.13;8.13 Statische Klassen;99
11.14;8.14 Unterschiede zu Java;99
11.15;8.15 Übungsaufgaben;100
12;9 Vererbung;103
12.1;9.1 Deklaration von Unterklassen;103
12.2;9.2 Kompatibilität zwischen Klassen;105
12.2.1;Tabelle 9–1 Statischer und dynamischer Typ einer Variablen;105
12.3;9.3 Überschreiben und Verdecken von Elementen;106
12.4;9.4 Dynamische Bindung;109
12.4.1;Dynamische Bindung und Verdecken von Methoden;110
12.4.2;Das Problem der zerbrechlichen Basisklassen;110
12.5;9.5 Konstruktoren in Ober- und Unterklasse;112
12.5.1;Tabelle 9–2 Impliziter Aufruf des parameterlosen Konstruktors der Basisklasse;112
12.6;9.6 Abstrakte Klassen;113
12.6.1;Abstrakte Properties und Indexer;113
12.7;9.7 Versiegelte Klassen;114
12.8;9.8 Die Klasse Object;115
12.9;9.9 Übungsaufgaben;117
13;10 Interfaces;119
13.1;10.1 Deklaration und Verwendung von Interfaces;119
13.1.1;Abb. 10–1 Arbeiten mit einem Objekt versus Arbeiten mit einer Interfacevariablen;120
13.2;10.2 Operationen auf Interfaces;121
13.3;10.3 Erweiterung von Interfaces;122
13.3.1;Abb. 10–2 Abhängigkeiten zwischen ISimpleReader, IReader, Terminal und File;122
13.4;10.4 Namenskonflikte;123
13.5;10.5 Interface IDisposable;124
13.5.1;using-Anweisung;125
13.6;10.6 Übungsaufgaben;125
14;11 Delegates und Events;127
14.1;11.1 Einfache Delegates;127
14.2;11.2 Multicast-Delegates;128
14.3;11.3 Erzeugen von Delegate-Werten;128
14.3.1;Vereinfachte Delegate-Zuweisung;129
14.4;11.4 Ereignisse (Events);130
14.5;11.5 Anonyme Methoden;131
14.6;11.6 Übungsaufgaben;133
15;12 Ausnahmen;135
15.1;12.1 try-Anweisung;135
15.2;12.2 Ausnahmeklassen;137
15.2.1;Abb. 12–1 Auszug aus der Hierarchie der Ausnahmeklassen;138
15.3;12.3 Auslösen von Ausnahmen;138
15.3.1;Abb. 12–2 Suche nach einer passenden catch-Klausel;139
15.4;12.4 Ausnahmen in aufgerufenen Methoden;140
15.5;12.5 Ausnahmen in Multicast-Delegates;140
15.5.1;Abb. 12–3 Suche nach einer catch-Klausel in Zusammenhang mit Delegates;140
15.6;12.6 Übungsaufgaben;141
16;13 Namensräume und Assemblies;143
16.1;13.1 Namensräume;143
16.1.1;C#-Namensräume versus Java-Pakete;144
16.1.1.1;Abb. 13–1 Pakete werden in Java auf Verzeichnisse abgebildet, Namensräume in C# nicht;145
16.2;13.2 Assemblies;146
16.2.1;13.2.1 Assemblies und Module;146
16.2.1.1;Abb. 13–2 Assembly A.exe, bestehend aus drei Modulen;147
16.2.2;13.2.2 Versionierung von Assemblies;147
16.2.2.1;Private und öffentliche Assemblies;147
16.2.2.2;Starke Namen;148
16.2.2.3;Versionsnummer;148
16.2.2.3.1;Abb. 13–3 A.exe merkt sich die Versionsnummer von Lib.dll;149
16.2.2.4;Signierte Assemblies;149
16.2.2.4.1;Abb. 13–4 Signieren eines Assemblies;150
16.2.2.4.2;Abb. 13–5 Überprüfung der Unterschrift eines Assemblies;150
16.2.3;13.2.3 Assemblies versus Namensräume;150
16.2.3.1;Abb. 13–6 Ein Assembly, bestehend aus den Klassen A.C2 und B.C3 sowie aus einem Icon;151
16.3;13.3 Übungsaufgaben;151
17;14 Generische Bausteine;153
17.1;14.1 Generische Typen;154
17.2;14.2 Constraints;155
17.2.1;Konstruktor-Constraints;156
17.3;14.3 Vererbung bei generischen Typen;156
17.3.1;Zuweisungskompatibilität zwischen generischen Typen;157
17.3.2;Überschreiben von Methoden;158
17.3.3;Laufzeittypprüfungen;158
17.4;14.4 Generische Methoden;158
17.5;14.5 Generische Delegates;159
17.6;14.6 Nullwerte;161
17.7;14.7 Ko- und Kontravarianz bei generischen Typen;161
17.7.1;Typsichere Kovarianz;162
17.7.1.1;Abb. 14–1 Kovarianz bei generischen Typen;163
17.7.2;Typsichere Kontravarianz;163
17.7.2.1;Abb. 14–2 Kontravarianz bei generischen Typen;164
17.7.3;Beispiel;164
17.7.3.1;Abb. 14–3 Beispiel-Klassenhierarchie;164
17.8;14.8 Was geschieht hinter den Kulissen?;165
17.9;14.9 Unterschiede zu Java;165
17.10;14.10 Übungsaufgaben;166
18;15 Threads;169
18.1;15.1 Die Klasse Thread;169
18.1.1;Beispiel;171
18.2;15.2 Zustände eines Threads;172
18.2.1;Abb. 15–1 Zustandsübergangsdiagramm eines Threads;172
18.3;15.3 Abbrechen eines Threads;173
18.4;15.4 Thread-Synchronisation;174
18.4.1;Abb. 15–2 Zwei Threads führen gleichzeitig die Anweisung x = x + 1; aus;174
18.4.2;Die lock-Anweisung;174
18.4.3;Die Klasse Monitor;176
18.4.4;Wait und Pulse;176
18.4.4.1;Abb. 15–3 Systemverklemmung bei Verwendung von Pulse statt PulseAll;178
18.5;15.5 Übungsaufgaben;179
19;16 Iteratoren;181
19.1;16.1 Allgemeine Iteratoren;181
19.1.1;yield-Anweisung;183
19.2;16.2 Spezifische Iteratoren;183
19.2.1;Übersetzung spezifischer Iteratoren;185
19.3;16.3 Übungsaufgaben;186
20;17 Attribute;187
20.1;17.1 Schreibweise von Attributen;187
20.2;17.2 Parameter von Attributen;188
20.3;17.3 Attribute für spezifische Programmelemente;189
20.4;17.4 Attribut Serializable;190
20.4.1;Abb. 17–1 Ursprüngliche Liste und neue Liste nach Serialisierung und Deserialisierung;191
20.5;17.5 Attribut Conditional;192
20.6;17.6 Attribut DllImport;193
20.6.1;Abb. 17–2 Ein von einer Native-Funktion erzeugtes Fenster;193
20.7;17.7 Deklaration eigener Attribute;194
20.8;17.8 Übungsaufgaben;195
21;18 Dokumentationskommentare;197
21.1;18.1 XML-Elemente;197
21.1.1;Beispiel;198
21.2;18.2 Erzeugte XML-Datei;199
21.3;18.3 Übungsaufgaben;200
22;19 Auszug aus der .NET-Klassenbibliothek;201
22.1;Tabelle 19–1 Auszug der Namensräume und Typen der .NET-Bibliothek;202
22.2;19.1 Hilfsklassen;202
22.2.1;StringBuilder;202
22.2.2;Math;203
22.2.3;Random;204
22.2.4;Convert;204
22.3;19.2 Collections;205
22.3.1;Abb. 19–1 Auszug der wichtigsten Collection-Typen;205
22.3.2;Array;206
22.3.3;ArrayList;206
22.3.4;Hashtable;208
22.3.5;ListDictionary;209
22.3.6;SortedList;209
22.3.7;Stack;210
22.3.8;Queue;210
22.3.9;BitArray;211
22.3.10;Iterieren über Collections;212
22.3.11;Generische Collection-Typen;213
22.4;19.3 Ein-/Ausgabe;214
22.4.1;Datenströme;214
22.4.1.1;Abb. 19–2 Hierarchie der Stream-Klassen;215
22.4.2;Reader;216
22.4.2.1;Abb. 19–3 Reader-Klassen (Auszug);216
22.4.3;Writer;217
22.4.3.1;Abb. 19–4 Writer-Klassen (Auszug);217
22.4.4;File und FileInfo;218
22.4.4.1;Abb. 19–5 Auszug aus den Klassen File und FileInfo;218
22.4.5;Directory und DirectoryInfo;218
22.4.5.1;Abb. 19–6 Auszug aus den Klassen Directory und DirectoryInfo;219
22.5;19.4 Reflection;220
22.5.1;Type;220
22.5.2;Assembly;222
22.6;19.5 Übungsaufgaben;224
23;20 LINQ;227
23.1;20.1 Motivation;227
23.2;20.2 Lambda-Ausdrücke;228
23.2.1;Lambda-Ausdrücke als Parameter;229
23.2.2;Lambda-Ausdrücke als Prädikate;230
23.2.3;Lambda-Ausdrücke mit mehreren Parametern;230
23.2.4;Lambda-Ausdrücke mit Anweisungsblöcken;231
23.2.5;Beispiele;232
23.3;20.3 Erweiterungsmethoden;232
23.4;20.4 Objektinitialisierer;234
23.4.1;Initialisierer für Collections;235
23.5;20.5 Anonyme Typen;236
23.5.1;Schlüsselwort var;237
23.6;20.6 Query-Ausdrücke;238
23.6.1;Query-Syntax;239
23.6.2;Laufvariablen;240
23.6.3;Gruppierung;241
23.6.4;Joins;242
23.6.5;Gruppen-Joins;244
23.6.6;let;244
23.7;20.7 LINQ und XML;245
23.7.1;XElement und XAttribute;245
23.7.2;Erzeugen von XML-Daten aus einer Wertefolge;246
23.7.3;Erzeugen einer Wertefolge aus XML-Daten;246
23.8;20.8 Übungsaufgaben;247
24;21 Asynchrone Methoden und Parallelität;249
24.1;21.1 Asynchronität;249
24.1.1;Abb. 21–1 Synchrone und asynchrone Methodenaufrufe;249
24.2;21.2 Tasks;250
24.3;21.3 Asynchrone Methoden;252
24.3.1;Abb. 21–2 Ablauf von DoAsync(); Task ist bereits vor der await-Anweisung fertig;252
24.3.2;Abb. 21–3 Ablauf von DoAsync(); Task ist erst nach der await-Anweisung fertig;253
24.3.3;Umwandlung von synchronen in asynchrone Methoden;254
24.3.4;Einschränkungen und Hinweise;255
24.3.5;Asynchronität in Schleifen;256
24.3.5.1;Abb. 21–4 Asynchrone Operation in einer Schleife;256
24.3.6;Weiteres Beispiel;257
24.3.6.1;Abb. 21–5 Verzahnter Steuerfluss beim Aufruf von DoAsync(), GetAsync() und ReadAsync();258
24.4;21.4 Explizite Parallelität;258
24.5;21.5 Übungsaufgaben;260
25;22 Tupel;261
25.1;22.1 Tupel-Typen;261
25.2;22.2 Zuweisungen;262
25.3;22.3 Anwendungen;263
25.3.1;Funktionen mit mehreren Rückgabewerten;263
25.3.2;Tupel-Typen als Typparameter;264
25.3.3;Tupel-Typen als Projektionen;264
25.4;22.4 Zerlegung von Tupeln;265
25.4.1;Zerlegung unter Weglassung einzelner Elemente;266
25.5;22.5 Dekonstruktoren für Klassen und Structs;266
25.6;22.6 Übungsaufgaben;267
26;23 Pattern Matching;269
26.1;Pattern Matching in switch-Anweisungen;270
27;24 Interoperabilität mit COM;273
27.1;24.1 COM-Objekte von .NET aus ansprechen;274
27.1.1;Erzeugen eines Assemblies (tlbimp);274
27.1.1.1;Abb. 24–1 Ansicht von MyLibNET.dll in ildasm;275
27.1.2;Registrieren der COM-Objekte (regsvr32);275
27.1.3;Benutzung des Assemblies;276
27.1.4;Spät gebundener Methodenaufruf;276
27.2;24.2 .NET-Assemblies von COM aus ansprechen;277
27.2.1;Früh gebundener Methodenaufruf;277
27.2.2;Spät gebundener Methodenaufruf;279
27.3;24.3 Übungsaufgaben;279
27.3.1;Abb. 24–2 Beispiele für Figuren unter Microsoft Agent;279
28;25 Dynamisch getypte Variablen;281
28.1;25.1 Typ dynamic;281
28.1.1;Abb. 25–1 Alle Typen sind mit dynamic kompatibel;281
28.2;25.2 Operationen auf dynamic-Variablen;283
28.2.1;Implementierung der dynamischen Methodensuche;284
29;26 Diverses;285
29.1;26.1 Null-fähige Werttypen;285
29.1.1;Rechnen mit null-fähigen Typen;287
29.1.2;Konversion zwischen null-fähigen Typen und Originaltypen;287
29.2;26.2 Bedingter Zugriff über Referenzen;288
29.2.1;Bedingter Aufruf von Delegates;289
29.3;26.3 using static;289
29.4;26.4 Geschachtelte Methoden;290
29.5;26.5 Rückgabe von Funktionswerten by reference;291
30;27 Fallstudien;293
30.1;27.1 Anwendungen mit grafischer Benutzeroberfläche;293
30.1.1;Tabelle 27–1 Einige der in Windows Forms benötigten Typen;293
30.1.2;Spezifikation eines Dateivergleichsprogramms;294
30.1.2.1;Abb. 27–1 Benutzeroberfläche des Dateivergleichswerkzeugs;294
30.1.3;Erstellen der Benutzeroberfläche mit Visual Studio .NET;295
30.1.3.1;Abb. 27–2 Anlegen eines neuen Projekts;295
30.1.3.2;Abb. 27–3 Entwurfsfläche mit Toolbox-Palette und Property-Fenster;296
30.1.3.3;Tabelle 27–2 Properties der GUI-Elemente des Dateivergleichsprogramms;297
30.1.4;Erzeugter Code;298
30.2;27.2 Ein Web-Service für Börsenkurse;302
30.2.1;Abb. 27–4 Eine Applikation holt sich Informationen von verschiedenen Web-Services;303
30.2.2;Spezifikation eines Web-Services für Börsenkurse;303
30.2.3;Serverseitige Implementierung;303
30.2.3.1;Abb. 27–5 Von .NET generierte Seite zum Testen des Web-Services;305
30.2.4;Clientseitige Implementierung;306
30.2.4.1;Abb. 27–6 Aufruf der Web-Service-Methode GetQuote;307
30.3;27.3 Dynamische Webseiten mit ASP.NET;307
30.3.1;Abb. 27–7 Benutzeroberfläche einer Webseite zur Abfrage von Börsenkursen;308
30.3.2;Layout der Webseite;308
30.3.3;Hintergrundcode;310
30.3.4;Einbinden weiterer Klassen;311
30.3.5;Benutzung der Webseite;312
30.3.6;Interaktive Erstellung von Webseiten;312
30.3.7;Weitere Möglichkeiten von ASP.NET;312
30.4;27.4 Übungsaufgaben;313
31;A Anhang;315
31.1;A.1 Compileroptionen;315
31.1.1;Optionen zur Bestimmung der erzeugten Ausgabe;315
31.1.2;Optionen zum Einbinden von Bibliotheken;316
31.1.3;Weitere Optionen (Auswahl);316
31.1.4;Beispiele;317
31.1.4.1;Tabelle A–1 Beispiele für den Aufruf des C#-Compilers;317
31.2;A.2 Werkzeuge unter .NET;318
31.2.1;A.2.1 ildasm;318
31.2.1.1;Abb. A–1 Ansicht eines Assemblies Primes.exe in ildasm;318
31.2.1.2;Abb. A–2 Links: Manifest von Primes.exe; rechts: CIL-Code der Methode PrintPrimes;318
31.2.2;A.2.2 Globaler Assembly-Cache;319
31.2.2.1;Signieren von Assemblies;319
31.2.2.2;Verzögertes Signieren von Assemblies;320
31.2.2.3;Verwaltung des globalen Assembly-Cache;321
31.2.2.3.1;Abb. A–3 Globaler Assembly-Cache;321
31.3;A.3 Grammatik von C#;322
31.3.1;Tabelle A–2 Metazeichen in Grammatikregeln;322
31.3.2;Zeichenmengen;322
31.3.3;Namen und Konstanten;323
31.3.4;Deklarationen;323
31.3.5;Typen;325
31.3.6;Anweisungen;326
31.3.7;Ausdrücke;327
31.4;A.4 Unicode und ASCII;329
31.4.1;Tabelle A–3 Der ASCII-Zeichensatz (entspricht den ersten 128 Zeichen von Unicode);329
32;Literatur;331
33;Index;333

Über Autor(innen)

Hanspeter Mössenböck ist Professor für Informatik an der Universität Linz und Leiter des Instituts für Systemsoftware. Er beschäf-tigt sich vor allem mit Programmiersprachen, Compilern und Systemsoftware.
Als ehemaliger Mitarbeiter von Prof. Niklaus Wirth an der ETH Zürich war er Mitglied des Oberon-Teams, in dem ein Pascal-Nachfolger samt innovativem Betriebssystem entwickelt wurde. Ferner ist er Autor des Compiler-Generators Coco/R, der heute weltweit als Public-Domain-Software eingesetzt wird. Neben einem Forschungsaufenthalt bei Sun Microsystems in Kalifornien hatte er Gastprofessuren in Oxford und Budapest inne. Er ist Verfasser der Bücher "Sprechen Sie Java?" und "Objektorientierte Programmierung in Oberon-2" sowie Mitverfasser der Bücher "Die .NET-Technologie" und "Ein Compiler-Generator für Mikrocomputer".