| Inhaltsverzeichnis | 6 |
| Vorwort | 46 |
| Teil I: Grundlagen | 50 |
| 1 Einstieg in Visual Studio 2015 | 52 |
| 1.1 Die Installation von Visual Studio 2015 | 52 |
| 1.1.1 Überblick über die Produktpalette | 52 |
| 1.1.2 Anforderungen an Hard- und Software | 53 |
| 1.2 Unser allererstes VB-Programm | 54 |
| 1.2.1 Vorbereitungen | 54 |
| 1.2.2 Programm schreiben | 56 |
| 1.2.3 Programm kompilieren und testen | 56 |
| 1.2.4 Einige Erläuterungen zum Quellcode | 57 |
| 1.2.5 Konsolenanwendungen sind out | 58 |
| 1.3 Die Windows-Philosophie | 58 |
| 1.3.1 Mensch-Rechner-Dialog | 59 |
| 1.3.2 Objekt- und ereignisorientierte Programmierung | 59 |
| 1.3.3 Windows-Programmierung unter Visual Studio 2015 | 60 |
| 1.4 Die Entwicklungsumgebung Visual Studio 2015 | 62 |
| 1.4.1 Neues Projekt | 62 |
| 1.4.2 Die wichtigsten Fenster | 63 |
| 1.5 Microsofts .NET-Technologie | 65 |
| 1.5.1 Zur Geschichte von .NET | 65 |
| 1.5.2 .NET-Features und Begriffe | 67 |
| 1.6 Wichtige Neuigkeiten in Visual Studio 2015 | 75 |
| 1.6.1 Entwicklungsumgebung | 75 |
| 1.6.2 Neue VB-Sprachfeatures | 75 |
| 1.6.3 Code-Editor | 75 |
| 1.6.4 NET Framework 4.6 | 76 |
| 1.7 Praxisbeispiele | 76 |
| 1.7.1 Windows-Anwendung für Einsteiger | 76 |
| 1.7.2 Windows-Anwendung für fortgeschrittene Einsteiger | 80 |
| 2 Einführung in Visual Basic | 88 |
| 2.1 Grundbegriffe | 88 |
| 2.1.1 Anweisungen | 88 |
| 2.1.2 Bezeichner | 89 |
| 2.1.3 Kommentare | 90 |
| 2.1.4 Zeilenumbruch | 91 |
| 2.2 Datentypen, Variablen und Konstanten | 93 |
| 2.2.1 Fundamentale Typen | 93 |
| 2.2.2 Wertetypen versus Verweistypen | 94 |
| 2.2.3 Benennung von Variablen | 94 |
| 2.2.4 Deklaration von Variablen | 95 |
| 2.2.5 Typinferenz | 98 |
| 2.2.6 Konstanten deklarieren | 98 |
| 2.2.7 Gültigkeitsbereiche von Deklarationen | 99 |
| 2.2.8 Lokale Variablen mit Dim | 99 |
| 2.2.9 Lokale Variablen mit Static | 100 |
| 2.2.10 Private globale Variablen | 100 |
| 2.2.11 Public Variablen | 101 |
| 2.3 Wichtige Datentypen im Überblick | 101 |
| 2.3.1 Byte, Short, Integer, Long | 101 |
| 2.3.2 Single, Double und Decimal | 102 |
| 2.3.3 Char und String | 102 |
| 2.3.4 Date | 103 |
| 2.3.5 Boolean | 104 |
| 2.3.6 Object | 104 |
| 2.4 Konvertieren von Datentypen | 105 |
| 2.4.1 Implizite und explizite Konvertierung | 105 |
| 2.4.2 Welcher Datentyp passt zu welchem? | 106 |
| 2.4.3 Konvertierungsfunktionen | 107 |
| 2.4.4 CType-Funktion | 108 |
| 2.4.5 Konvertieren von Strings | 108 |
| 2.4.6 Die Convert-Klasse | 110 |
| 2.4.7 Die Parse-Methode | 110 |
| 2.4.8 Boxing und Unboxing | 111 |
| 2.4.9 TryCast-Operator | 112 |
| 2.4.10 Nullable Types | 112 |
| 2.5 Operatoren | 113 |
| 2.5.1 Arithmetische Operatoren | 113 |
| 2.5.2 Zuweisungsoperatoren | 114 |
| 2.5.3 Logische Operatoren | 115 |
| 2.5.4 Vergleichsoperatoren | 116 |
| 2.5.5 Rangfolge der Operatoren | 116 |
| 2.6 Kontrollstrukturen | 117 |
| 2.6.1 Verzweigungsbefehle | 117 |
| 2.6.2 Schleifenanweisungen | 120 |
| 2.7 Benutzerdefinierte Datentypen | 121 |
| 2.7.1 Enumerationen | 121 |
| 2.7.2 Strukturen | 122 |
| 2.8 Nutzerdefinierte Funktionen/Prozeduren | 125 |
| 2.8.1 Deklaration und Syntax | 125 |
| 2.8.2 Parameterübergabe allgemein | 127 |
| 2.8.3 Übergabe mit ByVal und ByRef | 128 |
| 2.8.4 Optionale Parameter | 129 |
| 2.8.5 Überladene Funktionen/Prozeduren | 129 |
| 2.9 Praxisbeispiele | 130 |
| 2.9.1 Vom PAP zum Konsolen-Programm | 130 |
| 2.9.2 Vom Konsolen- zum Windows-Programm | 132 |
| 2.9.3 Schleifenanweisungen kennen lernen | 134 |
| 2.9.4 Methoden überladen | 137 |
| 2.9.5 Eine Iterationsschleife verstehen | 139 |
| 2.9.6 Anwendungen von C# nach Visual Basic portieren | 142 |
| 3 OOP-Konzepte | 150 |
| 3.1 Strukturierter versus objektorientierter Entwurf | 150 |
| 3.1.1 Was bedeutet strukturierte Programmierung? | 150 |
| 3.1.2 Was heißt objektorientierte Programmierung? | 151 |
| 3.2 Grundbegriffe der OOP | 152 |
| 3.2.1 Objekt, Klasse, Instanz | 152 |
| 3.2.2 Kapselung und Wiederverwendbarkeit | 153 |
| 3.2.3 Vererbung und Polymorphie | 153 |
| 3.2.4 Sichtbarkeit von Klassen und ihren Mitgliedern | 154 |
| 3.2.5 Allgemeiner Aufbau einer Klasse | 155 |
| 3.3 Ein Objekt erzeugen | 156 |
| 3.3.1 Referenzieren und Instanziieren | 157 |
| 3.3.2 Klassische Initialisierung | 158 |
| 3.3.3 Objekt-Initialisierer | 158 |
| 3.3.4 Arbeiten mit dem Objekt | 158 |
| 3.3.5 Zerstören des Objekts | 159 |
| 3.4 OOP-Einführungsbeispiel | 159 |
| 3.4.1 Vorbereitungen | 159 |
| 3.4.2 Klasse definieren | 160 |
| 3.4.3 Objekt erzeugen und initialisieren | 161 |
| 3.4.4 Objekt verwenden | 161 |
| 3.4.5 Unterstützung durch die IntelliSense | 161 |
| 3.4.6 Objekt testen | 162 |
| 3.4.7 Warum unsere Klasse noch nicht optimal ist | 163 |
| 3.5 Eigenschaften | 163 |
| 3.5.1 Eigenschaften kapseln | 163 |
| 3.5.2 Eigenschaften mit Zugriffsmethoden kapseln | 166 |
| 3.5.3 Lese-/Schreibschutz für Eigenschaften | 167 |
| 3.5.4 Statische Eigenschaften | 168 |
| 3.5.5 Selbst implementierende Eigenschaften | 169 |
| 3.6 Methoden | 170 |
| 3.6.1 Öffentliche und private Methoden | 170 |
| 3.6.2 Überladene Methoden | 171 |
| 3.6.3 Statische Methoden | 172 |
| 3.7 Ereignisse | 173 |
| 3.7.1 Ereignise deklarieren | 173 |
| 3.7.2 Ereignis auslösen | 174 |
| 3.7.3 Ereignis auswerten | 174 |
| 3.7.4 Benutzerdefinierte Ereignisse (Custom Events) | 176 |
| 3.8 Arbeiten mit Konstruktor und Destruktor | 179 |
| 3.8.1 Der Konstruktor erzeugt das Objekt | 179 |
| 3.8.2 Bequemer geht’s mit einem Objekt-Initialisierer | 181 |
| 3.8.3 Destruktor und Garbage Collector räumen auf | 182 |
| 3.8.4 Mit Using den Lebenszyklus des Objekts kapseln | 184 |
| 3.9 Vererbung und Polymorphie | 185 |
| 3.9.1 Vererbungsbeziehungen im Klassendiagramm | 185 |
| 3.9.2 Überschreiben von Methoden (Method-Overriding) | 187 |
| 3.9.3 Klassen implementieren | 187 |
| 3.9.4 Objekte implementieren | 192 |
| 3.9.5 Ausblenden von Mitgliedern durch Vererbung | 193 |
| 3.9.6 Allgemeine Hinweise und Regeln zur Vererbung | 195 |
| 3.9.7 Polymorphe Methoden | 196 |
| 3.10 Besondere Klassen und Features | 198 |
| 3.10.1 Abstrakte Klassen | 198 |
| 3.10.2 Abstrakte Methoden | 199 |
| 3.10.3 Versiegelte Klassen | 199 |
| 3.10.4 Partielle Klassen | 200 |
| 3.10.5 Die Basisklasse System.Object | 202 |
| 3.10.6 Property-Accessors | 203 |
| 3.10.7 Nullbedingter Operator | 203 |
| 3.11 Schnittstellen (Interfaces) | 204 |
| 3.11.1 Definition einer Schnittstelle | 204 |
| 3.11.2 Implementieren einer Schnittstelle | 205 |
| 3.11.3 Abfragen, ob eine Schnittstelle vorhanden ist | 206 |
| 3.11.4 Mehrere Schnittstellen implementieren | 206 |
| 3.11.5 Schnittstellenprogrammierung ist ein weites Feld | 206 |
| 3.12 Praxisbeispiele | 207 |
| 3.12.1 Eigenschaften sinnvoll kapseln | 207 |
| 3.12.2 Eine statische Klasse anwenden | 210 |
| 3.12.3 Vom fetten zum dünnen Client | 212 |
| 3.12.4 Schnittstellenvererbung verstehen | 221 |
| 3.12.5 Aggregation und Vererbung gegenüberstellen | 225 |
| 3.12.6 Eine Klasse zur Matrizenrechnung entwickeln | 231 |
| 3.12.7 Rechner für komplexe Zahlen | 237 |
| 3.12.8 Formel-Rechner mit dem CodeDOM | 245 |
| 3.12.9 Einen Funktionsverlauf grafisch darstellen | 250 |
| 3.12.10 Sortieren mit IComparable/IComparer | 254 |
| 3.12.11 Objektbäume in generischen Listen abspeichern | 259 |
| 3.12.12 OOP beim Kartenspiel erlernen | 265 |
| 4 Arrays, Strings, Funktionen | 270 |
| 4.1 Datenfelder (Arrays) | 270 |
| 4.1.1 Ein Array deklarieren | 270 |
| 4.1.2 Zugriff auf Array-Elemente | 271 |
| 4.1.3 Oberen Index ermitteln | 271 |
| 4.1.4 Explizite Arraygrenzen | 271 |
| 4.1.5 Arrays erzeugen und initialisieren | 271 |
| 4.1.6 Zugriff mittels Schleife | 272 |
| 4.1.7 Mehrdimensionale Arrays | 273 |
| 4.1.8 Dynamische Arrays | 274 |
| 4.1.9 Zuweisen von Arrays | 275 |
| 4.1.10 Arrays aus Strukturvariablen | 276 |
| 4.1.11 Löschen von Arrays | 277 |
| 4.1.12 Eigenschaften und Methoden von Arrays | 277 |
| 4.1.13 Übergabe von Arrays | 280 |
| 4.2 Zeichenkettenverarbeitung | 281 |
| 4.2.1 Strings zuweisen | 281 |
| 4.2.2 Eigenschaften und Methoden eines Strings | 281 |
| 4.2.3 Kopieren eines Strings in ein Char-Array | 284 |
| 4.2.4 Wichtige (statische) Methoden der String-Klasse | 284 |
| 4.2.5 Die StringBuilder-Klasse | 286 |
| 4.3 Reguläre Ausdrücke | 289 |
| 4.3.1 Wozu braucht man reguläre Ausdrücke? | 289 |
| 4.3.2 Eine kleine Einführung | 290 |
| 4.3.3 Wichtige Methoden der Klasse Regex | 290 |
| 4.3.4 Kompilierte reguläre Ausdrücke | 292 |
| 4.3.5 RegexOptions-Enumeration | 293 |
| 4.3.6 Metazeichen (Escape-Zeichen) | 294 |
| 4.3.7 Zeichenmengen (Character Sets) | 295 |
| 4.3.8 Quantifizierer | 296 |
| 4.3.9 Zero-Width Assertions | 297 |
| 4.3.10 Gruppen | 301 |
| 4.3.11 Text ersetzen | 301 |
| 4.3.12 Text splitten | 302 |
| 4.4 Datums- und Zeitberechnungen | 303 |
| 4.4.1 Grundlegendes | 303 |
| 4.4.2 Wichtige Eigenschaften von DateTime-Variablen | 304 |
| 4.4.3 Wichtige Methoden von DateTime-Variablen | 305 |
| 4.4.4 Wichtige Mitglieder der DateTime-Struktur | 306 |
| 4.4.5 Konvertieren von Datumstrings in DateTime-Werte | 307 |
| 4.4.6 Die TimeSpan-Struktur | 307 |
| 4.5 Vordefinierten Funktionen | 309 |
| 4.5.1 Mathematik | 309 |
| 4.5.2 Datums- und Zeitfunktionen | 311 |
| 4.6 Zahlen formatieren | 313 |
| 4.6.1 Die ToString-Methode | 314 |
| 4.6.2 Die Format-Methode | 315 |
| 4.6.3 Stringinterpolation | 317 |
| 4.7 Praxisbeispiele | 317 |
| 4.7.1 Zeichenketten verarbeiten | 317 |
| 4.7.2 Zeichenketten mittels StringBuilder addieren | 320 |
| 4.7.3 Reguläre Ausdrücke testen | 324 |
| 4.7.4 Fehler bei mathematischen Operationen behandeln | 326 |
| 4.7.5 Methodenaufrufe mit Array-Parametern | 329 |
| 4.7.6 String in Array kopieren und umgekehrt | 332 |
| 4.7.7 Ein Byte-Array in einen String konvertieren | 334 |
| 4.7.8 Strukturvariablen in Arrays einsetzen | 336 |
| 5 Weitere Sprachfeatures | 340 |
| 5.1 Namespaces (Namensräume) | 340 |
| 5.1.1 Ein kleiner Überblick | 340 |
| 5.1.2 Die Imports-Anweisung | 342 |
| 5.1.3 Namespace-Alias | 342 |
| 5.1.4 Namespaces in Projekteigenschaften | 343 |
| 5.1.5 Namespace Alias Qualifizierer | 344 |
| 5.1.6 Eigene Namespaces einrichten | 344 |
| 5.2 Überladen von Operatoren | 345 |
| 5.2.1 Syntaxregeln | 345 |
| 5.2.2 Praktische Anwendung | 346 |
| 5.2.3 Konvertierungsoperatoren überladen | 347 |
| 5.3 Auflistungen (Collections) | 348 |
| 5.3.1 Beziehungen zwischen den Schnittstellen | 348 |
| 5.3.2 IEnumerable | 349 |
| 5.3.3 ICollection | 350 |
| 5.3.4 IList | 350 |
| 5.3.5 Iteratoren | 350 |
| 5.3.6 Die ArrayList-Collection | 351 |
| 5.3.7 Die Hashtable | 352 |
| 5.4 Generische Datentypen | 353 |
| 5.4.1 Wie es früher einmal war | 353 |
| 5.4.2 Typsicherheit durch Generics | 355 |
| 5.4.3 List-Collection ersetzt ArrayList | 356 |
| 5.4.4 Über die Vorzüge generischer Collections | 357 |
| 5.4.5 Typbeschränkungen durch Constraints | 358 |
| 5.4.6 Collection-Initialisierer | 359 |
| 5.4.7 Generische Methoden | 359 |
| 5.5 Delegates | 360 |
| 5.5.1 Delegates sind Methodenzeiger | 360 |
| 5.5.2 Delegate-Typ definieren | 361 |
| 5.5.3 Delegate-Objekt erzeugen | 362 |
| 5.5.4 Delegates vereinfacht instanziieren | 362 |
| 5.5.5 Relaxed Delegates | 363 |
| 5.5.6 Anonyme Methoden | 363 |
| 5.5.7 Lambda-Ausdrücke | 364 |
| 5.5.8 Lambda-Ausdrücke in der Task Parallel Library | 365 |
| 5.6 Dynamische Programmierung | 367 |
| 5.6.1 Wozu dynamische Programmierung? | 367 |
| 5.6.2 Das Prinzip der dynamischen Programmierung | 367 |
| 5.6.3 Kovarianz und Kontravarianz | 371 |
| 5.7 Weitere Datentypen | 372 |
| 5.7.1 BigInteger | 372 |
| 5.7.2 Complex | 374 |
| 5.7.3 Tuple(Of T) | 375 |
| 5.7.4 SortedSet(Of T) | 375 |
| 5.8 Praxisbeispiele | 377 |
| 5.8.1 ArrayList versus generische List | 377 |
| 5.8.2 Delegates und Lambda Expressions | 380 |
| 5.8.3 Mit dynamischem Objekt eine Datei durchsuchen | 383 |
| 6 Einführung in LINQ | 388 |
| 6.1 LINQ-Grundlagen | 388 |
| 6.1.1 Die LINQ-Architektur | 388 |
| 6.1.2 LINQ-Implementierungen | 389 |
| 6.1.3 Anonyme Typen | 389 |
| 6.1.4 Erweiterungsmethoden | 391 |
| 6.2 Abfragen mit LINQ to Objects | 392 |
| 6.2.1 Grundlegendes zur LINQ-Syntax | 392 |
| 6.2.2 Zwei alternative Schreibweisen von LINQ-Abfragen | 393 |
| 6.2.3 Übersicht der wichtigsten Abfrage-Operatoren | 395 |
| 6.3 LINQ-Abfragen im Detail | 396 |
| 6.3.1 Die Projektionsoperatoren Select und SelectMany | 397 |
| 6.3.2 Der Restriktionsoperator Where | 399 |
| 6.3.3 Die Sortierungsoperatoren OrderBy und ThenBy | 399 |
| 6.3.4 Der Gruppierungsoperator GroupBy | 401 |
| 6.3.5 Verknüpfen mit Join | 402 |
| 6.3.6 Aggregat-Operatoren | 403 |
| 6.3.7 Verzögertes Ausführen von LINQ-Abfragen | 405 |
| 6.3.8 Konvertierungsmethoden | 406 |
| 6.3.9 Abfragen mit PLINQ | 406 |
| 6.4 Praxisbeispiele | 409 |
| 6.4.1 Die Syntax von LINQ-Abfragen verstehen | 409 |
| 6.4.2 Aggregat-Abfragen mit LINQ | 412 |
| 6.4.3 LINQ im Schnelldurchgang erlernen | 414 |
| 6.4.4 Strings mit LINQ abfragen und filtern | 417 |
| 6.4.5 Duplikate aus einer Liste oder einem Array entfernen | 418 |
| 6.4.6 Arrays mit LINQ initialisieren | 421 |
| 6.4.7 Arrays per LINQ mit Zufallszahlen füllen | 423 |
| 6.4.8 Einen String mit Wiederholmuster erzeugen | 424 |
| 6.4.9 Mit LINQ Zahlen und Strings sortieren | 426 |
| 6.4.10 Mit LINQ Collections von Objekten sortieren | 427 |
| 6.4.11 Ergebnisse von LINQ-Abfragen in ein Array kopieren | 429 |
| Teil II: Technologien | 430 |
| 7 Zugriff auf das Dateisystem | 432 |
| 7.1 Grundlagen | 432 |
| 7.1.1 Klassen für Verzeichnis- und Dateioperationen | 433 |
| 7.1.2 Statische versus Instanzen-Klasse | 433 |
| 7.2 Übersichten | 434 |
| 7.2.1 Methoden der Directory-Klasse | 434 |
| 7.2.2 Methoden eines DirectoryInfo-Objekts | 435 |
| 7.2.3 Eigenschaften eines DirectoryInfo-Objekts | 435 |
| 7.2.4 Methoden der File-Klasse | 435 |
| 7.2.5 Methoden eines FileInfo-Objekts | 436 |
| 7.2.6 Eigenschaften eines FileInfo-Objekts | 437 |
| 7.3 Operationen auf Verzeichnisebene | 437 |
| 7.3.1 Existenz eines Verzeichnisses/einer Datei feststellen | 437 |
| 7.3.2 Verzeichnisse erzeugen und löschen | 438 |
| 7.3.3 Verzeichnisse verschieben und umbenennen | 439 |
| 7.3.4 Aktuelles Verzeichnis bestimmen | 439 |
| 7.3.5 Unterverzeichnisse ermitteln | 439 |
| 7.3.6 Alle Laufwerke ermitteln | 440 |
| 7.3.7 Dateien kopieren und verschieben | 441 |
| 7.3.8 Dateien umbenennen | 442 |
| 7.3.9 Dateiattribute feststellen | 442 |
| 7.3.10 Verzeichnis einer Datei ermitteln | 444 |
| 7.3.11 Alle im Verzeichnis enthaltene Dateien ermitteln | 444 |
| 7.3.12 Dateien und Unterverzeichnisse ermitteln | 444 |
| 7.4 Zugriffsberechtigungen | 445 |
| 7.4.1 ACL und ACE | 445 |
| 7.4.2 SetAccessControl-Methode | 446 |
| 7.4.3 Zugriffsrechte anzeigen | 446 |
| 7.5 Weitere wichtige Klassen | 447 |
| 7.5.1 Die Path-Klasse | 447 |
| 7.5.2 Die Klasse FileSystemWatcher | 448 |
| 7.6 Datei- und Verzeichnisdialoge | 450 |
| 7.6.1 OpenFileDialog und SaveFileDialog | 450 |
| 7.6.2 FolderBrowserDialog | 452 |
| 7.7 Praxisbeispiele | 453 |
| 7.7.1 Infos über Verzeichnisse und Dateien gewinnen | 453 |
| 7.7.2 Die Verzeichnisstruktur in eine TreeView einlesen | 456 |
| 7.7.3 Mit LINQ und RegEx Verzeichnisbäume durchsuchen | 458 |
| 8 Dateien lesen und schreiben | 464 |
| 8.1 Grundprinzip der Datenpersistenz | 464 |
| 8.1.1 Dateien und Streams | 464 |
| 8.1.2 Die wichtigsten Klassen | 465 |
| 8.1.3 Erzeugen eines Streams | 466 |
| 8.2 Dateiparameter | 466 |
| 8.2.1 FileAccess | 466 |
| 8.2.2 FileMode | 466 |
| 8.2.3 FileShare | 467 |
| 8.3 Textdateien | 467 |
| 8.3.1 Eine Textdatei beschreiben bzw. neu anlegen | 467 |
| 8.3.2 Eine Textdatei lesen | 469 |
| 8.4 Binärdateien | 471 |
| 8.4.1 Lese-/Schreibzugriff | 471 |
| 8.4.2 Die Methoden ReadAllBytes und WriteAllBytes | 471 |
| 8.4.3 BinaryReader/BinaryWriter erzeugen | 472 |
| 8.5 Sequenzielle Dateien | 472 |
| 8.5.1 Lesen und Schreiben von strukturierten Daten | 472 |
| 8.5.2 Serialisieren von Objekten | 473 |
| 8.6 Dateien verschlüsseln und komprimieren | 474 |
| 8.6.1 Das Methodenpärchen Encrypt-/Decrypt | 475 |
| 8.6.2 Verschlüsseln unter Windows Vista/7/8/10 | 475 |
| 8.6.3 Verschlüsseln mit der CryptoStream-Klasse | 476 |
| 8.6.4 Dateien komprimieren | 477 |
| 8.7 Memory Mapped Files | 478 |
| 8.7.1 Grundprinzip | 478 |
| 8.7.2 Erzeugen eines MMF | 479 |
| 8.7.3 Erstellen eines Map View | 479 |
| 8.8 Praxisbeispiele | 480 |
| 8.8.1 Auf eine Textdatei zugreifen | 480 |
| 8.8.2 Einen Objektbaum speichern | 484 |
| 8.8.3 Ein Memory Mapped File (MMF) verwenden | 491 |
| 8.8.4 Hex-Dezimal-Bytes-Konverter | 493 |
| 8.8.5 Eine Datei verschlüsseln | 497 |
| 8.8.6 Eine Datei komprimieren | 500 |
| 8.8.7 Echte ZIP-Dateien erstellen | 502 |
| 8.8.8 PDFs erstellen/exportieren | 503 |
| 8.8.9 Eine CSV-Datei erstellen | 507 |
| 8.8.10 Eine CSV-Datei mit LINQ lesen und auswerten | 510 |
| 8.8.11 Einen korrekten Dateinamen erzeugen | 512 |
| 9 Asynchrone Programmierung | 514 |
| 9.1 Übersicht | 514 |
| 9.1.1 Multitasking versus Multithreading | 515 |
| 9.1.2 Deadlocks | 516 |
| 9.1.3 Racing | 516 |
| 9.2 Programmieren mit Threads | 518 |
| 9.2.1 Einführungsbeispiel | 518 |
| 9.2.2 Wichtige Thread-Methoden | 519 |
| 9.2.3 Wichtige Thread-Eigenschaften | 521 |
| 9.2.4 Einsatz der ThreadPool-Klasse | 522 |
| 9.3 Sperrmechanismen | 524 |
| 9.3.1 Threading ohne SyncLock | 524 |
| 9.3.2 Threading mit SyncLock | 525 |
| 9.3.3 Die Monitor-Klasse | 528 |
| 9.3.4 Mutex | 531 |
| 9.3.5 Methoden für die parallele Ausführung sperren | 532 |
| 9.3.6 Semaphore | 533 |
| 9.4 Interaktion mit der Programmoberfläche | 534 |
| 9.4.1 Die Werkzeuge | 535 |
| 9.4.2 Einzelne Steuerelemente mit Invoke aktualisieren | 535 |
| 9.4.3 Mehrere Steuerelemente aktualisieren | 536 |
| 9.4.4 Ist ein Invoke-Aufruf nötig? | 537 |
| 9.4.5 Und was ist mit WPF? | 537 |
| 9.5 Timer-Threads | 539 |
| 9.6 Die BackgroundWorker-Komponente | 540 |
| 9.7 Asynchrone Programmier-Entwurfsmuster | 543 |
| 9.7.1 Kurzübersicht | 543 |
| 9.7.2 Polling | 544 |
| 9.7.3 Callback verwenden | 545 |
| 9.7.4 Callback mit Parameterübergabe verwenden | 546 |
| 9.7.5 Callback mit Zugriff auf die Programm-Oberfläche | 547 |
| 9.8 Asynchroner Aufruf beliebiger Methoden | 548 |
| 9.8.1 Die Beispielklasse | 548 |
| 9.8.2 Asynchroner Aufruf ohne Callback | 550 |
| 9.8.3 Asynchroner Aufruf mit Callback und Anzeigefunktion | 550 |
| 9.8.4 Aufruf mit Rückgabewerten (per Eigenschaft) | 551 |
| 9.8.5 Aufruf mit Rückgabewerten (per EndInvoke) | 552 |
| 9.9 Es geht auch einfacher – Async und Await | 553 |
| 9.9.1 Der Weg von synchron zu asynchron | 553 |
| 9.9.2 Achtung: Fehlerquellen! | 555 |
| 9.9.3 Eigene asynchrone Methoden entwickeln | 557 |
| 9.10 Praxisbeispiele | 559 |
| 9.10.1 Spieltrieb & Multithreading erleben | 559 |
| 9.10.2 Prozess- und Thread-Informationen gewinnen | 571 |
| 9.10.3 Ein externes Programm starten | 576 |
| 10 Die Task Parallel Library | 580 |
| 10.1 Überblick | 580 |
| 10.1.1 Parallel-Programmierung | 580 |
| 10.1.2 Möglichkeiten der TPL | 583 |
| 10.1.3 Der CLR-Threadpool | 583 |
| 10.2 Parallele Verarbeitung mit Parallel.Invoke | 584 |
| 10.2.1 Aufrufvarianten | 585 |
| 10.2.2 Einschränkungen | 586 |
| 10.3 Verwendung von Parallel.For | 586 |
| 10.3.1 Abbrechen der Verarbeitung | 588 |
| 10.3.2 Auswerten des Verarbeitungsstatus | 589 |
| 10.3.3 Und was ist mit anderen Iterator-Schrittweiten? | 589 |
| 10.4 Collections mit Parallel.ForEach verarbeiten | 590 |
| 10.5 Die Task-Klasse | 591 |
| 10.5.1 Einen Task erzeugen | 591 |
| 10.5.2 Task starten | 592 |
| 10.5.3 Datenübergabe an den Task | 593 |
| 10.5.4 Wie warte ich auf das Taskende? | 594 |
| 10.5.5 Tasks mit Rückgabewerten | 596 |
| 10.5.6 Die Verarbeitung abbrechen | 599 |
| 10.5.7 Fehlerbehandlung | 603 |
| 10.5.8 Weitere Eigenschaften | 603 |
| 10.6 Zugriff auf das Userinterface | 605 |
| 10.6.1 Task-Ende und Zugriff auf die Oberfläche | 605 |
| 10.6.2 Zugriff auf das UI aus dem Task heraus | 606 |
| 10.7 Weitere Datenstrukturen im Überblick | 608 |
| 10.7.1 Threadsichere Collections | 608 |
| 10.7.2 Primitive für die Threadsynchronisation | 609 |
| 10.8 Parallel LINQ (PLINQ) | 609 |
| 10.9 Praxisbeispiel: Spieltrieb – Version 2 | 610 |
| 10.9.1 Aufgabenstellung | 610 |
| 10.9.2 Global-Klasse | 610 |
| 10.9.3 Controller | 611 |
| 10.9.4 LKWs | 613 |
| 10.9.5 Schiff-Klasse | 614 |
| 10.9.6 Oberfläche | 616 |
| 11 Fehlersuche und Behandlung | 618 |
| 11.1 Der Debugger | 618 |
| 11.1.1 Allgemeine Beschreibung | 618 |
| 11.1.2 Die wichtigsten Fenster | 619 |
| 11.1.3 Debugging-Optionen | 622 |
| 11.1.4 Praktisches Debugging am Beispiel | 624 |
| 11.2 Arbeiten mit Debug und Trace | 628 |
| 11.2.1 Wichtige Methoden von Debug und Trace | 628 |
| 11.2.2 Besonderheiten der Trace-Klasse | 631 |
| 11.2.3 TraceListener-Objekte | 632 |
| 11.3 Caller Information | 635 |
| 11.3.1 Attribute | 635 |
| 11.3.2 Anwendung | 635 |
| 11.4 Fehlerbehandlung | 636 |
| 11.4.1 Anweisungen zur Fehlerbehandlung | 636 |
| 11.4.2 Try-Catch | 636 |
| 11.4.3 Try-Finally | 641 |
| 11.4.4 Das Standardverhalten bei Ausnahmen festlegen | 643 |
| 11.4.5 Die Exception-Klasse | 644 |
| 11.4.6 Fehler/Ausnahmen auslösen | 644 |
| 11.4.7 Eigene Fehlerklassen | 645 |
| 11.4.8 Exceptionhandling zur Entwurfszeit | 647 |
| 11.4.9 Code Contracts | 647 |
| 12 XML in Theorie und Praxis | 650 |
| 12.1 XML – etwas Theorie | 650 |
| 12.1.1 Übersicht | 650 |
| 12.1.2 Der XML-Grundaufbau | 653 |
| 12.1.3 Wohlgeformte Dokumente | 654 |
| 12.1.4 Processing Instructions (PI) | 657 |
| 12.1.5 Elemente und Attribute | 657 |
| 12.1.6 Verwendbare Zeichensätze | 659 |
| 12.2 XSD-Schemas | 661 |
| 12.2.1 XSD-Schemas und ADO.NET | 661 |
| 12.2.2 XML-Schemas in Visual Studio analysieren | 663 |
| 12.2.3 XML-Datei mit XSD-Schema erzeugen | 666 |
| 12.2.4 XSD-Schema aus einer XML-Datei erzeugen | 667 |
| 12.3 XML-Integration in Visual Basic | 668 |
| 12.3.1 XML-Literale | 668 |
| 12.3.2 Einfaches Navigieren durch späte Bindung | 671 |
| 12.3.3 Die LINQ to XML-API | 673 |
| 12.3.4 Neue XML-Dokumente erzeugen | 674 |
| 12.3.5 Laden und Sichern von XML-Dokumenten | 676 |
| 12.3.6 Navigieren in XML-Daten | 678 |
| 12.3.7 Auswählen und Filtern | 680 |
| 12.3.8 Manipulieren der XML-Daten | 680 |
| 12.3.9 XML-Dokumente transformieren | 682 |
| 12.4 Verwendung des DOM unter .NET | 685 |
| 12.4.1 Übersicht | 685 |
| 12.4.2 DOM-Integration in Visual Basic | 686 |
| 12.4.3 Laden von Dokumenten | 686 |
| 12.4.4 Erzeugen von XML-Dokumenten | 687 |
| 12.4.5 Auslesen von XML-Dateien | 689 |
| 12.4.6 Direktzugriff auf einzelne Elemente | 690 |
| 12.4.7 Einfügen von Informationen | 691 |
| 12.4.8 Suchen in den Baumzweigen | 693 |
| 12.5 Weitere Möglichkeiten der XML-Verarbeitung | 697 |
| 12.5.1 Die relationale Sicht mit XmlDataDocument | 697 |
| 12.5.2 XML-Daten aus Objektstrukturen erzeugen | 700 |
| 12.5.3 Schnelles Suchen in XML-Daten mit XPathNavigator | 703 |
| 12.5.4 Schnelles Auslesen von XML-Daten mit XmlReader | 706 |
| 12.5.5 Erzeugen von XML-Daten mit XmlWriter | 708 |
| 12.5.6 XML transformieren mit XSLT | 710 |
| 12.6 Praxisbeispiele | 712 |
| 12.6.1 Mit dem DOM in XML-Dokumenten navigieren | 712 |
| 12.6.2 XML-Daten in eine TreeView einlesen | 715 |
| 12.6.3 DataSets in XML-Strings konvertieren | 719 |
| 12.6.4 In Dokumenten mit dem XPathNavigator navigieren | 723 |
| 13 Einführung in ADO.NET | 728 |
| 13.1 Eine kleine Übersicht | 728 |
| 13.1.1 Die ADO.NET-Klassenhierarchie | 728 |
| 13.1.2 Die Klassen der Datenprovider | 729 |
| 13.1.3 Das Zusammenspiel der ADO.NET-Klassen | 732 |
| 13.2 Das Connection-Objekt | 733 |
| 13.2.1 Allgemeiner Aufbau | 733 |
| 13.2.2 OleDbConnection | 733 |
| 13.2.3 Schließen einer Verbindung | 735 |
| 13.2.4 Eigenschaften des Connection-Objekts | 735 |
| 13.2.5 Methoden des Connection-Objekts | 737 |
| 13.2.6 Der ConnectionStringBuilder | 738 |
| 13.3 Das Command-Objekt | 739 |
| 13.3.1 Erzeugen und Anwenden eines Command-Objekts | 739 |
| 13.3.2 Erzeugen mittels CreateCommand-Methode | 740 |
| 13.3.3 Eigenschaften des Command-Objekts | 740 |
| 13.3.4 Methoden des Command-Objekts | 742 |
| 13.3.5 Freigabe von Connection- und Command-Objekten | 743 |
| 13.4 Parameter-Objekte | 745 |
| 13.4.1 Erzeugen und Anwenden eines Parameter-Objekts | 745 |
| 13.4.2 Eigenschaften des Parameter-Objekts | 745 |
| 13.5 Das CommandBuilder-Objekt | 746 |
| 13.5.1 Erzeugen | 746 |
| 13.5.2 Anwenden | 747 |
| 13.6 Das DataReader-Objekt | 747 |
| 13.6.1 DataReader erzeugen | 748 |
| 13.6.2 Daten lesen | 748 |
| 13.6.3 Eigenschaften des DataReaders | 749 |
| 13.6.4 Methoden des DataReaders | 749 |
| 13.7 Das DataAdapter-Objekt | 750 |
| 13.7.1 DataAdapter erzeugen | 750 |
| 13.7.2 Command-Eigenschaften | 751 |
| 13.7.3 Fill-Methode | 752 |
| 13.7.4 Update-Methode | 753 |
| 13.8 Praxisbeispiele | 754 |
| 13.8.1 Wichtige ADO.NET-Objekte im Einsatz | 754 |
| 13.8.2 Eine Aktionsabfrage ausführen | 756 |
| 13.8.3 Eine Auswahlabfrage aufrufen | 758 |
| 13.8.4 Die Datenbank aktualisieren | 760 |
| 13.8.5 Den ConnectionString speichern | 763 |
| 14 Das DataSet | 766 |
| 14.1 Grundlegende Features des DataSets | 766 |
| 14.1.1 Die Objekthierarchie | 767 |
| 14.1.2 Die wichtigsten Klassen | 767 |
| 14.1.3 Erzeugen eines DataSets | 768 |
| 14.2 Das DataTable-Objekt | 770 |
| 14.2.1 DataTable erzeugen | 770 |
| 14.2.2 Spalten hinzufügen | 770 |
| 14.2.3 Zeilen zur DataTable hinzufügen | 771 |
| 14.2.4 Auf den Inhalt einer DataTable zugreifen | 772 |
| 14.3 Die DataView | 774 |
| 14.3.1 Erzeugen eines DataView | 774 |
| 14.3.2 Sortieren und Filtern von Datensätzen | 774 |
| 14.3.3 Suchen von Datensätzen | 775 |
| 14.4 Typisierte DataSets | 775 |
| 14.4.1 Ein typisiertes DataSet erzeugen | 776 |
| 14.4.2 Das Konzept der Datenquellen | 777 |
| 14.4.3 Typisierte DataSets und TableAdapter | 778 |
| 14.5 Die Qual der Wahl | 779 |
| 14.5.1 DataReader – der schnelle Lesezugriff | 780 |
| 14.5.2 DataSet – die Datenbank im Hauptspeicher | 780 |
| 14.5.3 Objektrelationales Mapping – die Zukunft? | 781 |
| 14.6 Praxisbeispiele | 782 |
| 14.6.1 Im DataView sortieren und filtern | 782 |
| 14.6.2 Suche nach Datensätzen | 784 |
| 14.6.3 Ein DataSet in einen XML-String serialisieren | 785 |
| 14.6.4 Untypisierte in typisierte DataSets konvertieren | 790 |
| 14.6.5 Eine LINQ to SQL-Abfrage ausführen | 795 |
| 15 Verteilen von Anwendungen | 800 |
| 15.1 ClickOnce-Deployment | 801 |
| 15.1.1 Übersicht/Einschränkungen | 801 |
| 15.1.2 Die Vorgehensweise | 802 |
| 15.1.3 Ort der Veröffentlichung | 802 |
| 15.1.4 Anwendungsdateien | 803 |
| 15.1.5 Erforderliche Komponenten | 803 |
| 15.1.6 Aktualisierungen | 804 |
| 15.1.7 Veröffentlichungsoptionen | 805 |
| 15.1.8 Veröffentlichen | 806 |
| 15.1.9 Verzeichnisstruktur | 806 |
| 15.1.10 Der Webpublishing-Assistent | 808 |
| 15.1.11 Neue Versionen erstellen | 809 |
| 15.2 InstallShield | 809 |
| 15.2.1 Installation | 809 |
| 15.2.2 Aktivieren | 810 |
| 15.2.3 Ein neues Setup-Projekt | 810 |
| 15.2.4 Finaler Test | 818 |
| 15.3 Hilfedateien programmieren | 818 |
| 15.3.1 Der HTML Help Workshop | 819 |
| 15.3.2 Bedienung am Beispiel | 820 |
| 15.3.3 Hilfedateien in die VB-Anwendung einbinden | 822 |
| 15.3.4 Eine alternative Hilfe-IDE verwenden | 826 |
| 16 Weitere Techniken | 828 |
| 16.1 Zugriff auf die Zwischenablage | 828 |
| 16.1.1 Das Clipboard-Objekt | 828 |
| 16.1.2 Zwischenablage-Funktionen für Textboxen | 830 |
| 16.2 Arbeiten mit der Registry | 830 |
| 16.2.1 Allgemeines | 831 |
| 16.2.2 Registry-Unterstützung in .NET | 832 |
| 16.3 .NET-Reflection | 834 |
| 16.3.1 Übersicht | 834 |
| 16.3.2 Assembly laden | 834 |
| 16.3.3 Mittels GetType und Type Informationen sammeln | 835 |
| 16.3.4 Dynamisches Laden von Assemblies | 837 |
| 16.4 Praxisbeispiele | 839 |
| 16.4.1 Zugriff auf die Registry | 839 |
| 16.4.2 Dateiverknüpfungen erzeugen | 841 |
| 16.4.3 Die Zwischenablage überwachen und anzeigen | 843 |
| 16.4.4 Die WIA-Library kennenlernen | 846 |
| 16.4.5 Auf eine Webcam zugreifen | 858 |
| 16.4.6 Auf den Scanner zugreifen | 860 |
| 16.4.7 OpenOffice.org Writer per OLE steuern | 864 |
| 16.4.8 Nutzer und Gruppen des Systems ermitteln | 872 |
| 16.4.9 Testen, ob Nutzer in einer Gruppe enthalten ist | 873 |
| 16.4.10 Testen, ob der Nutzer ein Administrator ist | 875 |
| 16.4.11 Die IP-Adressen des Computers bestimmen | 876 |
| 16.4.12 Die IP-Adresse über den Hostnamen bestimmen | 877 |
| 16.4.13 Diverse Systeminformationen ermitteln | 878 |
| 16.4.14 Sound per MCI aufnehmen | 887 |
| 16.4.15 Mikrofonpegel anzeigen | 890 |
| 16.4.16 Pegeldiagramm aufzeichnen | 892 |
| 16.4.17 Sound-und Video-Dateien per MCI abspielen | 896 |
| 17 Konsolenanwendungen | 904 |
| 17.1 Grundaufbau/Konzepte | 904 |
| 17.1.1 Unser Hauptprogramm – Module1.vb | 905 |
| 17.1.2 Rückgabe eines Fehlerstatus | 906 |
| 17.1.3 Parameterübergabe | 907 |
| 17.1.4 Zugriff auf die Umgebungsvariablen | 908 |
| 17.2 Die Kommandozentrale: System.Console | 909 |
| 17.2.1 Eigenschaften | 909 |
| 17.2.2 Methoden/Ereignisse | 910 |
| 17.2.3 Textausgaben | 911 |
| 17.2.4 Farbangaben | 912 |
| 17.2.5 Tastaturabfragen | 913 |
| 17.2.6 Arbeiten mit Streamdaten | 914 |
| 17.3 Praxisbeispiel: Farbige Konsolenanwendung | 915 |
| Teil III: Windows Apps | 918 |
| 18 Erste Schritte | 920 |
| 18.1 Grundkonzepte und Begriffe | 920 |
| 18.1.1 Windows Runtime (WinRT) | 920 |
| 18.1.2 Windows Store Apps | 921 |
| 18.1.3 Fast and Fluid | 922 |
| 18.1.4 Process Sandboxing und Contracts | 923 |
| 18.1.5 .NET WinRT-Profil | 925 |
| 18.1.6 Language Projection | 925 |
| 18.1.7 Vollbildmodus – war da was? | 927 |
| 18.1.8 Windows Store | 927 |
| 18.1.9 Zielplattformen | 928 |
| 18.2 Entwurfsumgebung | 929 |
| 18.2.1 Betriebssystem | 929 |
| 18.2.2 Windows-Simulator | 929 |
| 18.2.3 Remote-Debugging | 932 |
| 18.3 Ein (kleines) Einstiegsbeispiel | 933 |
| 18.3.1 Aufgabenstellung | 933 |
| 18.3.2 Quellcode | 933 |
| 18.3.3 Oberflächenentwurf | 936 |
| 18.3.4 Installation und Test | 938 |
| 18.3.5 Touchscreen | 940 |
| 18.3.6 Fazit | 940 |
| 18.4 Weitere Details zu WinRT | 942 |
| 18.4.1 Wo ist WinRT einzuordnen? | 943 |
| 18.4.2 Die WinRT-API | 944 |
| 18.4.3 Wichtige WinRT-Namespaces | 946 |
| 18.4.4 Der Unterbau | 947 |
| 18.5 Praxisbeispiel | 949 |
| 18.5.1 WinRT in Desktop-Applikationen nutzen | 949 |
| 19 App-Oberflächen entwerfen | 954 |
| 19.1 Grundkonzepte | 954 |
| 19.1.1 XAML (oder HTML 5) für die Oberfläche | 955 |
| 19.1.2 Die Page, der Frame und das Window | 956 |
| 19.1.3 Das Befehlsdesign | 958 |
| 19.1.4 Die Navigationsdesigns | 960 |
| 19.1.5 Achtung: Fingereingabe! | 961 |
| 19.1.6 Verwendung von Schriftarten | 961 |
| 19.2 Seitenauswahl und -navigation | 962 |
| 19.2.1 Die Startseite festlegen | 962 |
| 19.2.2 Navigation und Parameterübergabe | 962 |
| 19.2.3 Den Seitenstatus erhalten | 963 |
| 19.3 App-Darstellung | 964 |
| 19.3.1 Vollbild quer und hochkant | 964 |
| 19.3.2 Was ist mit Andocken und Füllmodus? | 965 |
| 19.3.3 Reagieren auf die Änderung | 965 |
| 19.4 Skalieren von Apps | 967 |
| 19.5 Praxisbeispiele | 969 |
| 19.5.1 Seitennavigation und Parameterübergabe | 969 |
| 19.5.2 Die Fensterkopfzeile anpassen | 971 |
| 20 Die wichtigsten Controls | 974 |
| 20.1 Einfache WinRT-Controls | 974 |
| 20.1.1 TextBlock, RichTextBlock | 974 |
| 20.1.2 Button, HyperlinkButton, RepeatButton | 977 |
| 20.1.3 CheckBox, RadioButton, ToggleButton, ToggleSwitch | 979 |
| 20.1.4 TextBox, PasswordBox, RichEditBox | 980 |
| 20.1.5 Image | 984 |
| 20.1.6 ScrollBar, Slider, ProgressBar, ProgressRing | 985 |
| 20.1.7 Border, Ellipse, Rectangle | 987 |
| 20.2 Layout-Controls | 988 |
| 20.2.1 Canvas | 988 |
| 20.2.2 StackPanel | 989 |
| 20.2.3 ScrollViewer | 989 |
| 20.2.4 Grid | 990 |
| 20.2.5 VariableSizedWrapGrid | 991 |
| 20.2.6 SplitView | 992 |
| 20.2.7 Pivot | 996 |
| 20.2.8 RelativPanel | 997 |
| 20.3 Listendarstellungen | 999 |
| 20.3.1 ComboBox, ListBox | 999 |
| 20.3.2 ListView | 1003 |
| 20.3.3 GridView | 1005 |
| 20.3.4 FlipView | 1007 |
| 20.4 Sonstige Controls | 1009 |
| 20.4.1 CaptureElement | 1009 |
| 20.4.2 MediaElement | 1010 |
| 20.4.3 Frame | 1012 |
| 20.4.4 WebView | 1012 |
| 20.4.5 ToolTip | 1013 |
| 20.4.6 CalendarDatePicker | 1015 |
| 20.4.7 DatePicker/TimePicker | 1016 |
| 20.5 Praxisbeispiele | 1016 |
| 20.5.1 Einen StringFormat-Konverter implementieren | 1016 |
| 20.5.2 Besonderheiten der TextBox kennen lernen | 1018 |
| 20.5.3 Daten in der GridView gruppieren | 1021 |
| 20.5.4 Das SemanticZoom-Control verwenden | 1026 |
| 20.5.5 Die CollectionViewSource verwenden | 1031 |
| 20.5.6 Zusammenspiel ListBox/AppBar | 1034 |
| 21 Apps im Detail | 1038 |
| 21.1 Ein Windows App-Projekt im Detail | 1038 |
| 21.1.1 Contracts und Extensions | 1039 |
| 21.1.2 AssemblyInfo.vb | 1039 |
| 21.1.3 Verweise | 1041 |
| 21.1.4 App.xaml und App.xaml.vb | 1041 |
| 21.1.5 Package.appxmanifest | 1042 |
| 21.1.6 Application1_TemporaryKey.pfx | 1047 |
| 21.1.7 MainPage.xaml & MainPage.xaml.vb | 1047 |
| 21.1.8 Assets/Symbole | 1048 |
| 21.1.9 Nach dem Kompilieren | 1048 |
| 21.2 Der Lebenszyklus einer Windows App | 1048 |
| 21.2.1 Möglichkeiten der Aktivierung von Apps | 1050 |
| 21.2.2 Der Splash Screen | 1052 |
| 21.2.3 Suspending | 1052 |
| 21.2.4 Resuming | 1053 |
| 21.2.5 Beenden von Apps | 1054 |
| 21.2.6 Die Ausnahmen von der Regel | 1055 |
| 21.2.7 Debuggen | 1055 |
| 21.3 Daten speichern und laden | 1059 |
| 21.3.1 Grundsätzliche Überlegungen | 1059 |
| 21.3.2 Worauf und wie kann ich zugreifen? | 1060 |
| 21.3.3 Das AppData-Verzeichnis | 1060 |
| 21.3.4 Das Anwendungs-Installationsverzeichnis | 1062 |
| 21.3.5 Das Downloads-Verzeichnis | 1063 |
| 21.3.6 Sonstige Verzeichnisse | 1064 |
| 21.3.7 Anwendungsdaten lokal sichern und laden | 1065 |
| 21.3.8 Daten in der Cloud ablegen/laden (Roaming) | 1067 |
| 21.3.9 Aufräumen | 1068 |
| 21.3.10 Sensible Informationen speichern | 1069 |
| 21.4 Praxisbeispiele | 1070 |
| 21.4.1 Die Auto-Play-Funktion unterstützen | 1070 |
| 21.4.2 Einen zusätzlichen Splash Screen einsetzen | 1074 |
| 21.4.3 Eine Dateiverknüpfung erstellen | 1076 |
| 22 App-Techniken | 1082 |
| 22.1 Arbeiten mit Dateien/Verzeichnissen | 1082 |
| 22.1.1 Verzeichnisinformationen auflisten | 1082 |
| 22.1.2 Unterverzeichnisse auflisten | 1085 |
| 22.1.3 Verzeichnisse erstellen/löschen | 1087 |
| 22.1.4 Dateien auflisten | 1088 |
| 22.1.5 Dateien erstellen/schreiben/lesen | 1090 |
| 22.1.6 Dateien kopieren/umbenennen/löschen | 1094 |
| 22.1.7 Verwenden der Dateipicker | 1096 |
| 22.1.8 StorageFile-/StorageFolder-Objekte speichern | 1100 |
| 22.1.9 Verwenden der Most Recently Used-Liste | 1102 |
| 22.2 Datenaustausch zwischen Apps/Programmen | 1103 |
| 22.2.1 Zwischenablage | 1103 |
| 22.2.2 Teilen von Inhalten | 1110 |
| 22.2.3 Eine App als Freigabeziel verwenden | 1113 |
| 22.2.4 Zugriff auf die Kontaktliste | 1114 |
| 22.3 Spezielle Oberflächenelemente | 1116 |
| 22.3.1 MessageDialog | 1116 |
| 22.3.2 ContentDialog | 1119 |
| 22.3.3 Popup-Benachrichtigungen | 1121 |
| 22.3.4 PopUp/Flyouts | 1128 |
| 22.3.5 Das PopupMenu einsetzen | 1132 |
| 22.3.6 Eine AppBar verwenden | 1134 |
| 22.4 Datenbanken und Windows Store Apps | 1138 |
| 22.4.1 Der Retter in der Not: SQLite! | 1138 |
| 22.4.2 Verwendung/Kurzüberblick | 1138 |
| 22.4.3 Installation | 1140 |
| 22.4.4 Wie kommen wir zu einer neuen Datenbank? | 1141 |
| 22.4.5 Wie werden die Daten manipuliert? | 1145 |
| 22.5 Vertrieb der App | 1146 |
| 22.5.1 Verpacken der App | 1146 |
| 22.5.2 App-Installation per Skript | 1148 |
| 22.6 Ein Blick auf die App-Schwachstellen | 1150 |
| 22.6.1 Quellcodes im Installationsverzeichnis | 1150 |
| 22.6.2 Zugriff auf den App-Datenordner | 1152 |
| 22.7 Praxisbeispiele | 1152 |
| 22.7.1 Ein Verzeichnis auf Änderungen überwachen | 1152 |
| 22.7.2 Eine App als Freigabeziel verwenden | 1155 |
| 22.7.3 ToastNotifications einfach erzeugen | 1160 |
| Anhang | 1166 |
| A Glossar | 1168 |
| B Wichtige Dateiextensions | 1174 |
| Index | 1176 |
| Download-Kapitel | 30 |
