Visual Basic 2015 - Grundlagen, Profiwissen und Rezepte

1 - Inhaltsverzeichnis [Seite 6]
2 - Vorwort [Seite 46]
3 - Teil I: Grundlagen [Seite 50]
3.1 - 1 Einstieg in Visual Studio 2015 [Seite 52]
3.1.1 - 1.1 Die Installation von Visual Studio 2015 [Seite 52]
3.1.1.1 - 1.1.1 Überblick über die Produktpalette [Seite 52]
3.1.1.2 - 1.1.2 Anforderungen an Hard- und Software [Seite 53]
3.1.2 - 1.2 Unser allererstes VB-Programm [Seite 54]
3.1.2.1 - 1.2.1 Vorbereitungen [Seite 54]
3.1.2.2 - 1.2.2 Programm schreiben [Seite 56]
3.1.2.3 - 1.2.3 Programm kompilieren und testen [Seite 56]
3.1.2.4 - 1.2.4 Einige Erläuterungen zum Quellcode [Seite 57]
3.1.2.5 - 1.2.5 Konsolenanwendungen sind out [Seite 58]
3.1.3 - 1.3 Die Windows-Philosophie [Seite 58]
3.1.3.1 - 1.3.1 Mensch-Rechner-Dialog [Seite 59]
3.1.3.2 - 1.3.2 Objekt- und ereignisorientierte Programmierung [Seite 59]
3.1.3.3 - 1.3.3 Windows-Programmierung unter Visual Studio 2015 [Seite 60]
3.1.4 - 1.4 Die Entwicklungsumgebung Visual Studio 2015 [Seite 62]
3.1.4.1 - 1.4.1 Neues Projekt [Seite 62]
3.1.4.2 - 1.4.2 Die wichtigsten Fenster [Seite 63]
3.1.5 - 1.5 Microsofts .NET-Technologie [Seite 65]
3.1.5.1 - 1.5.1 Zur Geschichte von .NET [Seite 65]
3.1.5.2 - 1.5.2 .NET-Features und Begriffe [Seite 67]
3.1.6 - 1.6 Wichtige Neuigkeiten in Visual Studio 2015 [Seite 75]
3.1.6.1 - 1.6.1 Entwicklungsumgebung [Seite 75]
3.1.6.2 - 1.6.2 Neue VB-Sprachfeatures [Seite 75]
3.1.6.3 - 1.6.3 Code-Editor [Seite 75]
3.1.6.4 - 1.6.4 NET Framework 4.6 [Seite 76]
3.1.7 - 1.7 Praxisbeispiele [Seite 76]
3.1.7.1 - 1.7.1 Windows-Anwendung für Einsteiger [Seite 76]
3.1.7.2 - 1.7.2 Windows-Anwendung für fortgeschrittene Einsteiger [Seite 80]
3.2 - 2 Einführung in Visual Basic [Seite 88]
3.2.1 - 2.1 Grundbegriffe [Seite 88]
3.2.1.1 - 2.1.1 Anweisungen [Seite 88]
3.2.1.2 - 2.1.2 Bezeichner [Seite 89]
3.2.1.3 - 2.1.3 Kommentare [Seite 90]
3.2.1.4 - 2.1.4 Zeilenumbruch [Seite 91]
3.2.2 - 2.2 Datentypen, Variablen und Konstanten [Seite 93]
3.2.2.1 - 2.2.1 Fundamentale Typen [Seite 93]
3.2.2.2 - 2.2.2 Wertetypen versus Verweistypen [Seite 94]
3.2.2.3 - 2.2.3 Benennung von Variablen [Seite 94]
3.2.2.4 - 2.2.4 Deklaration von Variablen [Seite 95]
3.2.2.5 - 2.2.5 Typinferenz [Seite 98]
3.2.2.6 - 2.2.6 Konstanten deklarieren [Seite 98]
3.2.2.7 - 2.2.7 Gültigkeitsbereiche von Deklarationen [Seite 99]
3.2.2.8 - 2.2.8 Lokale Variablen mit Dim [Seite 99]
3.2.2.9 - 2.2.9 Lokale Variablen mit Static [Seite 100]
3.2.2.10 - 2.2.10 Private globale Variablen [Seite 100]
3.2.2.11 - 2.2.11 Public Variablen [Seite 101]
3.2.3 - 2.3 Wichtige Datentypen im Überblick [Seite 101]
3.2.3.1 - 2.3.1 Byte, Short, Integer, Long [Seite 101]
3.2.3.2 - 2.3.2 Single, Double und Decimal [Seite 102]
3.2.3.3 - 2.3.3 Char und String [Seite 102]
3.2.3.4 - 2.3.4 Date [Seite 103]
3.2.3.5 - 2.3.5 Boolean [Seite 104]
3.2.3.6 - 2.3.6 Object [Seite 104]
3.2.4 - 2.4 Konvertieren von Datentypen [Seite 105]
3.2.4.1 - 2.4.1 Implizite und explizite Konvertierung [Seite 105]
3.2.4.2 - 2.4.2 Welcher Datentyp passt zu welchem? [Seite 106]
3.2.4.3 - 2.4.3 Konvertierungsfunktionen [Seite 107]
3.2.4.4 - 2.4.4 CType-Funktion [Seite 108]
3.2.4.5 - 2.4.5 Konvertieren von Strings [Seite 108]
3.2.4.6 - 2.4.6 Die Convert-Klasse [Seite 110]
3.2.4.7 - 2.4.7 Die Parse-Methode [Seite 110]
3.2.4.8 - 2.4.8 Boxing und Unboxing [Seite 111]
3.2.4.9 - 2.4.9 TryCast-Operator [Seite 112]
3.2.4.10 - 2.4.10 Nullable Types [Seite 112]
3.2.5 - 2.5 Operatoren [Seite 113]
3.2.5.1 - 2.5.1 Arithmetische Operatoren [Seite 113]
3.2.5.2 - 2.5.2 Zuweisungsoperatoren [Seite 114]
3.2.5.3 - 2.5.3 Logische Operatoren [Seite 115]
3.2.5.4 - 2.5.4 Vergleichsoperatoren [Seite 116]
3.2.5.5 - 2.5.5 Rangfolge der Operatoren [Seite 116]
3.2.6 - 2.6 Kontrollstrukturen [Seite 117]
3.2.6.1 - 2.6.1 Verzweigungsbefehle [Seite 117]
3.2.6.2 - 2.6.2 Schleifenanweisungen [Seite 120]
3.2.7 - 2.7 Benutzerdefinierte Datentypen [Seite 121]
3.2.7.1 - 2.7.1 Enumerationen [Seite 121]
3.2.7.2 - 2.7.2 Strukturen [Seite 122]
3.2.8 - 2.8 Nutzerdefinierte Funktionen/Prozeduren [Seite 125]
3.2.8.1 - 2.8.1 Deklaration und Syntax [Seite 125]
3.2.8.2 - 2.8.2 Parameterübergabe allgemein [Seite 127]
3.2.8.3 - 2.8.3 Übergabe mit ByVal und ByRef [Seite 128]
3.2.8.4 - 2.8.4 Optionale Parameter [Seite 129]
3.2.8.5 - 2.8.5 Überladene Funktionen/Prozeduren [Seite 129]
3.2.9 - 2.9 Praxisbeispiele [Seite 130]
3.2.9.1 - 2.9.1 Vom PAP zum Konsolen-Programm [Seite 130]
3.2.9.2 - 2.9.2 Vom Konsolen- zum Windows-Programm [Seite 132]
3.2.9.3 - 2.9.3 Schleifenanweisungen kennen lernen [Seite 134]
3.2.9.4 - 2.9.4 Methoden überladen [Seite 137]
3.2.9.5 - 2.9.5 Eine Iterationsschleife verstehen [Seite 139]
3.2.9.6 - 2.9.6 Anwendungen von C# nach Visual Basic portieren [Seite 142]
3.3 - 3 OOP-Konzepte [Seite 150]
3.3.1 - 3.1 Strukturierter versus objektorientierter Entwurf [Seite 150]
3.3.1.1 - 3.1.1 Was bedeutet strukturierte Programmierung? [Seite 150]
3.3.1.2 - 3.1.2 Was heißt objektorientierte Programmierung? [Seite 151]
3.3.2 - 3.2 Grundbegriffe der OOP [Seite 152]
3.3.2.1 - 3.2.1 Objekt, Klasse, Instanz [Seite 152]
3.3.2.2 - 3.2.2 Kapselung und Wiederverwendbarkeit [Seite 153]
3.3.2.3 - 3.2.3 Vererbung und Polymorphie [Seite 153]
3.3.2.4 - 3.2.4 Sichtbarkeit von Klassen und ihren Mitgliedern [Seite 154]
3.3.2.5 - 3.2.5 Allgemeiner Aufbau einer Klasse [Seite 155]
3.3.3 - 3.3 Ein Objekt erzeugen [Seite 156]
3.3.3.1 - 3.3.1 Referenzieren und Instanziieren [Seite 157]
3.3.3.2 - 3.3.2 Klassische Initialisierung [Seite 158]
3.3.3.3 - 3.3.3 Objekt-Initialisierer [Seite 158]
3.3.3.4 - 3.3.4 Arbeiten mit dem Objekt [Seite 158]
3.3.3.5 - 3.3.5 Zerstören des Objekts [Seite 159]
3.3.4 - 3.4 OOP-Einführungsbeispiel [Seite 159]
3.3.4.1 - 3.4.1 Vorbereitungen [Seite 159]
3.3.4.2 - 3.4.2 Klasse definieren [Seite 160]
3.3.4.3 - 3.4.3 Objekt erzeugen und initialisieren [Seite 161]
3.3.4.4 - 3.4.4 Objekt verwenden [Seite 161]
3.3.4.5 - 3.4.5 Unterstützung durch die IntelliSense [Seite 161]
3.3.4.6 - 3.4.6 Objekt testen [Seite 162]
3.3.4.7 - 3.4.7 Warum unsere Klasse noch nicht optimal ist [Seite 163]
3.3.5 - 3.5 Eigenschaften [Seite 163]
3.3.5.1 - 3.5.1 Eigenschaften kapseln [Seite 163]
3.3.5.2 - 3.5.2 Eigenschaften mit Zugriffsmethoden kapseln [Seite 166]
3.3.5.3 - 3.5.3 Lese-/Schreibschutz für Eigenschaften [Seite 167]
3.3.5.4 - 3.5.4 Statische Eigenschaften [Seite 168]
3.3.5.5 - 3.5.5 Selbst implementierende Eigenschaften [Seite 169]
3.3.6 - 3.6 Methoden [Seite 170]
3.3.6.1 - 3.6.1 Öffentliche und private Methoden [Seite 170]
3.3.6.2 - 3.6.2 Überladene Methoden [Seite 171]
3.3.6.3 - 3.6.3 Statische Methoden [Seite 172]
3.3.7 - 3.7 Ereignisse [Seite 173]
3.3.7.1 - 3.7.1 Ereignise deklarieren [Seite 173]
3.3.7.2 - 3.7.2 Ereignis auslösen [Seite 174]
3.3.7.3 - 3.7.3 Ereignis auswerten [Seite 174]
3.3.7.4 - 3.7.4 Benutzerdefinierte Ereignisse (Custom Events) [Seite 176]
3.3.8 - 3.8 Arbeiten mit Konstruktor und Destruktor [Seite 179]
3.3.8.1 - 3.8.1 Der Konstruktor erzeugt das Objekt [Seite 179]
3.3.8.2 - 3.8.2 Bequemer geht's mit einem Objekt-Initialisierer [Seite 181]
3.3.8.3 - 3.8.3 Destruktor und Garbage Collector räumen auf [Seite 182]
3.3.8.4 - 3.8.4 Mit Using den Lebenszyklus des Objekts kapseln [Seite 184]
3.3.9 - 3.9 Vererbung und Polymorphie [Seite 185]
3.3.9.1 - 3.9.1 Vererbungsbeziehungen im Klassendiagramm [Seite 185]
3.3.9.2 - 3.9.2 Überschreiben von Methoden (Method-Overriding) [Seite 187]
3.3.9.3 - 3.9.3 Klassen implementieren [Seite 187]
3.3.9.4 - 3.9.4 Objekte implementieren [Seite 192]
3.3.9.5 - 3.9.5 Ausblenden von Mitgliedern durch Vererbung [Seite 193]
3.3.9.6 - 3.9.6 Allgemeine Hinweise und Regeln zur Vererbung [Seite 195]
3.3.9.7 - 3.9.7 Polymorphe Methoden [Seite 196]
3.3.10 - 3.10 Besondere Klassen und Features [Seite 198]
3.3.10.1 - 3.10.1 Abstrakte Klassen [Seite 198]
3.3.10.2 - 3.10.2 Abstrakte Methoden [Seite 199]
3.3.10.3 - 3.10.3 Versiegelte Klassen [Seite 199]
3.3.10.4 - 3.10.4 Partielle Klassen [Seite 200]
3.3.10.5 - 3.10.5 Die Basisklasse System.Object [Seite 202]
3.3.10.6 - 3.10.6 Property-Accessors [Seite 203]
3.3.10.7 - 3.10.7 Nullbedingter Operator [Seite 203]
3.3.11 - 3.11 Schnittstellen (Interfaces) [Seite 204]
3.3.11.1 - 3.11.1 Definition einer Schnittstelle [Seite 204]
3.3.11.2 - 3.11.2 Implementieren einer Schnittstelle [Seite 205]
3.3.11.3 - 3.11.3 Abfragen, ob eine Schnittstelle vorhanden ist [Seite 206]
3.3.11.4 - 3.11.4 Mehrere Schnittstellen implementieren [Seite 206]
3.3.11.5 - 3.11.5 Schnittstellenprogrammierung ist ein weites Feld [Seite 206]
3.3.12 - 3.12 Praxisbeispiele [Seite 207]
3.3.12.1 - 3.12.1 Eigenschaften sinnvoll kapseln [Seite 207]
3.3.12.2 - 3.12.2 Eine statische Klasse anwenden [Seite 210]
3.3.12.3 - 3.12.3 Vom fetten zum dünnen Client [Seite 212]
3.3.12.4 - 3.12.4 Schnittstellenvererbung verstehen [Seite 221]
3.3.12.5 - 3.12.5 Aggregation und Vererbung gegenüberstellen [Seite 225]
3.3.12.6 - 3.12.6 Eine Klasse zur Matrizenrechnung entwickeln [Seite 231]
3.3.12.7 - 3.12.7 Rechner für komplexe Zahlen [Seite 237]
3.3.12.8 - 3.12.8 Formel-Rechner mit dem CodeDOM [Seite 245]
3.3.12.9 - 3.12.9 Einen Funktionsverlauf grafisch darstellen [Seite 250]
3.3.12.10 - 3.12.10 Sortieren mit IComparable/IComparer [Seite 254]
3.3.12.11 - 3.12.11 Objektbäume in generischen Listen abspeichern [Seite 259]
3.3.12.12 - 3.12.12 OOP beim Kartenspiel erlernen [Seite 265]
3.4 - 4 Arrays, Strings, Funktionen [Seite 270]
3.4.1 - 4.1 Datenfelder (Arrays) [Seite 270]
3.4.1.1 - 4.1.1 Ein Array deklarieren [Seite 270]
3.4.1.2 - 4.1.2 Zugriff auf Array-Elemente [Seite 271]
3.4.1.3 - 4.1.3 Oberen Index ermitteln [Seite 271]
3.4.1.4 - 4.1.4 Explizite Arraygrenzen [Seite 271]
3.4.1.5 - 4.1.5 Arrays erzeugen und initialisieren [Seite 271]
3.4.1.6 - 4.1.6 Zugriff mittels Schleife [Seite 272]
3.4.1.7 - 4.1.7 Mehrdimensionale Arrays [Seite 273]
3.4.1.8 - 4.1.8 Dynamische Arrays [Seite 274]
3.4.1.9 - 4.1.9 Zuweisen von Arrays [Seite 275]
3.4.1.10 - 4.1.10 Arrays aus Strukturvariablen [Seite 276]
3.4.1.11 - 4.1.11 Löschen von Arrays [Seite 277]
3.4.1.12 - 4.1.12 Eigenschaften und Methoden von Arrays [Seite 277]
3.4.1.13 - 4.1.13 Übergabe von Arrays [Seite 280]
3.4.2 - 4.2 Zeichenkettenverarbeitung [Seite 281]
3.4.2.1 - 4.2.1 Strings zuweisen [Seite 281]
3.4.2.2 - 4.2.2 Eigenschaften und Methoden eines Strings [Seite 281]
3.4.2.3 - 4.2.3 Kopieren eines Strings in ein Char-Array [Seite 284]
3.4.2.4 - 4.2.4 Wichtige (statische) Methoden der String-Klasse [Seite 284]
3.4.2.5 - 4.2.5 Die StringBuilder-Klasse [Seite 286]
3.4.3 - 4.3 Reguläre Ausdrücke [Seite 289]
3.4.3.1 - 4.3.1 Wozu braucht man reguläre Ausdrücke? [Seite 289]
3.4.3.2 - 4.3.2 Eine kleine Einführung [Seite 290]
3.4.3.3 - 4.3.3 Wichtige Methoden der Klasse Regex [Seite 290]
3.4.3.4 - 4.3.4 Kompilierte reguläre Ausdrücke [Seite 292]
3.4.3.5 - 4.3.5 RegexOptions-Enumeration [Seite 293]
3.4.3.6 - 4.3.6 Metazeichen (Escape-Zeichen) [Seite 294]
3.4.3.7 - 4.3.7 Zeichenmengen (Character Sets) [Seite 295]
3.4.3.8 - 4.3.8 Quantifizierer [Seite 296]
3.4.3.9 - 4.3.9 Zero-Width Assertions [Seite 297]
3.4.3.10 - 4.3.10 Gruppen [Seite 301]
3.4.3.11 - 4.3.11 Text ersetzen [Seite 301]
3.4.3.12 - 4.3.12 Text splitten [Seite 302]
3.4.4 - 4.4 Datums- und Zeitberechnungen [Seite 303]
3.4.4.1 - 4.4.1 Grundlegendes [Seite 303]
3.4.4.2 - 4.4.2 Wichtige Eigenschaften von DateTime-Variablen [Seite 304]
3.4.4.3 - 4.4.3 Wichtige Methoden von DateTime-Variablen [Seite 305]
3.4.4.4 - 4.4.4 Wichtige Mitglieder der DateTime-Struktur [Seite 306]
3.4.4.5 - 4.4.5 Konvertieren von Datumstrings in DateTime-Werte [Seite 307]
3.4.4.6 - 4.4.6 Die TimeSpan-Struktur [Seite 307]
3.4.5 - 4.5 Vordefinierten Funktionen [Seite 309]
3.4.5.1 - 4.5.1 Mathematik [Seite 309]
3.4.5.2 - 4.5.2 Datums- und Zeitfunktionen [Seite 311]
3.4.6 - 4.6 Zahlen formatieren [Seite 313]
3.4.6.1 - 4.6.1 Die ToString-Methode [Seite 314]
3.4.6.2 - 4.6.2 Die Format-Methode [Seite 315]
3.4.6.3 - 4.6.3 Stringinterpolation [Seite 317]
3.4.7 - 4.7 Praxisbeispiele [Seite 317]
3.4.7.1 - 4.7.1 Zeichenketten verarbeiten [Seite 317]
3.4.7.2 - 4.7.2 Zeichenketten mittels StringBuilder addieren [Seite 320]
3.4.7.3 - 4.7.3 Reguläre Ausdrücke testen [Seite 324]
3.4.7.4 - 4.7.4 Fehler bei mathematischen Operationen behandeln [Seite 326]
3.4.7.5 - 4.7.5 Methodenaufrufe mit Array-Parametern [Seite 329]
3.4.7.6 - 4.7.6 String in Array kopieren und umgekehrt [Seite 332]
3.4.7.7 - 4.7.7 Ein Byte-Array in einen String konvertieren [Seite 334]
3.4.7.8 - 4.7.8 Strukturvariablen in Arrays einsetzen [Seite 336]
3.5 - 5 Weitere Sprachfeatures [Seite 340]
3.5.1 - 5.1 Namespaces (Namensräume) [Seite 340]
3.5.1.1 - 5.1.1 Ein kleiner Überblick [Seite 340]
3.5.1.2 - 5.1.2 Die Imports-Anweisung [Seite 342]
3.5.1.3 - 5.1.3 Namespace-Alias [Seite 342]
3.5.1.4 - 5.1.4 Namespaces in Projekteigenschaften [Seite 343]
3.5.1.5 - 5.1.5 Namespace Alias Qualifizierer [Seite 344]
3.5.1.6 - 5.1.6 Eigene Namespaces einrichten [Seite 344]
3.5.2 - 5.2 Überladen von Operatoren [Seite 345]
3.5.2.1 - 5.2.1 Syntaxregeln [Seite 345]
3.5.2.2 - 5.2.2 Praktische Anwendung [Seite 346]
3.5.2.3 - 5.2.3 Konvertierungsoperatoren überladen [Seite 347]
3.5.3 - 5.3 Auflistungen (Collections) [Seite 348]
3.5.3.1 - 5.3.1 Beziehungen zwischen den Schnittstellen [Seite 348]
3.5.3.2 - 5.3.2 IEnumerable [Seite 349]
3.5.3.3 - 5.3.3 ICollection [Seite 350]
3.5.3.4 - 5.3.4 IList [Seite 350]
3.5.3.5 - 5.3.5 Iteratoren [Seite 350]
3.5.3.6 - 5.3.6 Die ArrayList-Collection [Seite 351]
3.5.3.7 - 5.3.7 Die Hashtable [Seite 352]
3.5.4 - 5.4 Generische Datentypen [Seite 353]
3.5.4.1 - 5.4.1 Wie es früher einmal war [Seite 353]
3.5.4.2 - 5.4.2 Typsicherheit durch Generics [Seite 355]
3.5.4.3 - 5.4.3 List-Collection ersetzt ArrayList [Seite 356]
3.5.4.4 - 5.4.4 Über die Vorzüge generischer Collections [Seite 357]
3.5.4.5 - 5.4.5 Typbeschränkungen durch Constraints [Seite 358]
3.5.4.6 - 5.4.6 Collection-Initialisierer [Seite 359]
3.5.4.7 - 5.4.7 Generische Methoden [Seite 359]
3.5.5 - 5.5 Delegates [Seite 360]
3.5.5.1 - 5.5.1 Delegates sind Methodenzeiger [Seite 360]
3.5.5.2 - 5.5.2 Delegate-Typ definieren [Seite 361]
3.5.5.3 - 5.5.3 Delegate-Objekt erzeugen [Seite 362]
3.5.5.4 - 5.5.4 Delegates vereinfacht instanziieren [Seite 362]
3.5.5.5 - 5.5.5 Relaxed Delegates [Seite 363]
3.5.5.6 - 5.5.6 Anonyme Methoden [Seite 363]
3.5.5.7 - 5.5.7 Lambda-Ausdrücke [Seite 364]
3.5.5.8 - 5.5.8 Lambda-Ausdrücke in der Task Parallel Library [Seite 365]
3.5.6 - 5.6 Dynamische Programmierung [Seite 367]
3.5.6.1 - 5.6.1 Wozu dynamische Programmierung? [Seite 367]
3.5.6.2 - 5.6.2 Das Prinzip der dynamischen Programmierung [Seite 367]
3.5.6.3 - 5.6.3 Kovarianz und Kontravarianz [Seite 371]
3.5.7 - 5.7 Weitere Datentypen [Seite 372]
3.5.7.1 - 5.7.1 BigInteger [Seite 372]
3.5.7.2 - 5.7.2 Complex [Seite 374]
3.5.7.3 - 5.7.3 Tuple(Of T) [Seite 375]
3.5.7.4 - 5.7.4 SortedSet(Of T) [Seite 375]
3.5.8 - 5.8 Praxisbeispiele [Seite 377]
3.5.8.1 - 5.8.1 ArrayList versus generische List [Seite 377]
3.5.8.2 - 5.8.2 Delegates und Lambda Expressions [Seite 380]
3.5.8.3 - 5.8.3 Mit dynamischem Objekt eine Datei durchsuchen [Seite 383]
3.6 - 6 Einführung in LINQ [Seite 388]
3.6.1 - 6.1 LINQ-Grundlagen [Seite 388]
3.6.1.1 - 6.1.1 Die LINQ-Architektur [Seite 388]
3.6.1.2 - 6.1.2 LINQ-Implementierungen [Seite 389]
3.6.1.3 - 6.1.3 Anonyme Typen [Seite 389]
3.6.1.4 - 6.1.4 Erweiterungsmethoden [Seite 391]
3.6.2 - 6.2 Abfragen mit LINQ to Objects [Seite 392]
3.6.2.1 - 6.2.1 Grundlegendes zur LINQ-Syntax [Seite 392]
3.6.2.2 - 6.2.2 Zwei alternative Schreibweisen von LINQ-Abfragen [Seite 393]
3.6.2.3 - 6.2.3 Übersicht der wichtigsten Abfrage-Operatoren [Seite 395]
3.6.3 - 6.3 LINQ-Abfragen im Detail [Seite 396]
3.6.3.1 - 6.3.1 Die Projektionsoperatoren Select und SelectMany [Seite 397]
3.6.3.2 - 6.3.2 Der Restriktionsoperator Where [Seite 399]
3.6.3.3 - 6.3.3 Die Sortierungsoperatoren OrderBy und ThenBy [Seite 399]
3.6.3.4 - 6.3.4 Der Gruppierungsoperator GroupBy [Seite 401]
3.6.3.5 - 6.3.5 Verknüpfen mit Join [Seite 402]
3.6.3.6 - 6.3.6 Aggregat-Operatoren [Seite 403]
3.6.3.7 - 6.3.7 Verzögertes Ausführen von LINQ-Abfragen [Seite 405]
3.6.3.8 - 6.3.8 Konvertierungsmethoden [Seite 406]
3.6.3.9 - 6.3.9 Abfragen mit PLINQ [Seite 406]
3.6.4 - 6.4 Praxisbeispiele [Seite 409]
3.6.4.1 - 6.4.1 Die Syntax von LINQ-Abfragen verstehen [Seite 409]
3.6.4.2 - 6.4.2 Aggregat-Abfragen mit LINQ [Seite 412]
3.6.4.3 - 6.4.3 LINQ im Schnelldurchgang erlernen [Seite 414]
3.6.4.4 - 6.4.4 Strings mit LINQ abfragen und filtern [Seite 417]
3.6.4.5 - 6.4.5 Duplikate aus einer Liste oder einem Array entfernen [Seite 418]
3.6.4.6 - 6.4.6 Arrays mit LINQ initialisieren [Seite 421]
3.6.4.7 - 6.4.7 Arrays per LINQ mit Zufallszahlen füllen [Seite 423]
3.6.4.8 - 6.4.8 Einen String mit Wiederholmuster erzeugen [Seite 424]
3.6.4.9 - 6.4.9 Mit LINQ Zahlen und Strings sortieren [Seite 426]
3.6.4.10 - 6.4.10 Mit LINQ Collections von Objekten sortieren [Seite 427]
3.6.4.11 - 6.4.11 Ergebnisse von LINQ-Abfragen in ein Array kopieren [Seite 429]
4 - Teil II: Technologien [Seite 430]
4.1 - 7 Zugriff auf das Dateisystem [Seite 432]
4.1.1 - 7.1 Grundlagen [Seite 432]
4.1.1.1 - 7.1.1 Klassen für Verzeichnis- und Dateioperationen [Seite 433]
4.1.1.2 - 7.1.2 Statische versus Instanzen-Klasse [Seite 433]
4.1.2 - 7.2 Übersichten [Seite 434]
4.1.2.1 - 7.2.1 Methoden der Directory-Klasse [Seite 434]
4.1.2.2 - 7.2.2 Methoden eines DirectoryInfo-Objekts [Seite 435]
4.1.2.3 - 7.2.3 Eigenschaften eines DirectoryInfo-Objekts [Seite 435]
4.1.2.4 - 7.2.4 Methoden der File-Klasse [Seite 435]
4.1.2.5 - 7.2.5 Methoden eines FileInfo-Objekts [Seite 436]
4.1.2.6 - 7.2.6 Eigenschaften eines FileInfo-Objekts [Seite 437]
4.1.3 - 7.3 Operationen auf Verzeichnisebene [Seite 437]
4.1.3.1 - 7.3.1 Existenz eines Verzeichnisses/einer Datei feststellen [Seite 437]
4.1.3.2 - 7.3.2 Verzeichnisse erzeugen und löschen [Seite 438]
4.1.3.3 - 7.3.3 Verzeichnisse verschieben und umbenennen [Seite 439]
4.1.3.4 - 7.3.4 Aktuelles Verzeichnis bestimmen [Seite 439]
4.1.3.5 - 7.3.5 Unterverzeichnisse ermitteln [Seite 439]
4.1.3.6 - 7.3.6 Alle Laufwerke ermitteln [Seite 440]
4.1.3.7 - 7.3.7 Dateien kopieren und verschieben [Seite 441]
4.1.3.8 - 7.3.8 Dateien umbenennen [Seite 442]
4.1.3.9 - 7.3.9 Dateiattribute feststellen [Seite 442]
4.1.3.10 - 7.3.10 Verzeichnis einer Datei ermitteln [Seite 444]
4.1.3.11 - 7.3.11 Alle im Verzeichnis enthaltene Dateien ermitteln [Seite 444]
4.1.3.12 - 7.3.12 Dateien und Unterverzeichnisse ermitteln [Seite 444]
4.1.4 - 7.4 Zugriffsberechtigungen [Seite 445]
4.1.4.1 - 7.4.1 ACL und ACE [Seite 445]
4.1.4.2 - 7.4.2 SetAccessControl-Methode [Seite 446]
4.1.4.3 - 7.4.3 Zugriffsrechte anzeigen [Seite 446]
4.1.5 - 7.5 Weitere wichtige Klassen [Seite 447]
4.1.5.1 - 7.5.1 Die Path-Klasse [Seite 447]
4.1.5.2 - 7.5.2 Die Klasse FileSystemWatcher [Seite 448]
4.1.6 - 7.6 Datei- und Verzeichnisdialoge [Seite 450]
4.1.6.1 - 7.6.1 OpenFileDialog und SaveFileDialog [Seite 450]
4.1.6.2 - 7.6.2 FolderBrowserDialog [Seite 452]
4.1.7 - 7.7 Praxisbeispiele [Seite 453]
4.1.7.1 - 7.7.1 Infos über Verzeichnisse und Dateien gewinnen [Seite 453]
4.1.7.2 - 7.7.2 Die Verzeichnisstruktur in eine TreeView einlesen [Seite 456]
4.1.7.3 - 7.7.3 Mit LINQ und RegEx Verzeichnisbäume durchsuchen [Seite 458]
4.2 - 8 Dateien lesen und schreiben [Seite 464]
4.2.1 - 8.1 Grundprinzip der Datenpersistenz [Seite 464]
4.2.1.1 - 8.1.1 Dateien und Streams [Seite 464]
4.2.1.2 - 8.1.2 Die wichtigsten Klassen [Seite 465]
4.2.1.3 - 8.1.3 Erzeugen eines Streams [Seite 466]
4.2.2 - 8.2 Dateiparameter [Seite 466]
4.2.2.1 - 8.2.1 FileAccess [Seite 466]
4.2.2.2 - 8.2.2 FileMode [Seite 466]
4.2.2.3 - 8.2.3 FileShare [Seite 467]
4.2.3 - 8.3 Textdateien [Seite 467]
4.2.3.1 - 8.3.1 Eine Textdatei beschreiben bzw. neu anlegen [Seite 467]
4.2.3.2 - 8.3.2 Eine Textdatei lesen [Seite 469]
4.2.4 - 8.4 Binärdateien [Seite 471]
4.2.4.1 - 8.4.1 Lese-/Schreibzugriff [Seite 471]
4.2.4.2 - 8.4.2 Die Methoden ReadAllBytes und WriteAllBytes [Seite 471]
4.2.4.3 - 8.4.3 BinaryReader/BinaryWriter erzeugen [Seite 472]
4.2.5 - 8.5 Sequenzielle Dateien [Seite 472]
4.2.5.1 - 8.5.1 Lesen und Schreiben von strukturierten Daten [Seite 472]
4.2.5.2 - 8.5.2 Serialisieren von Objekten [Seite 473]
4.2.6 - 8.6 Dateien verschlüsseln und komprimieren [Seite 474]
4.2.6.1 - 8.6.1 Das Methodenpärchen Encrypt-/Decrypt [Seite 475]
4.2.6.2 - 8.6.2 Verschlüsseln unter Windows Vista/7/8/10 [Seite 475]
4.2.6.3 - 8.6.3 Verschlüsseln mit der CryptoStream-Klasse [Seite 476]
4.2.6.4 - 8.6.4 Dateien komprimieren [Seite 477]
4.2.7 - 8.7 Memory Mapped Files [Seite 478]
4.2.7.1 - 8.7.1 Grundprinzip [Seite 478]
4.2.7.2 - 8.7.2 Erzeugen eines MMF [Seite 479]
4.2.7.3 - 8.7.3 Erstellen eines Map View [Seite 479]
4.2.8 - 8.8 Praxisbeispiele [Seite 480]
4.2.8.1 - 8.8.1 Auf eine Textdatei zugreifen [Seite 480]
4.2.8.2 - 8.8.2 Einen Objektbaum speichern [Seite 484]
4.2.8.3 - 8.8.3 Ein Memory Mapped File (MMF) verwenden [Seite 491]
4.2.8.4 - 8.8.4 Hex-Dezimal-Bytes-Konverter [Seite 493]
4.2.8.5 - 8.8.5 Eine Datei verschlüsseln [Seite 497]
4.2.8.6 - 8.8.6 Eine Datei komprimieren [Seite 500]
4.2.8.7 - 8.8.7 Echte ZIP-Dateien erstellen [Seite 502]
4.2.8.8 - 8.8.8 PDFs erstellen/exportieren [Seite 503]
4.2.8.9 - 8.8.9 Eine CSV-Datei erstellen [Seite 507]
4.2.8.10 - 8.8.10 Eine CSV-Datei mit LINQ lesen und auswerten [Seite 510]
4.2.8.11 - 8.8.11 Einen korrekten Dateinamen erzeugen [Seite 512]
4.3 - 9 Asynchrone Programmierung [Seite 514]
4.3.1 - 9.1 Übersicht [Seite 514]
4.3.1.1 - 9.1.1 Multitasking versus Multithreading [Seite 515]
4.3.1.2 - 9.1.2 Deadlocks [Seite 516]
4.3.1.3 - 9.1.3 Racing [Seite 516]
4.3.2 - 9.2 Programmieren mit Threads [Seite 518]
4.3.2.1 - 9.2.1 Einführungsbeispiel [Seite 518]
4.3.2.2 - 9.2.2 Wichtige Thread-Methoden [Seite 519]
4.3.2.3 - 9.2.3 Wichtige Thread-Eigenschaften [Seite 521]
4.3.2.4 - 9.2.4 Einsatz der ThreadPool-Klasse [Seite 522]
4.3.3 - 9.3 Sperrmechanismen [Seite 524]
4.3.3.1 - 9.3.1 Threading ohne SyncLock [Seite 524]
4.3.3.2 - 9.3.2 Threading mit SyncLock [Seite 525]
4.3.3.3 - 9.3.3 Die Monitor-Klasse [Seite 528]
4.3.3.4 - 9.3.4 Mutex [Seite 531]
4.3.3.5 - 9.3.5 Methoden für die parallele Ausführung sperren [Seite 532]
4.3.3.6 - 9.3.6 Semaphore [Seite 533]
4.3.4 - 9.4 Interaktion mit der Programmoberfläche [Seite 534]
4.3.4.1 - 9.4.1 Die Werkzeuge [Seite 535]
4.3.4.2 - 9.4.2 Einzelne Steuerelemente mit Invoke aktualisieren [Seite 535]
4.3.4.3 - 9.4.3 Mehrere Steuerelemente aktualisieren [Seite 536]
4.3.4.4 - 9.4.4 Ist ein Invoke-Aufruf nötig? [Seite 537]
4.3.4.5 - 9.4.5 Und was ist mit WPF? [Seite 537]
4.3.5 - 9.5 Timer-Threads [Seite 539]
4.3.6 - 9.6 Die BackgroundWorker-Komponente [Seite 540]
4.3.7 - 9.7 Asynchrone Programmier-Entwurfsmuster [Seite 543]
4.3.7.1 - 9.7.1 Kurzübersicht [Seite 543]
4.3.7.2 - 9.7.2 Polling [Seite 544]
4.3.7.3 - 9.7.3 Callback verwenden [Seite 545]
4.3.7.4 - 9.7.4 Callback mit Parameterübergabe verwenden [Seite 546]
4.3.7.5 - 9.7.5 Callback mit Zugriff auf die Programm-Oberfläche [Seite 547]
4.3.8 - 9.8 Asynchroner Aufruf beliebiger Methoden [Seite 548]
4.3.8.1 - 9.8.1 Die Beispielklasse [Seite 548]
4.3.8.2 - 9.8.2 Asynchroner Aufruf ohne Callback [Seite 550]
4.3.8.3 - 9.8.3 Asynchroner Aufruf mit Callback und Anzeigefunktion [Seite 550]
4.3.8.4 - 9.8.4 Aufruf mit Rückgabewerten (per Eigenschaft) [Seite 551]
4.3.8.5 - 9.8.5 Aufruf mit Rückgabewerten (per EndInvoke) [Seite 552]
4.3.9 - 9.9 Es geht auch einfacher - Async und Await [Seite 553]
4.3.9.1 - 9.9.1 Der Weg von synchron zu asynchron [Seite 553]
4.3.9.2 - 9.9.2 Achtung: Fehlerquellen! [Seite 555]
4.3.9.3 - 9.9.3 Eigene asynchrone Methoden entwickeln [Seite 557]
4.3.10 - 9.10 Praxisbeispiele [Seite 559]
4.3.10.1 - 9.10.1 Spieltrieb & Multithreading erleben [Seite 559]
4.3.10.2 - 9.10.2 Prozess- und Thread-Informationen gewinnen [Seite 571]
4.3.10.3 - 9.10.3 Ein externes Programm starten [Seite 576]
4.4 - 10 Die Task Parallel Library [Seite 580]
4.4.1 - 10.1 Überblick [Seite 580]
4.4.1.1 - 10.1.1 Parallel-Programmierung [Seite 580]
4.4.1.2 - 10.1.2 Möglichkeiten der TPL [Seite 583]
4.4.1.3 - 10.1.3 Der CLR-Threadpool [Seite 583]
4.4.2 - 10.2 Parallele Verarbeitung mit Parallel.Invoke [Seite 584]
4.4.2.1 - 10.2.1 Aufrufvarianten [Seite 585]
4.4.2.2 - 10.2.2 Einschränkungen [Seite 586]
4.4.3 - 10.3 Verwendung von Parallel.For [Seite 586]
4.4.3.1 - 10.3.1 Abbrechen der Verarbeitung [Seite 588]
4.4.3.2 - 10.3.2 Auswerten des Verarbeitungsstatus [Seite 589]
4.4.3.3 - 10.3.3 Und was ist mit anderen Iterator-Schrittweiten? [Seite 589]
4.4.4 - 10.4 Collections mit Parallel.ForEach verarbeiten [Seite 590]
4.4.5 - 10.5 Die Task-Klasse [Seite 591]
4.4.5.1 - 10.5.1 Einen Task erzeugen [Seite 591]
4.4.5.2 - 10.5.2 Task starten [Seite 592]
4.4.5.3 - 10.5.3 Datenübergabe an den Task [Seite 593]
4.4.5.4 - 10.5.4 Wie warte ich auf das Taskende? [Seite 594]
4.4.5.5 - 10.5.5 Tasks mit Rückgabewerten [Seite 596]
4.4.5.6 - 10.5.6 Die Verarbeitung abbrechen [Seite 599]
4.4.5.7 - 10.5.7 Fehlerbehandlung [Seite 603]
4.4.5.8 - 10.5.8 Weitere Eigenschaften [Seite 603]
4.4.6 - 10.6 Zugriff auf das Userinterface [Seite 605]
4.4.6.1 - 10.6.1 Task-Ende und Zugriff auf die Oberfläche [Seite 605]
4.4.6.2 - 10.6.2 Zugriff auf das UI aus dem Task heraus [Seite 606]
4.4.7 - 10.7 Weitere Datenstrukturen im Überblick [Seite 608]
4.4.7.1 - 10.7.1 Threadsichere Collections [Seite 608]
4.4.7.2 - 10.7.2 Primitive für die Threadsynchronisation [Seite 609]
4.4.8 - 10.8 Parallel LINQ (PLINQ) [Seite 609]
4.4.9 - 10.9 Praxisbeispiel: Spieltrieb - Version 2 [Seite 610]
4.4.9.1 - 10.9.1 Aufgabenstellung [Seite 610]
4.4.9.2 - 10.9.2 Global-Klasse [Seite 610]
4.4.9.3 - 10.9.3 Controller [Seite 611]
4.4.9.4 - 10.9.4 LKWs [Seite 613]
4.4.9.5 - 10.9.5 Schiff-Klasse [Seite 614]
4.4.9.6 - 10.9.6 Oberfläche [Seite 616]
4.5 - 11 Fehlersuche und Behandlung [Seite 618]
4.5.1 - 11.1 Der Debugger [Seite 618]
4.5.1.1 - 11.1.1 Allgemeine Beschreibung [Seite 618]
4.5.1.2 - 11.1.2 Die wichtigsten Fenster [Seite 619]
4.5.1.3 - 11.1.3 Debugging-Optionen [Seite 622]
4.5.1.4 - 11.1.4 Praktisches Debugging am Beispiel [Seite 624]
4.5.2 - 11.2 Arbeiten mit Debug und Trace [Seite 628]
4.5.2.1 - 11.2.1 Wichtige Methoden von Debug und Trace [Seite 628]
4.5.2.2 - 11.2.2 Besonderheiten der Trace-Klasse [Seite 631]
4.5.2.3 - 11.2.3 TraceListener-Objekte [Seite 632]
4.5.3 - 11.3 Caller Information [Seite 635]
4.5.3.1 - 11.3.1 Attribute [Seite 635]
4.5.3.2 - 11.3.2 Anwendung [Seite 635]
4.5.4 - 11.4 Fehlerbehandlung [Seite 636]
4.5.4.1 - 11.4.1 Anweisungen zur Fehlerbehandlung [Seite 636]
4.5.4.2 - 11.4.2 Try-Catch [Seite 636]
4.5.4.3 - 11.4.3 Try-Finally [Seite 641]
4.5.4.4 - 11.4.4 Das Standardverhalten bei Ausnahmen festlegen [Seite 643]
4.5.4.5 - 11.4.5 Die Exception-Klasse [Seite 644]
4.5.4.6 - 11.4.6 Fehler/Ausnahmen auslösen [Seite 644]
4.5.4.7 - 11.4.7 Eigene Fehlerklassen [Seite 645]
4.5.4.8 - 11.4.8 Exceptionhandling zur Entwurfszeit [Seite 647]
4.5.4.9 - 11.4.9 Code Contracts [Seite 647]
4.6 - 12 XML in Theorie und Praxis [Seite 650]
4.6.1 - 12.1 XML - etwas Theorie [Seite 650]
4.6.1.1 - 12.1.1 Übersicht [Seite 650]
4.6.1.2 - 12.1.2 Der XML-Grundaufbau [Seite 653]
4.6.1.3 - 12.1.3 Wohlgeformte Dokumente [Seite 654]
4.6.1.4 - 12.1.4 Processing Instructions (PI) [Seite 657]
4.6.1.5 - 12.1.5 Elemente und Attribute [Seite 657]
4.6.1.6 - 12.1.6 Verwendbare Zeichensätze [Seite 659]
4.6.2 - 12.2 XSD-Schemas [Seite 661]
4.6.2.1 - 12.2.1 XSD-Schemas und ADO.NET [Seite 661]
4.6.2.2 - 12.2.2 XML-Schemas in Visual Studio analysieren [Seite 663]
4.6.2.3 - 12.2.3 XML-Datei mit XSD-Schema erzeugen [Seite 666]
4.6.2.4 - 12.2.4 XSD-Schema aus einer XML-Datei erzeugen [Seite 667]
4.6.3 - 12.3 XML-Integration in Visual Basic [Seite 668]
4.6.3.1 - 12.3.1 XML-Literale [Seite 668]
4.6.3.2 - 12.3.2 Einfaches Navigieren durch späte Bindung [Seite 671]
4.6.3.3 - 12.3.3 Die LINQ to XML-API [Seite 673]
4.6.3.4 - 12.3.4 Neue XML-Dokumente erzeugen [Seite 674]
4.6.3.5 - 12.3.5 Laden und Sichern von XML-Dokumenten [Seite 676]
4.6.3.6 - 12.3.6 Navigieren in XML-Daten [Seite 678]
4.6.3.7 - 12.3.7 Auswählen und Filtern [Seite 680]
4.6.3.8 - 12.3.8 Manipulieren der XML-Daten [Seite 680]
4.6.3.9 - 12.3.9 XML-Dokumente transformieren [Seite 682]
4.6.4 - 12.4 Verwendung des DOM unter .NET [Seite 685]
4.6.4.1 - 12.4.1 Übersicht [Seite 685]
4.6.4.2 - 12.4.2 DOM-Integration in Visual Basic [Seite 686]
4.6.4.3 - 12.4.3 Laden von Dokumenten [Seite 686]
4.6.4.4 - 12.4.4 Erzeugen von XML-Dokumenten [Seite 687]
4.6.4.5 - 12.4.5 Auslesen von XML-Dateien [Seite 689]
4.6.4.6 - 12.4.6 Direktzugriff auf einzelne Elemente [Seite 690]
4.6.4.7 - 12.4.7 Einfügen von Informationen [Seite 691]
4.6.4.8 - 12.4.8 Suchen in den Baumzweigen [Seite 693]
4.6.5 - 12.5 Weitere Möglichkeiten der XML-Verarbeitung [Seite 697]
4.6.5.1 - 12.5.1 Die relationale Sicht mit XmlDataDocument [Seite 697]
4.6.5.2 - 12.5.2 XML-Daten aus Objektstrukturen erzeugen [Seite 700]
4.6.5.3 - 12.5.3 Schnelles Suchen in XML-Daten mit XPathNavigator [Seite 703]
4.6.5.4 - 12.5.4 Schnelles Auslesen von XML-Daten mit XmlReader [Seite 706]
4.6.5.5 - 12.5.5 Erzeugen von XML-Daten mit XmlWriter [Seite 708]
4.6.5.6 - 12.5.6 XML transformieren mit XSLT [Seite 710]
4.6.6 - 12.6 Praxisbeispiele [Seite 712]
4.6.6.1 - 12.6.1 Mit dem DOM in XML-Dokumenten navigieren [Seite 712]
4.6.6.2 - 12.6.2 XML-Daten in eine TreeView einlesen [Seite 715]
4.6.6.3 - 12.6.3 DataSets in XML-Strings konvertieren [Seite 719]
4.6.6.4 - 12.6.4 In Dokumenten mit dem XPathNavigator navigieren [Seite 723]
4.7 - 13 Einführung in ADO.NET [Seite 728]
4.7.1 - 13.1 Eine kleine Übersicht [Seite 728]
4.7.1.1 - 13.1.1 Die ADO.NET-Klassenhierarchie [Seite 728]
4.7.1.2 - 13.1.2 Die Klassen der Datenprovider [Seite 729]
4.7.1.3 - 13.1.3 Das Zusammenspiel der ADO.NET-Klassen [Seite 732]
4.7.2 - 13.2 Das Connection-Objekt [Seite 733]
4.7.2.1 - 13.2.1 Allgemeiner Aufbau [Seite 733]
4.7.2.2 - 13.2.2 OleDbConnection [Seite 733]
4.7.2.3 - 13.2.3 Schließen einer Verbindung [Seite 735]
4.7.2.4 - 13.2.4 Eigenschaften des Connection-Objekts [Seite 735]
4.7.2.5 - 13.2.5 Methoden des Connection-Objekts [Seite 737]
4.7.2.6 - 13.2.6 Der ConnectionStringBuilder [Seite 738]
4.7.3 - 13.3 Das Command-Objekt [Seite 739]
4.7.3.1 - 13.3.1 Erzeugen und Anwenden eines Command-Objekts [Seite 739]
4.7.3.2 - 13.3.2 Erzeugen mittels CreateCommand-Methode [Seite 740]
4.7.3.3 - 13.3.3 Eigenschaften des Command-Objekts [Seite 740]
4.7.3.4 - 13.3.4 Methoden des Command-Objekts [Seite 742]
4.7.3.5 - 13.3.5 Freigabe von Connection- und Command-Objekten [Seite 743]
4.7.4 - 13.4 Parameter-Objekte [Seite 745]
4.7.4.1 - 13.4.1 Erzeugen und Anwenden eines Parameter-Objekts [Seite 745]
4.7.4.2 - 13.4.2 Eigenschaften des Parameter-Objekts [Seite 745]
4.7.5 - 13.5 Das CommandBuilder-Objekt [Seite 746]
4.7.5.1 - 13.5.1 Erzeugen [Seite 746]
4.7.5.2 - 13.5.2 Anwenden [Seite 747]
4.7.6 - 13.6 Das DataReader-Objekt [Seite 747]
4.7.6.1 - 13.6.1 DataReader erzeugen [Seite 748]
4.7.6.2 - 13.6.2 Daten lesen [Seite 748]
4.7.6.3 - 13.6.3 Eigenschaften des DataReaders [Seite 749]
4.7.6.4 - 13.6.4 Methoden des DataReaders [Seite 749]
4.7.7 - 13.7 Das DataAdapter-Objekt [Seite 750]
4.7.7.1 - 13.7.1 DataAdapter erzeugen [Seite 750]
4.7.7.2 - 13.7.2 Command-Eigenschaften [Seite 751]
4.7.7.3 - 13.7.3 Fill-Methode [Seite 752]
4.7.7.4 - 13.7.4 Update-Methode [Seite 753]
4.7.8 - 13.8 Praxisbeispiele [Seite 754]
4.7.8.1 - 13.8.1 Wichtige ADO.NET-Objekte im Einsatz [Seite 754]
4.7.8.2 - 13.8.2 Eine Aktionsabfrage ausführen [Seite 756]
4.7.8.3 - 13.8.3 Eine Auswahlabfrage aufrufen [Seite 758]
4.7.8.4 - 13.8.4 Die Datenbank aktualisieren [Seite 760]
4.7.8.5 - 13.8.5 Den ConnectionString speichern [Seite 763]
4.8 - 14 Das DataSet [Seite 766]
4.8.1 - 14.1 Grundlegende Features des DataSets [Seite 766]
4.8.1.1 - 14.1.1 Die Objekthierarchie [Seite 767]
4.8.1.2 - 14.1.2 Die wichtigsten Klassen [Seite 767]
4.8.1.3 - 14.1.3 Erzeugen eines DataSets [Seite 768]
4.8.2 - 14.2 Das DataTable-Objekt [Seite 770]
4.8.2.1 - 14.2.1 DataTable erzeugen [Seite 770]
4.8.2.2 - 14.2.2 Spalten hinzufügen [Seite 770]
4.8.2.3 - 14.2.3 Zeilen zur DataTable hinzufügen [Seite 771]
4.8.2.4 - 14.2.4 Auf den Inhalt einer DataTable zugreifen [Seite 772]
4.8.3 - 14.3 Die DataView [Seite 774]
4.8.3.1 - 14.3.1 Erzeugen eines DataView [Seite 774]
4.8.3.2 - 14.3.2 Sortieren und Filtern von Datensätzen [Seite 774]
4.8.3.3 - 14.3.3 Suchen von Datensätzen [Seite 775]
4.8.4 - 14.4 Typisierte DataSets [Seite 775]
4.8.4.1 - 14.4.1 Ein typisiertes DataSet erzeugen [Seite 776]
4.8.4.2 - 14.4.2 Das Konzept der Datenquellen [Seite 777]
4.8.4.3 - 14.4.3 Typisierte DataSets und TableAdapter [Seite 778]
4.8.5 - 14.5 Die Qual der Wahl [Seite 779]
4.8.5.1 - 14.5.1 DataReader - der schnelle Lesezugriff [Seite 780]
4.8.5.2 - 14.5.2 DataSet - die Datenbank im Hauptspeicher [Seite 780]
4.8.5.3 - 14.5.3 Objektrelationales Mapping - die Zukunft? [Seite 781]
4.8.6 - 14.6 Praxisbeispiele [Seite 782]
4.8.6.1 - 14.6.1 Im DataView sortieren und filtern [Seite 782]
4.8.6.2 - 14.6.2 Suche nach Datensätzen [Seite 784]
4.8.6.3 - 14.6.3 Ein DataSet in einen XML-String serialisieren [Seite 785]
4.8.6.4 - 14.6.4 Untypisierte in typisierte DataSets konvertieren [Seite 790]
4.8.6.5 - 14.6.5 Eine LINQ to SQL-Abfrage ausführen [Seite 795]
4.9 - 15 Verteilen von Anwendungen [Seite 800]
4.9.1 - 15.1 ClickOnce-Deployment [Seite 801]
4.9.1.1 - 15.1.1 Übersicht/Einschränkungen [Seite 801]
4.9.1.2 - 15.1.2 Die Vorgehensweise [Seite 802]
4.9.1.3 - 15.1.3 Ort der Veröffentlichung [Seite 802]
4.9.1.4 - 15.1.4 Anwendungsdateien [Seite 803]
4.9.1.5 - 15.1.5 Erforderliche Komponenten [Seite 803]
4.9.1.6 - 15.1.6 Aktualisierungen [Seite 804]
4.9.1.7 - 15.1.7 Veröffentlichungsoptionen [Seite 805]
4.9.1.8 - 15.1.8 Veröffentlichen [Seite 806]
4.9.1.9 - 15.1.9 Verzeichnisstruktur [Seite 806]
4.9.1.10 - 15.1.10 Der Webpublishing-Assistent [Seite 808]
4.9.1.11 - 15.1.11 Neue Versionen erstellen [Seite 809]
4.9.2 - 15.2 InstallShield [Seite 809]
4.9.2.1 - 15.2.1 Installation [Seite 809]
4.9.2.2 - 15.2.2 Aktivieren [Seite 810]
4.9.2.3 - 15.2.3 Ein neues Setup-Projekt [Seite 810]
4.9.2.4 - 15.2.4 Finaler Test [Seite 818]
4.9.3 - 15.3 Hilfedateien programmieren [Seite 818]
4.9.3.1 - 15.3.1 Der HTML Help Workshop [Seite 819]
4.9.3.2 - 15.3.2 Bedienung am Beispiel [Seite 820]
4.9.3.3 - 15.3.3 Hilfedateien in die VB-Anwendung einbinden [Seite 822]
4.9.3.4 - 15.3.4 Eine alternative Hilfe-IDE verwenden [Seite 826]
4.10 - 16 Weitere Techniken [Seite 828]
4.10.1 - 16.1 Zugriff auf die Zwischenablage [Seite 828]
4.10.1.1 - 16.1.1 Das Clipboard-Objekt [Seite 828]
4.10.1.2 - 16.1.2 Zwischenablage-Funktionen für Textboxen [Seite 830]
4.10.2 - 16.2 Arbeiten mit der Registry [Seite 830]
4.10.2.1 - 16.2.1 Allgemeines [Seite 831]
4.10.2.2 - 16.2.2 Registry-Unterstützung in .NET [Seite 832]
4.10.3 - 16.3 .NET-Reflection [Seite 834]
4.10.3.1 - 16.3.1 Übersicht [Seite 834]
4.10.3.2 - 16.3.2 Assembly laden [Seite 834]
4.10.3.3 - 16.3.3 Mittels GetType und Type Informationen sammeln [Seite 835]
4.10.3.4 - 16.3.4 Dynamisches Laden von Assemblies [Seite 837]
4.10.4 - 16.4 Praxisbeispiele [Seite 839]
4.10.4.1 - 16.4.1 Zugriff auf die Registry [Seite 839]
4.10.4.2 - 16.4.2 Dateiverknüpfungen erzeugen [Seite 841]
4.10.4.3 - 16.4.3 Die Zwischenablage überwachen und anzeigen [Seite 843]
4.10.4.4 - 16.4.4 Die WIA-Library kennenlernen [Seite 846]
4.10.4.5 - 16.4.5 Auf eine Webcam zugreifen [Seite 858]
4.10.4.6 - 16.4.6 Auf den Scanner zugreifen [Seite 860]
4.10.4.7 - 16.4.7 OpenOffice.org Writer per OLE steuern [Seite 864]
4.10.4.8 - 16.4.8 Nutzer und Gruppen des Systems ermitteln [Seite 872]
4.10.4.9 - 16.4.9 Testen, ob Nutzer in einer Gruppe enthalten ist [Seite 873]
4.10.4.10 - 16.4.10 Testen, ob der Nutzer ein Administrator ist [Seite 875]
4.10.4.11 - 16.4.11 Die IP-Adressen des Computers bestimmen [Seite 876]
4.10.4.12 - 16.4.12 Die IP-Adresse über den Hostnamen bestimmen [Seite 877]
4.10.4.13 - 16.4.13 Diverse Systeminformationen ermitteln [Seite 878]
4.10.4.14 - 16.4.14 Sound per MCI aufnehmen [Seite 887]
4.10.4.15 - 16.4.15 Mikrofonpegel anzeigen [Seite 890]
4.10.4.16 - 16.4.16 Pegeldiagramm aufzeichnen [Seite 892]
4.10.4.17 - 16.4.17 Sound-und Video-Dateien per MCI abspielen [Seite 896]
4.11 - 17 Konsolenanwendungen [Seite 904]
4.11.1 - 17.1 Grundaufbau/Konzepte [Seite 904]
4.11.1.1 - 17.1.1 Unser Hauptprogramm - Module1.vb [Seite 905]
4.11.1.2 - 17.1.2 Rückgabe eines Fehlerstatus [Seite 906]
4.11.1.3 - 17.1.3 Parameterübergabe [Seite 907]
4.11.1.4 - 17.1.4 Zugriff auf die Umgebungsvariablen [Seite 908]
4.11.2 - 17.2 Die Kommandozentrale: System.Console [Seite 909]
4.11.2.1 - 17.2.1 Eigenschaften [Seite 909]
4.11.2.2 - 17.2.2 Methoden/Ereignisse [Seite 910]
4.11.2.3 - 17.2.3 Textausgaben [Seite 911]
4.11.2.4 - 17.2.4 Farbangaben [Seite 912]
4.11.2.5 - 17.2.5 Tastaturabfragen [Seite 913]
4.11.2.6 - 17.2.6 Arbeiten mit Streamdaten [Seite 914]
4.11.3 - 17.3 Praxisbeispiel: Farbige Konsolenanwendung [Seite 915]
5 - Teil III: Windows Apps [Seite 918]
5.1 - 18 Erste Schritte [Seite 920]
5.1.1 - 18.1 Grundkonzepte und Begriffe [Seite 920]
5.1.1.1 - 18.1.1 Windows Runtime (WinRT) [Seite 920]
5.1.1.2 - 18.1.2 Windows Store Apps [Seite 921]
5.1.1.3 - 18.1.3 Fast and Fluid [Seite 922]
5.1.1.4 - 18.1.4 Process Sandboxing und Contracts [Seite 923]
5.1.1.5 - 18.1.5 .NET WinRT-Profil [Seite 925]
5.1.1.6 - 18.1.6 Language Projection [Seite 925]
5.1.1.7 - 18.1.7 Vollbildmodus - war da was? [Seite 927]
5.1.1.8 - 18.1.8 Windows Store [Seite 927]
5.1.1.9 - 18.1.9 Zielplattformen [Seite 928]
5.1.2 - 18.2 Entwurfsumgebung [Seite 929]
5.1.2.1 - 18.2.1 Betriebssystem [Seite 929]
5.1.2.2 - 18.2.2 Windows-Simulator [Seite 929]
5.1.2.3 - 18.2.3 Remote-Debugging [Seite 932]
5.1.3 - 18.3 Ein (kleines) Einstiegsbeispiel [Seite 933]
5.1.3.1 - 18.3.1 Aufgabenstellung [Seite 933]
5.1.3.2 - 18.3.2 Quellcode [Seite 933]
5.1.3.3 - 18.3.3 Oberflächenentwurf [Seite 936]
5.1.3.4 - 18.3.4 Installation und Test [Seite 938]
5.1.3.5 - 18.3.5 Touchscreen [Seite 940]
5.1.3.6 - 18.3.6 Fazit [Seite 940]
5.1.4 - 18.4 Weitere Details zu WinRT [Seite 942]
5.1.4.1 - 18.4.1 Wo ist WinRT einzuordnen? [Seite 943]
5.1.4.2 - 18.4.2 Die WinRT-API [Seite 944]
5.1.4.3 - 18.4.3 Wichtige WinRT-Namespaces [Seite 946]
5.1.4.4 - 18.4.4 Der Unterbau [Seite 947]
5.1.5 - 18.5 Praxisbeispiel [Seite 949]
5.1.5.1 - 18.5.1 WinRT in Desktop-Applikationen nutzen [Seite 949]
5.2 - 19 App-Oberflächen entwerfen [Seite 954]
5.2.1 - 19.1 Grundkonzepte [Seite 954]
5.2.1.1 - 19.1.1 XAML (oder HTML 5) für die Oberfläche [Seite 955]
5.2.1.2 - 19.1.2 Die Page, der Frame und das Window [Seite 956]
5.2.1.3 - 19.1.3 Das Befehlsdesign [Seite 958]
5.2.1.4 - 19.1.4 Die Navigationsdesigns [Seite 960]
5.2.1.5 - 19.1.5 Achtung: Fingereingabe! [Seite 961]
5.2.1.6 - 19.1.6 Verwendung von Schriftarten [Seite 961]
5.2.2 - 19.2 Seitenauswahl und -navigation [Seite 962]
5.2.2.1 - 19.2.1 Die Startseite festlegen [Seite 962]
5.2.2.2 - 19.2.2 Navigation und Parameterübergabe [Seite 962]
5.2.2.3 - 19.2.3 Den Seitenstatus erhalten [Seite 963]
5.2.3 - 19.3 App-Darstellung [Seite 964]
5.2.3.1 - 19.3.1 Vollbild quer und hochkant [Seite 964]
5.2.3.2 - 19.3.2 Was ist mit Andocken und Füllmodus? [Seite 965]
5.2.3.3 - 19.3.3 Reagieren auf die Änderung [Seite 965]
5.2.4 - 19.4 Skalieren von Apps [Seite 967]
5.2.5 - 19.5 Praxisbeispiele [Seite 969]
5.2.5.1 - 19.5.1 Seitennavigation und Parameterübergabe [Seite 969]
5.2.5.2 - 19.5.2 Die Fensterkopfzeile anpassen [Seite 971]
5.3 - 20 Die wichtigsten Controls [Seite 974]
5.3.1 - 20.1 Einfache WinRT-Controls [Seite 974]
5.3.1.1 - 20.1.1 TextBlock, RichTextBlock [Seite 974]
5.3.1.2 - 20.1.2 Button, HyperlinkButton, RepeatButton [Seite 977]
5.3.1.3 - 20.1.3 CheckBox, RadioButton, ToggleButton, ToggleSwitch [Seite 979]
5.3.1.4 - 20.1.4 TextBox, PasswordBox, RichEditBox [Seite 980]
5.3.1.5 - 20.1.5 Image [Seite 984]
5.3.1.6 - 20.1.6 ScrollBar, Slider, ProgressBar, ProgressRing [Seite 985]
5.3.1.7 - 20.1.7 Border, Ellipse, Rectangle [Seite 987]
5.3.2 - 20.2 Layout-Controls [Seite 988]
5.3.2.1 - 20.2.1 Canvas [Seite 988]
5.3.2.2 - 20.2.2 StackPanel [Seite 989]
5.3.2.3 - 20.2.3 ScrollViewer [Seite 989]
5.3.2.4 - 20.2.4 Grid [Seite 990]
5.3.2.5 - 20.2.5 VariableSizedWrapGrid [Seite 991]
5.3.2.6 - 20.2.6 SplitView [Seite 992]
5.3.2.7 - 20.2.7 Pivot [Seite 996]
5.3.2.8 - 20.2.8 RelativPanel [Seite 997]
5.3.3 - 20.3 Listendarstellungen [Seite 999]
5.3.3.1 - 20.3.1 ComboBox, ListBox [Seite 999]
5.3.3.2 - 20.3.2 ListView [Seite 1003]
5.3.3.3 - 20.3.3 GridView [Seite 1005]
5.3.3.4 - 20.3.4 FlipView [Seite 1007]
5.3.4 - 20.4 Sonstige Controls [Seite 1009]
5.3.4.1 - 20.4.1 CaptureElement [Seite 1009]
5.3.4.2 - 20.4.2 MediaElement [Seite 1010]
5.3.4.3 - 20.4.3 Frame [Seite 1012]
5.3.4.4 - 20.4.4 WebView [Seite 1012]
5.3.4.5 - 20.4.5 ToolTip [Seite 1013]
5.3.4.6 - 20.4.6 CalendarDatePicker [Seite 1015]
5.3.4.7 - 20.4.7 DatePicker/TimePicker [Seite 1016]
5.3.5 - 20.5 Praxisbeispiele [Seite 1016]
5.3.5.1 - 20.5.1 Einen StringFormat-Konverter implementieren [Seite 1016]
5.3.5.2 - 20.5.2 Besonderheiten der TextBox kennen lernen [Seite 1018]
5.3.5.3 - 20.5.3 Daten in der GridView gruppieren [Seite 1021]
5.3.5.4 - 20.5.4 Das SemanticZoom-Control verwenden [Seite 1026]
5.3.5.5 - 20.5.5 Die CollectionViewSource verwenden [Seite 1031]
5.3.5.6 - 20.5.6 Zusammenspiel ListBox/AppBar [Seite 1034]
5.4 - 21 Apps im Detail [Seite 1038]
5.4.1 - 21.1 Ein Windows App-Projekt im Detail [Seite 1038]
5.4.1.1 - 21.1.1 Contracts und Extensions [Seite 1039]
5.4.1.2 - 21.1.2 AssemblyInfo.vb [Seite 1039]
5.4.1.3 - 21.1.3 Verweise [Seite 1041]
5.4.1.4 - 21.1.4 App.xaml und App.xaml.vb [Seite 1041]
5.4.1.5 - 21.1.5 Package.appxmanifest [Seite 1042]
5.4.1.6 - 21.1.6 Application1_TemporaryKey.pfx [Seite 1047]
5.4.1.7 - 21.1.7 MainPage.xaml & MainPage.xaml.vb [Seite 1047]
5.4.1.8 - 21.1.8 Assets/Symbole [Seite 1048]
5.4.1.9 - 21.1.9 Nach dem Kompilieren [Seite 1048]
5.4.2 - 21.2 Der Lebenszyklus einer Windows App [Seite 1048]
5.4.2.1 - 21.2.1 Möglichkeiten der Aktivierung von Apps [Seite 1050]
5.4.2.2 - 21.2.2 Der Splash Screen [Seite 1052]
5.4.2.3 - 21.2.3 Suspending [Seite 1052]
5.4.2.4 - 21.2.4 Resuming [Seite 1053]
5.4.2.5 - 21.2.5 Beenden von Apps [Seite 1054]
5.4.2.6 - 21.2.6 Die Ausnahmen von der Regel [Seite 1055]
5.4.2.7 - 21.2.7 Debuggen [Seite 1055]
5.4.3 - 21.3 Daten speichern und laden [Seite 1059]
5.4.3.1 - 21.3.1 Grundsätzliche Überlegungen [Seite 1059]
5.4.3.2 - 21.3.2 Worauf und wie kann ich zugreifen? [Seite 1060]
5.4.3.3 - 21.3.3 Das AppData-Verzeichnis [Seite 1060]
5.4.3.4 - 21.3.4 Das Anwendungs-Installationsverzeichnis [Seite 1062]
5.4.3.5 - 21.3.5 Das Downloads-Verzeichnis [Seite 1063]
5.4.3.6 - 21.3.6 Sonstige Verzeichnisse [Seite 1064]
5.4.3.7 - 21.3.7 Anwendungsdaten lokal sichern und laden [Seite 1065]
5.4.3.8 - 21.3.8 Daten in der Cloud ablegen/laden (Roaming) [Seite 1067]
5.4.3.9 - 21.3.9 Aufräumen [Seite 1068]
5.4.3.10 - 21.3.10 Sensible Informationen speichern [Seite 1069]
5.4.4 - 21.4 Praxisbeispiele [Seite 1070]
5.4.4.1 - 21.4.1 Die Auto-Play-Funktion unterstützen [Seite 1070]
5.4.4.2 - 21.4.2 Einen zusätzlichen Splash Screen einsetzen [Seite 1074]
5.4.4.3 - 21.4.3 Eine Dateiverknüpfung erstellen [Seite 1076]
5.5 - 22 App-Techniken [Seite 1082]
5.5.1 - 22.1 Arbeiten mit Dateien/Verzeichnissen [Seite 1082]
5.5.1.1 - 22.1.1 Verzeichnisinformationen auflisten [Seite 1082]
5.5.1.2 - 22.1.2 Unterverzeichnisse auflisten [Seite 1085]
5.5.1.3 - 22.1.3 Verzeichnisse erstellen/löschen [Seite 1087]
5.5.1.4 - 22.1.4 Dateien auflisten [Seite 1088]
5.5.1.5 - 22.1.5 Dateien erstellen/schreiben/lesen [Seite 1090]
5.5.1.6 - 22.1.6 Dateien kopieren/umbenennen/löschen [Seite 1094]
5.5.1.7 - 22.1.7 Verwenden der Dateipicker [Seite 1096]
5.5.1.8 - 22.1.8 StorageFile-/StorageFolder-Objekte speichern [Seite 1100]
5.5.1.9 - 22.1.9 Verwenden der Most Recently Used-Liste [Seite 1102]
5.5.2 - 22.2 Datenaustausch zwischen Apps/Programmen [Seite 1103]
5.5.2.1 - 22.2.1 Zwischenablage [Seite 1103]
5.5.2.2 - 22.2.2 Teilen von Inhalten [Seite 1110]
5.5.2.3 - 22.2.3 Eine App als Freigabeziel verwenden [Seite 1113]
5.5.2.4 - 22.2.4 Zugriff auf die Kontaktliste [Seite 1114]
5.5.3 - 22.3 Spezielle Oberflächenelemente [Seite 1116]
5.5.3.1 - 22.3.1 MessageDialog [Seite 1116]
5.5.3.2 - 22.3.2 ContentDialog [Seite 1119]
5.5.3.3 - 22.3.3 Popup-Benachrichtigungen [Seite 1121]
5.5.3.4 - 22.3.4 PopUp/Flyouts [Seite 1128]
5.5.3.5 - 22.3.5 Das PopupMenu einsetzen [Seite 1132]
5.5.3.6 - 22.3.6 Eine AppBar verwenden [Seite 1134]
5.5.4 - 22.4 Datenbanken und Windows Store Apps [Seite 1138]
5.5.4.1 - 22.4.1 Der Retter in der Not: SQLite! [Seite 1138]
5.5.4.2 - 22.4.2 Verwendung/Kurzüberblick [Seite 1138]
5.5.4.3 - 22.4.3 Installation [Seite 1140]
5.5.4.4 - 22.4.4 Wie kommen wir zu einer neuen Datenbank? [Seite 1141]
5.5.4.5 - 22.4.5 Wie werden die Daten manipuliert? [Seite 1145]
5.5.5 - 22.5 Vertrieb der App [Seite 1146]
5.5.5.1 - 22.5.1 Verpacken der App [Seite 1146]
5.5.5.2 - 22.5.2 App-Installation per Skript [Seite 1148]
5.5.6 - 22.6 Ein Blick auf die App-Schwachstellen [Seite 1150]
5.5.6.1 - 22.6.1 Quellcodes im Installationsverzeichnis [Seite 1150]
5.5.6.2 - 22.6.2 Zugriff auf den App-Datenordner [Seite 1152]
5.5.7 - 22.7 Praxisbeispiele [Seite 1152]
5.5.7.1 - 22.7.1 Ein Verzeichnis auf Änderungen überwachen [Seite 1152]
5.5.7.2 - 22.7.2 Eine App als Freigabeziel verwenden [Seite 1155]
5.5.7.3 - 22.7.3 ToastNotifications einfach erzeugen [Seite 1160]
6 - Anhang [Seite 1166]
6.1 - A Glossar [Seite 1168]
6.2 - B Wichtige Dateiextensions [Seite 1174]
7 - Index [Seite 1176]
8 - Download-Kapitel [Seite 30]