Visual C# 2012 Einstieg und Praxis

Visual C# 2012 Einstieg und Praxis
29 mm
Teil 1: Grundlagen
der Programmierung
• C# und das .NET Framework
• Visual Studio
• Prozedurale und objektorientierte Programmierung
Teil 2: Fortgeschrittene
Programmiertechniken
• Generics, Delegaten,
Ereignisse
• Exceptionhandling
• Lambda-Kalkül, anonyme
Methoden, Expression
Trees
• Ressourcenmanagement
• Dynamische Objekte
• Collections
• LINQ
• Dateien und Verzeichnisse
• Unit Tests mit NUnit und
RhinoMock
Teil 3: Oberflächenprogrammierung und Datenbanken
• Konsolenanwendungen
• Windows Presentation
Foundation
• Zugriff auf Datenbanken
mit ADO.NET
Teil 4: Parallele Programmierung und Windows Store
Apps
• Threads
• Task Parallel Library
• Windows Store Apps
Die Programmiersprache C# bietet sowohl unerfahrenen
Programmierern als auch Umsteigern einen einfachen
Einstieg in die Welt der Windows-Programmierung.
Dabei gibt Microsoft dem Entwickler nicht nur die Sprache selbst, sondern mit der Entwicklungsumgebung
Visual Studio und dem .NET Framework auch das richtige
Werkzeug an die Hand.
Martel
ISBN 978-3-8266-9195-9
Christopher Martel vermittelt in diesem Buch einen
Einstieg in Visual C# und das .NET Framework. Anhand
verschiedener Beispiele erlernen Sie die Konzepte von
C# sowie das Erzeugen einfacher Oberflächen und die
Datenbankanbindung. Darüber hinaus geht der Autor
auch auf die parallele Programmierung und auf das
Erstellen von Windows Store Apps ein.
Anhand von Übungsaufgaben am Ende der Kapitel kann
der Leser das Gelernte überprüfen und festigen. Die
Lösungen, Beispielprojekte, sowie die Express-Versionen
von Visual Studio 2012 stehen auf der beiliegenden
Begleit-DVD zur Verfügung.
ISBN 978-3-8266-5936-2
Dieses Buch ist vor allem für Ein- und Umsteiger in die
Windows-Programmierung mit C# gedacht. Dennoch
können auch erfahrene Entwickler Informationen für
den Praxisalltag mitnehmen.
Auf der DVD:
• Express-Versionen von Visual Studio 2012
• Sourcecode zu den Beispielen und Übungen
• Weitere Kapitel zu Windows Forms und GDI+
Christopher
Martel
ISBN 978-3-8266-9240-6
Teil 5: Praxisbeispiel
• Fallbeispiel: Filmausleihe
Einstieg und Praxis
Aus dem Inhalt:
Außerdem bei mitp:
Visual C# 2012
Oberflächenprogrammierung mit WPF, Datenabfrage mit
LINQ, Datenbankanbindung mit SQL Server 2012 Express
und ADO.NET
Testen mithilfe von Unit Tests
Parallele und asynchrone Programmierung mit Threads und
der Task Parallel Library
Windows Store App Programmierung
Auf der DVD:
Express-Versionen
von Visual Studio
2012
Visual C# 2012
Einstieg und Praxis
(D) € 24,95
ISBN
ISBN978-3-8266-9440-0
978-3-8266-9440-0
978-3-8266-9440-0_umschlag_K3.indd Alle Seiten
Inklusive DVD-ROM
Arduino Praxiseinstieg – Softcover 170 x 240 mm – Reihe: Programmierung
11/6/2012 1:12:28 PM
Inhaltsverzeichnis
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
Teil I
Grundlagen der Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
1
1.1
1.2
C# und das .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Sprache C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.1
Die Common Language Specification (CLS). . . . . . . . . . . . . . . . . . . .
1.2.2
Das Common Type System (CTS) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.3
Die Common Language Runtime (CLR) . . . . . . . . . . . . . . . . . . . . . . .
Assemblies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Metadaten und das Manifest. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
21
22
24
24
24
25
25
26
Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Installation und Einrichtung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.1
Systemvoraussetzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.2
Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Projekte in Visual Studio erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1
Konsolenanwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2
Windows-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.3
Klassenbibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
28
28
28
29
31
34
37
38
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kommentare. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1
Einzeilige Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.2
Mehrzeilige Kommentare. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.3
Xml-Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Variablen und Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.1
Bezeichner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.2
Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.3
Primitive Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.4
Typkonvertierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.5
Überlauf überprüfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.6
Konstanten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.7
Enumerationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.8
Das Schlüsselwort var . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
39
39
39
40
41
41
41
42
44
46
47
47
49
1.3
1.4
1.5
2
2.1
2.2
2.3
3
3.1
3.2
5
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
3.3
3.4
3.5
3.6
4
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.1
Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.2
Zuweisungsoperatoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.3
Logische Operatoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.4
Bitweise Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.5
Rangfolge der Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kontrollstrukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.1
Verzweigungen mit if und else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.2
Fallunterscheidungen mit switch/case . . . . . . . . . . . . . . . . . . . . . . . .
3.4.3
For-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.4
Schleifen mit while/do…while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.5
Foreach-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
49
52
53
55
55
56
56
59
61
63
64
65
65
Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Typsystem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1
Referenz- vs. Wertetypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.2
Boxing und Unboxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.3
Das Schlüsselwort null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.4
Nullable-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Klassen vs. Structs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1
Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.2
Zugriffsmodifizierer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.3
Das Schlüsselwort readonly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.4
Partielle Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.5
Ein Objekt erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.6 Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.7
Der this-Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.8
Structs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1
Methoden definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.2
Methoden ohne Rückgabewert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.3
Methoden mit Rückgabewert. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.4
Methodenparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.5
Das Schlüsselwort ref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.6
Das Schlüsselwort out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.7
Methodenüberladung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Operatorenüberladung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.1
Eigenschaften definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.2
Automatische Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Objektinitialisierer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Statische Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.7.1
Das Schlüsselwort static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.7.2
Der statische Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
67
67
69
70
70
72
72
72
74
75
75
76
78
80
83
83
84
85
86
88
89
89
90
92
92
94
95
95
95
97
6
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
4.8
4.9
4.10
4.11
4.12
4.13
4.14
5
5.1
5.2
5.3
5.4
Die Basisklasse Sytem.Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vererbung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9.1
Vererbung definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9.2 Polymorphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9.3
Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9.4 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9.5
Versiegelte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9.6 Das Schlüsselwort is . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9.7
Das Schlüsselwort as. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.10.1 Namensräume definieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.10.2 Namespace-Alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.10.3 Namensraum-Alias-Qualifizierer. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Region-Anweisung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispielimplementierung einer Personalverwaltung . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
98
98
100
104
106
107
111
111
112
112
113
114
116
116
117
125
125
Crashkurs: Erzeugen von Windows-Oberflächen . . . . . . . . . . . . . . . . . . . . . . .
Die grafische Oberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1.1
Die Menüleiste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1.2
Nummerntasten und Eingabefelder . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1.3
Kontextmenüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die logische Komponente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1
Die Schnittstelle ICalculatable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.2
Die Klasse Addition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.3
Die Klasse Subtraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.4
Die Klasse Multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.5
Die Klasse Division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.6
Die Klasse Calculator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenführen der grafischen und logischen Komponenten. . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
127
127
127
128
129
130
130
131
131
131
131
132
132
136
Teil 2 Fortgeschrittene Programmiertechniken . . . . . . . . . . . . . . . . . . . . . . . . . 137
6
6.1
6.2
Fortgeschrittene C#-Techniken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.1.1
Generische Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.1.2
Constraints. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Delegaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2.1
Anonyme Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2.2 Lambda-Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2.3
Delegaten des .NET Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
139
139
143
144
145
149
150
153
7
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
7
7.1
7.2
7.3
7.4
7.5
Ereignisse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3.1
Prinzip der Ereignisbenachrichtigung . . . . . . . . . . . . . . . . . . . . . . . .
6.3.2
Ereignisse deklarieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3.3
Ereignisse auslösen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exceptionhandling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.1
try-catch-Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.2 try-finally-Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.3
Ausnahmen erneut auslösen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.4 Eigene Ausnahmen definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zeichenkettenverarbeitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5.1
Methoden und Eigenschaften der Klasse string . . . . . . . . . . . . . . . . .
6.5.2
Zeichenformatierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5.3
Datum- und Uhrzeitformatierung. . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5.4
Die Klasse StringBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erweiterungsmethoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Objekte vergleichen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.7.1
Die Methode Equals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.7.2
Die Methode ReferenceEquals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.7.3
Die Schnittstelle IEquatable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.7.4
Die Schnittstelle IComparable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ressourcenmanagement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.1
Die Schnittstelle IDisposable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.2 Destruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.3
Das Dispose-Pattern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.4 Objekte aufräumen mit dem using-Block. . . . . . . . . . . . . . . . . . . . . .
Dynamische Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.9.1
Die Dynamic Language Runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.9.2 Das Schlüsselwort dynamic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
154
154
155
159
160
161
163
164
165
166
166
170
171
173
175
176
178
179
179
180
183
183
184
185
186
187
187
188
191
191
Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übersicht der Collection-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.1
Arrays erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.2
Methoden und Eigenschaften der Klasse Array . . . . . . . . . . . . . . . . .
7.2.3
Mehrdimensionale Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.4
Indexer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.5
Ko- und Kontravarianz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Collection-Initialisierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Klasse List<T>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4.1
Eine Liste erzeugen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4.2
Methoden und Eigenschaften der Klasse List<T> . . . . . . . . . . . . . . .
Die Klasse Dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.5.1
Ein Dictionary erzeugen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.5.2
Methoden und Eigenschaften der Klasse Dictionary . . . . . . . . . . . . .
193
194
196
197
199
202
203
204
205
206
207
208
209
211
212
8
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
7.6
7.7
7.8
7.9
7.10
8
8.1
8.2
8.3
8.4
8.5
8.6
9
9.1
9.2
9.3
Das Interface IEnumerable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.6.1
Das Iterator-Prinzip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.6.2
foreach-Schleifen und Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.6.3
Das Schlüsselwort yield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Weitere Collection-Klassen des .NET Frameworks . . . . . . . . . . . . . . . . . . . . .
Erweiterung der Personalverwaltungssoftware . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
214
215
218
219
221
222
228
228
LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was ist LINQ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1.1
Die LINQ-Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1.2
Anonyme Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1.3
Verzögerte Ausführung von Abfragen. . . . . . . . . . . . . . . . . . . . . . . . .
Die Standardabfrageoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2.1
Der Where-Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2.2
Die Operatoren Select und SelectMany . . . . . . . . . . . . . . . . . . . . . . . .
8.2.3
Der Operator OfType . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2.4
Der Operator FirstOrDefault . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2.5
Das Schlüsselwort let . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Expression Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.4.1
LINQ to Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.4.2
LINQ to XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
229
229
231
232
233
235
242
243
244
245
246
247
249
249
250
252
252
Dateien und Verzeichnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verzeichnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.1
Die Klassen Directory und DirectoryInfo . . . . . . . . . . . . . . . . . . . . . .
9.1.2
Verzeichnis erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.3
Verzeichnis löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.4
Verzeichnis umbenennen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.5
Verzeichnis verschieben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.6
Verzeichnis bestimmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.1
Die Klassen File und FileInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.2 Datei erzeugen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.3
Datei löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.4 Datei umbenennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.5
Datei verschieben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.6 Datei kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.7
Dateien in einem Verzeichnis ermitteln . . . . . . . . . . . . . . . . . . . . . . .
9.2.8 Dateiinformationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.9 Dateien überwachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Laufwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.3.1
Laufwerke ermitteln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
255
256
256
259
259
260
260
260
262
263
267
268
268
268
268
269
270
272
274
275
9
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
9.4
9.5
9.6
Zugriffsberechtigungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Klasse Path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dateien lesen und schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.6.1
Textdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.6.2 Binärdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.6.3
Serialisieren von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dialoge für die Datei- und Ordnerverwaltung. . . . . . . . . . . . . . . . . . . . . . . . . .
9.7.1
Die Klasse OpenFileDialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.7.2
Die Klasse SaveFileDialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dateien verschlüsseln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.8.1
Verschlüsseln mit der Klasse File . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.8.2 Verschlüsseln mit der Klasse CryptoStream. . . . . . . . . . . . . . . . . . . .
Dateien komprimieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
276
279
280
281
283
284
286
286
288
288
289
289
290
291
292
Unit Tests. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Framework NUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1.1 Einen Unit Test definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1.2 Mehrere Testfälle definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1.3 Ausnahmen testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Abhängigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2.1 Dependency Injection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2.2 Mocks und Stubs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2.3 Das Framework RhinoMock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
293
293
294
298
298
299
300
301
302
304
Teil III Oberflächenprogrammierung und Datenbanken . . . . . . . . . . . . . . . . .
305
11
11.1
11.2
Konsolenanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Grundlagen zu Konsolenanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Klasse Console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.2.1 Methoden und Eigenschaften der Klasse Console . . . . . . . . . . . . . . .
Farbangaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tastaturabfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konsolen und Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispielimplementierung: Protokollierung von Eingaben
über eine Konsole in einer Textdatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
307
307
309
309
318
319
320
321
Windows Presentation Foundation (WPF) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was ist die Windows Presentation Foundation?. . . . . . . . . . . . . . . . . . . . . . . .
12.1.1 Extensible Markup Language (XAML) . . . . . . . . . . . . . . . . . . . . . . . .
12.1.2 Ein Fenster erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
325
326
326
329
9.7
9.8
9.9
9.10
9.11
10
10.1
10.2
10.3
11.3
11.4
11.5
11.6
11.7
11.8
11.9
12
12.1
321
323
323
10
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
12.2
12.3
12.4
12.5
12.6
12.7
12.8
12.1.3 Eigenschaften festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.1.4 Dependency Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.1.5 Attached Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.1.6 Ereignisse in XAML definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.1.7 Die Klasse App. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Allgemeine Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.1 Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.2 TextBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.3 TextBlock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.4 PasswordBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.5 Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.6 CheckBox und RadioButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.7 Toggle- und RepeatButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.8 Border. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.9 Image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.10 ProgressBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2.11 ToolTip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Layout definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.1 StackPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.2 WrapPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.3 DockPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.4 Canvas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.5 Grid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.6 UniformGrid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.7 ScrollViewer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.8 ViewBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.9 Ausrichtung des Inhalts eines Layoutcontainers . . . . . . . . . . . . . . . .
12.3.10 Dynamische Inhalte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Styles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.4.1 Styles definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.4.2 Ressourcen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.4.3 Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.5.1 Templates definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.6.1 Bindungsrichtung festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.6.2 Änderungen verfolgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.6.3 Daten konvertieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.6.4 Datenquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.6.5 Validierung von Eingaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Visuelle Effekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.7.1 Transformationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.7.2 Effekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.7.3 Animationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispielanwendung: Erfassung von Personendaten . . . . . . . . . . . . . . . . . . . . .
330
332
334
335
336
337
340
341
341
342
343
344
345
345
346
347
348
349
349
350
351
352
353
356
357
357
358
360
361
361
363
364
365
365
368
371
372
373
375
376
377
377
381
382
385
11
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
12.9
12.10
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
391
391
13
13.1
13.2
Zugriff auf Datenbanken mit ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einführung in relationale Datenbanken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übersicht der ADO.NET-Klassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.2.1 Erzeugen einer Datenbank in Visual Studio. . . . . . . . . . . . . . . . . . . .
Mit Datenbanken arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.3.1
Eine Verbindung herstellen mit der Klasse SqlConnection . . . . . . .
13.3.2 Datenbankabfragen erzeugen mit der Klasse SqlCommand. . . . . . .
13.3.3 Daten aus der Datenbank lesen mit der Klasse SqlDataReader . . . .
13.3.4 Transaktionen durchführen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
DataSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.4.1 Wichtige Klassen im Zusammenhang mit DataSets . . . . . . . . . . . .
13.4.2 Die Klasse SqlDataAdapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.4.3 Die Klasse DataTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.4.4 Daten anzeigen mit der Klasse DataView . . . . . . . . . . . . . . . . . . . . . .
13.4.5 Typisierte DataSets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das ADO.NET Entity Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.5.1
Möglichkeiten des Mappings zwischen Klassen und
Datenbanken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.5.2 Eine Verbindung zur Datenbank erzeugen . . . . . . . . . . . . . . . . . . . .
13.5.3 Daten abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.5.4 Daten einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.5.5 Daten aktualisieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.5.6 Daten löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Datenbindung an das Steuerelement DataGridView . . . . . . . . . . . . . . . . . . . .
13.6.1 Datenbindung unter WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispielanwendung: Personalverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
393
393
396
397
401
401
403
406
407
408
409
409
411
415
417
419
Teil III Parallele Programmierung und Windows 8 . . . . . . . . . . . . . . . . . . . . . .
437
14
14.1
439
439
441
443
448
449
453
454
454
455
13.3
13.4
13.5
13.6
13.7
13.8
13.9
14.2
14.3
Parallele Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was ist parallele Programmierung?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.1.1 Die Klasse Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.1.2 Die Klasse BackgroundWorker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Task Parallel Library. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.2.1 Die Klasse Task . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Klasse Parallel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.3.1 Parallel.Invoke. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.3.2 Parallel.For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.3.3 Parallel.ForEach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
420
424
424
425
425
426
426
427
428
435
436
12
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
14.4
14.5
14.6
14.7
14.8
15
15.1
15.2
15.3
15.4
15.5
15.6
15.7
Die Operatoren await und async. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
PLINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.5.1 Der Operator AsOrdered. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.5.2 Der Operator AsSequential. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.5.3 Der Operator ForAll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Parallele Collections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.6.1 Die Klasse ConcurrentStack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.6.2 Die Klasse ConcurrentQueue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.6.3 Die Klasse ConcurrentBag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
455
457
457
458
459
459
460
461
462
463
463
Windows Store Apps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Windows Runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Grundlagen einer Windows Store App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2.1 Designprinzipien. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2.2 Visual-Studio-Vorlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2.3 Das Application Manifest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2.4 Die Klasse App. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2.5 Aufbau einer Seite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2.6 Der Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Navigation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.3.1
Navigationsmuster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.3.2 Die Klasse Frame. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.3.3 Navigation innerhalb einer Windows Store App . . . . . . . . . . . . . . . .
Die AppBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.4.1 Eine AppBar erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.4.2 Eine NavBar erzeugen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.4.3 Flyouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Layout, Kacheln und der Lebenszyklus einer Windows Store App . . . . . . . . .
15.5.1
Ansichtstypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.5.2 Die Klasse VisualStateManager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.5.3 Livekacheln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.5.4 Das Tombstone-Modell. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.5.5 Contracts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung einer Windows Store App anhand einer Personalverwaltung . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
465
466
467
467
469
470
474
475
476
477
477
479
481
483
484
485
486
489
489
491
493
496
498
499
512
Teil V Praxisbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
16
16.1
16.2
Fallbeispiel: Filmausleihe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erzeugung der Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.2.1 Einbindung der Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
517
517
518
520
13
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Inhaltsverzeichnis
16.3
16.4
16.5
A
A.1
A.2
A.3
A.4
A.5
Das Enterprise-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.3.1 Die zentrale Klasse RentalService . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.3.2 Erweiterung der Entitätsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.3.3 Ausnahmenbehandlung für Fortgeschrittene . . . . . . . . . . . . . . . . . .
Die Oberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.4.1 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.4.2 Die Ansichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.4.3 Zusammenführen der Ansichten . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.4.4 Abfangen von unerwarteten Ausnahmen . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
520
520
528
528
530
530
534
554
556
557
Installationsanleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Systemvoraussetzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
»Visual Studio Express 2012 für Windows Desktop«
bzw. »Visual Studio Express 2012 für Windows 8«. . . . . . . . . . . . . . . . .
Einbinden der Visual Studio Express-Installations-DVD
bzw. -ISO-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programminstallation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Auswerfen der Installationsdatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
559
559
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
559
560
560
562
563
14
© des Titels »Visual C# 2012 - Einstieg und Praxis« (ISBN 978-3-8266-9442-4) 2012 by Verlagsgruppe Hüthig Jehle Rehm GmbH, Heidelberg.
Nähere Informationen unter: http://www.mitp.de/9442
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement