Visual Basic 2015 - Grundlagen, Profiwissen und Rezepte

Inhaltsverzeichnis

Vorwort

Teil I: Grundlagen

1 Einstieg in Visual Studio 2015

1.1 Die Installation von Visual Studio 2015

1.1.1 Überblick über die Produktpalette

1.1.2 Anforderungen an Hard- und Software

1.2 Unser allererstes VB-Programm

1.2.1 Vorbereitungen

1.2.2 Programm schreiben

1.2.3 Programm kompilieren und testen

1.2.4 Einige Erläuterungen zum Quellcode

1.2.5 Konsolenanwendungen sind out

1.3 Die Windows-Philosophie

1.3.1 Mensch-Rechner-Dialog

1.3.2 Objekt- und ereignisorientierte Programmierung

1.3.3 Windows-Programmierung unter Visual Studio 2015

1.4 Die Entwicklungsumgebung Visual Studio 2015

1.4.1 Neues Projekt

1.4.2 Die wichtigsten Fenster

1.5 Microsofts .NET-Technologie

1.5.1 Zur Geschichte von .NET

1.5.2 .NET-Features und Begriffe

1.6 Wichtige Neuigkeiten in Visual Studio 2015

1.6.1 Entwicklungsumgebung

1.6.2 Neue VB-Sprachfeatures

1.6.3 Code-Editor

1.6.4 NET Framework 4.6

1.7 Praxisbeispiele

1.7.1 Windows-Anwendung für Einsteiger

1.7.2 Windows-Anwendung für fortgeschrittene Einsteiger

2 Einführung in Visual Basic

2.1 Grundbegriffe

2.1.1 Anweisungen

2.1.2 Bezeichner

2.1.3 Kommentare

2.1.4 Zeilenumbruch

2.2 Datentypen, Variablen und Konstanten

2.2.1 Fundamentale Typen

2.2.2 Wertetypen versus Verweistypen

2.2.3 Benennung von Variablen

2.2.4 Deklaration von Variablen

2.2.5 Typinferenz

2.2.6 Konstanten deklarieren

2.2.7 Gültigkeitsbereiche von Deklarationen

2.2.8 Lokale Variablen mit Dim

2.2.9 Lokale Variablen mit Static

2.2.10 Private globale Variablen

2.2.11 Public Variablen

2.3 Wichtige Datentypen im Überblick

2.3.1 Byte, Short, Integer, Long

2.3.2 Single, Double und Decimal

2.3.3 Char und String

2.3.4 Date

2.3.5 Boolean

2.3.6 Object

2.4 Konvertieren von Datentypen

2.4.1 Implizite und explizite Konvertierung

2.4.2 Welcher Datentyp passt zu welchem?

2.4.3 Konvertierungsfunktionen

2.4.4 CType-Funktion

2.4.5 Konvertieren von Strings

2.4.6 Die Convert-Klasse

2.4.7 Die Parse-Methode

2.4.8 Boxing und Unboxing

2.4.9 TryCast-Operator

2.4.10 Nullable Types

2.5 Operatoren

2.5.1 Arithmetische Operatoren

2.5.2 Zuweisungsoperatoren

2.5.3 Logische Operatoren

2.5.4 Vergleichsoperatoren

2.5.5 Rangfolge der Operatoren

2.6 Kontrollstrukturen

2.6.1 Verzweigungsbefehle

2.6.2 Schleifenanweisungen

2.7 Benutzerdefinierte Datentypen

2.7.1 Enumerationen

2.7.2 Strukturen

2.8 Nutzerdefinierte Funktionen/Prozeduren

2.8.1 Deklaration und Syntax

2.8.2 Parameterübergabe allgemein

2.8.3 Übergabe mit ByVal und ByRef

2.8.4 Optionale Parameter

2.8.5 Überladene Funktionen/Prozeduren

2.9 Praxisbeispiele

2.9.1 Vom PAP zum Konsolen-Programm

2.9.2 Vom Konsolen- zum Windows-Programm

2.9.3 Schleifenanweisungen kennen lernen

2.9.4 Methoden überladen

2.9.5 Eine Iterationsschleife verstehen

2.9.6 Anwendungen von C# nach Visual Basic portieren

3 OOP-Konzepte

3.1 Strukturierter versus objektorientierter Entwurf

3.1.1 Was bedeutet strukturierte Programmierung?

3.1.2 Was heißt objektorientierte Programmierung?

3.2 Grundbegriffe der OOP

3.2.1 Objekt, Klasse, Instanz

3.2.2 Kapselung und Wiederverwendbarkeit

3.2.3 Vererbung und Polymorphie

3.2.4 Sichtbarkeit von Klassen und ihren Mitgliedern

3.2.5 Allgemeiner Aufbau einer Klasse

3.3 Ein Objekt erzeugen

3.3.1 Referenzieren und Instanziieren

3.3.2 Klassische Initialisierung

3.3.3 Objekt-Initialisierer

3.3.4 Arbeiten mit dem Objekt

3.3.5 Zerstören des Objekts

3.4 OOP-Einführungsbeispiel

3.4.1 Vorbereitungen

3.4.2 Klasse definieren

3.4.3 Objekt erzeugen und initialisieren

3.4.4 Objekt verwenden

3.4.5 Unterstützung durch die IntelliSense

3.4.6 Objekt testen

3.4.7 Warum unsere Klasse noch nicht optimal ist

3.5 Eigenschaften

3.5.1 Eigenschaften kapseln

3.5.2 Eigenschaften mit Zugriffsmethoden kapseln

3.5.3 Lese-/Schreibschutz für Eigenschaften

3.5.4 Statische Eigenschaften

3.5.5 Selbst implementierende Eigenschaften

3.6 Methoden

3.6.1 Öffentliche und private Methoden

3.6.2 Überladene Methoden

3.6.3 Statische Methoden

3.7 Ereignisse

3.7.1 Ereignise deklarieren

3.7.2 Ereignis auslösen

3.7.3 Ereignis auswerten

3.7.4 Benutzerdefinierte Ereignisse (Custom Events)

3.8 Arbeiten mit Konstruktor und Destruktor

3.8.1 Der Konstruktor erzeugt das Objekt

3.8.2 Bequemer geht’s mit einem Objekt-Initialisierer

3.8.3 Destruktor und Garbage Collector räumen auf

3.8.4 Mit Using den Lebenszyklus des Objekts kapseln

3.9 Vererbung und Polymorphie

3.9.1 Vererbungsbeziehungen im Klassendiagramm

3.9.2 Überschreiben von Methoden (Method-Overriding)

3.9.3 Klassen implementieren

3.9.4 Objekte implementieren

3.9.5 Ausblenden von Mitgliedern durch Vererbung

3.9.6 Allgemeine Hinweise und Regeln zur Vererbung

3.9.7 Polymorphe Methoden

3.10 Besondere Klassen und Features

3.10.1 Abstrakte Klassen

3.10.2 Abstrakte Methoden

3.10.3 Versiegelte Klassen

3.10.4 Partielle Klassen

3.10.5 Die Basisklasse System.Object

3.10.6 Property-Accessors

3.10.7 Nullbedingter Operator

3.11 Schnittstellen (Interfaces)

3.11.1 Definition einer Schnittstelle

3.11.2 Implementieren einer Schnittstelle

3.11.3 Abfragen, ob eine Schnittstelle vorhanden ist

3.11.4 Mehrere Schnittstellen implementieren

3.11.5 Schnittstellenprogrammierung ist ein weites Feld

3.12 Praxisbeispiele

3.12.1 Eigenschaften sinnvoll kapseln

3.12.2 Eine statische Klasse anwenden

3.12.3 Vom fetten zum dünnen Client

3.12.4 Schnittstellenvererbung verstehen

3.12.5 Aggregation und Vererbung gegenüberstellen

3.12.6 Eine Klasse zur Matrizenrechnung entwickeln

3.12.7 Rechner für komplexe Zahlen

3.12.8 Formel-Rechner mit dem CodeDOM

3.12.9 Einen Funktionsverlauf grafisch darstellen

3.12.10 Sortieren mit IComparable/IComparer

3.12.11 Objektbäume in generischen Listen abspeichern

3.12.12 OOP beim Kartenspiel erlernen

4 Arrays, Strings, Funktionen

4.1 Datenfelder (Arrays)

4.1.1 Ein Array deklarieren

4.1.2 Zugriff auf Array-Elemente

4.1.3 Oberen Index ermitteln

4.1.4 Explizite Arraygrenzen

4.1.5 Arrays erzeugen und initialisieren

4.1.6 Zugriff mittels Schleife

4.1.7 Mehrdimensionale Arrays

4.1.8 Dynamische Arrays

4.1.9 Zuweisen von Arrays

4.1.10 Arrays aus Strukturvariablen

4.1.11 Löschen von Arrays

4.1.12 Eigenschaften und Methoden von Arrays

4.1.13 Übergabe von Arrays

4.2 Zeichenkettenverarbeitung

4.2.1 Strings zuweisen

4.2.2 Eigenschaften und Methoden eines Strings

4.2.3 Kopieren eines Strings in ein Char-Array

4.2.4 Wichtige (statische) Methoden der String-Klasse

4.2.5 Die StringBuilder-Klasse

4.3 Reguläre Ausdrücke

4.3.1 Wozu braucht man reguläre Ausdrücke?

4.3.2 Eine kleine Einführung

4.3.3 Wichtige Methoden der Klasse Regex

4.3.4 Kompilierte reguläre Ausdrücke

4.3.5 RegexOptions-Enumeration

4.3.6 Metazeichen (Escape-Zeichen)

4.3.7 Zeichenmengen (Character Sets)

4.3.8 Quantifizierer

4.3.9 Zero-Width Assertions

4.3.10 Gruppen

4.3.11 Text ersetzen

4.3.12 Text splitten

4.4 Datums- und Zeitberechnungen

4.4.1 Grundlegendes

4.4.2 Wichtige Eigenschaften von DateTime-Variablen

4.4.3 Wichtige Methoden von DateTime-Variablen

4.4.4 Wichtige Mitglieder der DateTime-Struktur

4.4.5 Konvertieren von Datumstrings in DateTime-Werte

4.4.6 Die TimeSpan-Struktur

4.5 Vordefinierten Funktionen

4.5.1 Mathematik

4.5.2 Datums- und Zeitfunktionen

4.6 Zahlen formatieren

4.6.1 Die ToString-Methode

4.6.2 Die Format-Methode

4.6.3 Stringinterpolation

4.7 Praxisbeispiele

4.7.1 Zeichenketten verarbeiten

4.7.2 Zeichenketten mittels StringBuilder addieren

4.7.3 Reguläre Ausdrücke testen

4.7.4 Fehler bei mathematischen Operationen behandeln

4.7.5 Methodenaufrufe mit Array-Parametern

4.7.6 String in Array kopieren und umgekehrt

4.7.7 Ein Byte-Array in einen String konvertieren

4.7.8 Strukturvariablen in Arrays einsetzen

5 Weitere Sprachfeatures

5.1 Namespaces (Namensräume)

5.1.1 Ein kleiner Überblick

5.1.2 Die Imports-Anweisung

5.1.3 Namespace-Alias

5.1.4 Namespaces in Projekteigenschaften

5.1.5 Namespace Alias Qualifizierer

5.1.6 Eigene Namespaces einrichten

5.2 Überladen von Operatoren

5.2.1 Syntaxregeln

5.2.2 Praktische Anwendung

5.2.3 Konvertierungsoperatoren überladen

5.3 Auflistungen (Collections)

5.3.1 Beziehungen zwischen den Schnittstellen

5.3.2 IEnumerable

5.3.3 ICollection

5.3.4 IList

5.3.5 Iteratoren

5.3.6 Die ArrayList-Collection

5.3.7 Die Hashtable

5.4 Generische Datentypen

5.4.1 Wie es früher einmal war

5.4.2 Typsicherheit durch Generics

5.4.3 List-Collection ersetzt ArrayList

5.4.4 Über die Vorzüge generischer Collections

5.4.5 Typbeschränkungen durch Constraints

5.4.6 Collection-Initialisierer

5.4.7 Generische Methoden

5.5 Delegates

5.5.1 Delegates sind Methodenzeiger

5.5.2 Delegate-Typ definieren

5.5.3 Delegate-Objekt erzeugen

5.5.4 Delegates vereinfacht instanziieren

5.5.5 Relaxed Delegates

5.5.6 Anonyme Methoden

5.5.7 Lambda-Ausdrücke

5.5.8 Lambda-Ausdrücke in der Task Parallel Library

5.6 Dynamische Programmierung

5.6.1 Wozu dynamische Programmierung?

5.6.2 Das Prinzip der dynamischen Programmierung

5.6.3 Kovarianz und Kontravarianz

5.7 Weitere Datentypen

5.7.1 BigInteger

5.7.2 Complex

5.7.3 Tuple(Of T)

5.7.4 SortedSet(Of T)

5.8 Praxisbeispiele

5.8.1 ArrayList versus generische List

5.8.2 Delegates und Lambda Expressions

5.8.3 Mit dynamischem Objekt eine Datei durchsuchen

6 Einführung in LINQ

6.1 LINQ-Grundlagen

6.1.1 Die LINQ-Architektur

6.1.2 LINQ-Implementierungen

6.1.3 Anonyme Typen

6.1.4 Erweiterungsmethoden

6.2 Abfragen mit LINQ to Objects

6.2.1 Grundlegendes zur LINQ-Syntax

6.2.2 Zwei alternative Schreibweisen von LINQ-Abfragen

6.2.3 Übersicht der wichtigsten Abfrage-Operatoren

6.3 LINQ-Abfragen im Detail

6.3.1 Die Projektionsoperatoren Select und SelectMany

6.3.2 Der Restriktionsoperator Where

6.3.3 Die Sortierungsoperatoren OrderBy und ThenBy

6.3.4 Der Gruppierungsoperator GroupBy

6.3.5 Verknüpfen mit Join

6.3.6 Aggregat-Operatoren

6.3.7 Verzögertes Ausführen von LINQ-Abfragen

6.3.8 Konvertierungsmethoden

6.3.9 Abfragen mit PLINQ

6.4 Praxisbeispiele

6.4.1 Die Syntax von LINQ-Abfragen verstehen

6.4.2 Aggregat-Abfragen mit LINQ

6.4.3 LINQ im Schnelldurchgang erlernen

6.4.4 Strings mit LINQ abfragen und filtern

6.4.5 Duplikate aus einer Liste oder einem Array entfernen

6.4.6 Arrays mit LINQ initialisieren

6.4.7 Arrays per LINQ mit Zufallszahlen füllen

6.4.8 Einen String mit Wiederholmuster erzeugen

6.4.9 Mit LINQ Zahlen und Strings sortieren

6.4.10 Mit LINQ Collections von Objekten sortieren

6.4.11 Ergebnisse von LINQ-Abfragen in ein Array kopieren

Teil II: Technologien

7 Zugriff auf das Dateisystem

7.1 Grundlagen

7.1.1 Klassen für Verzeichnis- und Dateioperationen

7.1.2 Statische versus Instanzen-Klasse

7.2 Übersichten

7.2.1 Methoden der Directory-Klasse

7.2.2 Methoden eines DirectoryInfo-Objekts

7.2.3 Eigenschaften eines DirectoryInfo-Objekts

7.2.4 Methoden der File-Klasse

7.2.5 Methoden eines FileInfo-Objekts

7.2.6 Eigenschaften eines FileInfo-Objekts

7.3 Operationen auf Verzeichnisebene

7.3.1 Existenz eines Verzeichnisses/einer Datei feststellen

7.3.2 Verzeichnisse erzeugen und löschen

7.3.3 Verzeichnisse verschieben und umbenennen

7.3.4 Aktuelles Verzeichnis bestimmen

7.3.5 Unterverzeichnisse ermitteln

7.3.6 Alle Laufwerke ermitteln

7.3.7 Dateien kopieren und verschieben

7.3.8 Dateien umbenennen

7.3.9 Dateiattribute feststellen

7.3.10 Verzeichnis einer Datei ermitteln

7.3.11 Alle im Verzeichnis enthaltene Dateien ermitteln

7.3.12 Dateien und Unterverzeichnisse ermitteln

7.4 Zugriffsberechtigungen

7.4.1 ACL und ACE

7.4.2 SetAccessControl-Methode

7.4.3 Zugriffsrechte anzeigen

7.5 Weitere wichtige Klassen

7.5.1 Die Path-Klasse

7.5.2 Die Klasse FileSystemWatcher

7.6 Datei- und Verzeichnisdialoge

7.6.1 OpenFileDialog und SaveFileDialog

7.6.2 FolderBrowserDialog

7.7 Praxisbeispiele

7.7.1 Infos über Verzeichnisse und Dateien gewinnen

7.7.2 Die Verzeichnisstruktur in eine TreeView einlesen

7.7.3 Mit LINQ und RegEx Verzeichnisbäume durchsuchen

8 Dateien lesen und schreiben

8.1 Grundprinzip der Datenpersistenz

8.1.1 Dateien und Streams

8.1.2 Die wichtigsten Klassen

8.1.3 Erzeugen eines Streams

8.2 Dateiparameter

8.2.1 FileAccess

8.2.2 FileMode

8.2.3 FileShare

8.3 Textdateien

8.3.1 Eine Textdatei beschreiben bzw. neu anlegen

8.3.2 Eine Textdatei lesen

8.4 Binärdateien

8.4.1 Lese-/Schreibzugriff

8.4.2 Die Methoden ReadAllBytes und WriteAllBytes

8.4.3 BinaryReader/BinaryWriter erzeugen

8.5 Sequenzielle Dateien

8.5.1 Lesen und Schreiben von strukturierten Daten

8.5.2 Serialisieren von Objekten

8.6 Dateien verschlüsseln und komprimieren

8.6.1 Das Methodenpärchen Encrypt-/Decrypt

8.6.2 Verschlüsseln unter Windows Vista/7/8/10

8.6.3 Verschlüsseln mit der CryptoStream-Klasse

8.6.4 Dateien komprimieren

8.7 Memory Mapped Files

8.7.1 Grundprinzip

8.7.2 Erzeugen eines MMF

8.7.3 Erstellen eines Map View

8.8 Praxisbeispiele

8.8.1 Auf eine Textdatei zugreifen

8.8.2 Einen Objektbaum speichern

8.8.3 Ein Memory Mapped File (MMF) verwenden

8.8.4 Hex-Dezimal-Bytes-Konverter

8.8.5 Eine Datei verschlüsseln

8.8.6 Eine Datei komprimieren

8.8.7 Echte ZIP-Dateien erstellen

8.8.8 PDFs erstellen/exportieren

8.8.9 Eine CSV-Datei erstellen

8.8.10 Eine CSV-Datei mit LINQ lesen und auswerten

8.8.11 Einen korrekten Dateinamen erzeugen

9 Asynchrone Programmierung

9.1 Übersicht

9.1.1 Multitasking versus Multithreading

9.1.2 Deadlocks

9.1.3 Racing

9.2 Programmieren mit Threads

9.2.1 Einführungsbeispiel

9.2.2 Wichtige Thread-Methoden

9.2.3 Wichtige Thread-Eigenschaften

9.2.4 Einsatz der ThreadPool-Klasse

9.3 Sperrmechanismen

9.3.1 Threading ohne SyncLock

9.3.2 Threading mit SyncLock

9.3.3 Die Monitor-Klasse

9.3.4 Mutex

9.3.5 Methoden für die parallele Ausführung sperren

9.3.6 Semaphore

9.4 Interaktion mit der Programmoberfläche

9.4.1 Die Werkzeuge

9.4.2 Einzelne Steuerelemente mit Invoke aktualisieren

9.4.3 Mehrere Steuerelemente aktualisieren

9.4.4 Ist ein Invoke-Aufruf nötig?

9.4.5 Und was ist mit WPF?

9.5 Timer-Threads

9.6 Die BackgroundWorker-Komponente

9.7 Asynchrone Programmier-Entwurfsmuster

9.7.1 Kurzübersicht

9.7.2 Polling

9.7.3 Callback verwenden

9.7.4 Callback mit Parameterübergabe verwenden

9.7.5 Callback mit Zugriff auf die Programm-Oberfläche

9.8 Asynchroner Aufruf beliebiger Methoden

9.8.1 Die Beispielklasse

9.8.2 Asynchroner Aufruf ohne Callback

9.8.3 Asynchroner Aufruf mit Callback und Anzeigefunktion

9.8.4 Aufruf mit Rückgabewerten (per Eigenschaft)

9.8.5 Aufruf mit Rückgabewerten (per EndInvoke)

9.9 Es geht auch einfacher – Async und Await

9.9.1 Der Weg von synchron zu asynchron

9.9.2 Achtung: Fehlerquellen!

9.9.3 Eigene asynchrone Methoden entwickeln

9.10 Praxisbeispiele

9.10.1 Spieltrieb & Multithreading erleben

9.10.2 Prozess- und Thread-Informationen gewinnen

9.10.3 Ein externes Programm starten

10 Die Task Parallel Library

10.1 Überblick

10.1.1 Parallel-Programmierung

10.1.2 Möglichkeiten der TPL

10.1.3 Der CLR-Threadpool

10.2 Parallele Verarbeitung mit Parallel.Invoke

10.2.1 Aufrufvarianten

10.2.2 Einschränkungen

10.3 Verwendung von Parallel.For

10.3.1 Abbrechen der Verarbeitung

10.3.2 Auswerten des Verarbeitungsstatus

10.3.3 Und was ist mit anderen Iterator-Schrittweiten?

10.4 Collections mit Parallel.ForEach verarbeiten

10.5 Die Task-Klasse

10.5.1 Einen Task erzeugen

10.5.2 Task starten

10.5.3 Datenübergabe an den Task

10.5.4 Wie warte ich auf das Taskende?

10.5.5 Tasks mit Rückgabewerten

10.5.6 Die Verarbeitung abbrechen

10.5.7 Fehlerbehandlung

10.5.8 Weitere Eigenschaften

10.6 Zugriff auf das Userinterface

10.6.1 Task-Ende und Zugriff auf die Oberfläche

10.6.2 Zugriff auf das UI aus dem Task heraus

10.7 Weitere Datenstrukturen im Überblick

10.7.1 Threadsichere Collections

10.7.2 Primitive für die Threadsynchronisation

10.8 Parallel LINQ (PLINQ)

10.9 Praxisbeispiel: Spieltrieb – Version 2

10.9.1 Aufgabenstellung

10.9.2 Global-Klasse

10.9.3 Controller

10.9.4 LKWs

10.9.5 Schiff-Klasse

10.9.6 Oberfläche

11 Fehlersuche und Behandlung

11.1 Der Debugger

11.1.1 Allgemeine Beschreibung

11.1.2 Die wichtigsten Fenster

11.1.3 Debugging-Optionen

11.1.4 Praktisches Debugging am Beispiel

11.2 Arbeiten mit Debug und Trace

11.2.1 Wichtige Methoden von Debug und Trace

11.2.2 Besonderheiten der Trace-Klasse

11.2.3 TraceListener-Objekte

11.3 Caller Information

11.3.1 Attribute

11.3.2 Anwendung

11.4 Fehlerbehandlung

11.4.1 Anweisungen zur Fehlerbehandlung

11.4.2 Try-Catch

11.4.3 Try-Finally

11.4.4 Das Standardverhalten bei Ausnahmen festlegen

11.4.5 Die Exception-Klasse

11.4.6 Fehler/Ausnahmen auslösen

11.4.7 Eigene Fehlerklassen

11.4.8 Exceptionhandling zur Entwurfszeit

11.4.9 Code Contracts

12 XML in Theorie und Praxis

12.1 XML – etwas Theorie

12.1.1 Übersicht

12.1.2 Der XML-Grundaufbau

12.1.3 Wohlgeformte Dokumente

12.1.4 Processing Instructions (PI)

12.1.5 Elemente und Attribute

12.1.6 Verwendbare Zeichensätze

12.2 XSD-Schemas

12.2.1 XSD-Schemas und ADO.NET

12.2.2 XML-Schemas in Visual Studio analysieren

12.2.3 XML-Datei mit XSD-Schema erzeugen

12.2.4 XSD-Schema aus einer XML-Datei erzeugen

12.3 XML-Integration in Visual Basic

12.3.1 XML-Literale

12.3.2 Einfaches Navigieren durch späte Bindung

12.3.3 Die LINQ to XML-API

12.3.4 Neue XML-Dokumente erzeugen

12.3.5 Laden und Sichern von XML-Dokumenten

12.3.6 Navigieren in XML-Daten

12.3.7 Auswählen und Filtern

12.3.8 Manipulieren der XML-Daten

12.3.9 XML-Dokumente transformieren

12.4 Verwendung des DOM unter .NET

12.4.1 Übersicht

12.4.2 DOM-Integration in Visual Basic

12.4.3 Laden von Dokumenten

12.4.4 Erzeugen von XML-Dokumenten

12.4.5 Auslesen von XML-Dateien

12.4.6 Direktzugriff auf einzelne Elemente

12.4.7 Einfügen von Informationen

12.4.8 Suchen in den Baumzweigen

12.5 Weitere Möglichkeiten der XML-Verarbeitung

12.5.1 Die relationale Sicht mit XmlDataDocument

12.5.2 XML-Daten aus Objektstrukturen erzeugen

12.5.3 Schnelles Suchen in XML-Daten mit XPathNavigator

12.5.4 Schnelles Auslesen von XML-Daten mit XmlReader

12.5.5 Erzeugen von XML-Daten mit XmlWriter

12.5.6 XML transformieren mit XSLT

12.6 Praxisbeispiele

12.6.1 Mit dem DOM in XML-Dokumenten navigieren

12.6.2 XML-Daten in eine TreeView einlesen

12.6.3 DataSets in XML-Strings konvertieren

12.6.4 In Dokumenten mit dem XPathNavigator navigieren

13 Einführung in ADO.NET

13.1 Eine kleine Übersicht

13.1.1 Die ADO.NET-Klassenhierarchie

13.1.2 Die Klassen der Datenprovider

13.1.3 Das Zusammenspiel der ADO.NET-Klassen

13.2 Das Connection-Objekt

13.2.1 Allgemeiner Aufbau

13.2.2 OleDbConnection

13.2.3 Schließen einer Verbindung

13.2.4 Eigenschaften des Connection-Objekts

13.2.5 Methoden des Connection-Objekts

13.2.6 Der ConnectionStringBuilder

13.3 Das Command-Objekt

13.3.1 Erzeugen und Anwenden eines Command-Objekts

13.3.2 Erzeugen mittels CreateCommand-Methode

13.3.3 Eigenschaften des Command-Objekts

13.3.4 Methoden des Command-Objekts

13.3.5 Freigabe von Connection- und Command-Objekten

13.4 Parameter-Objekte

13.4.1 Erzeugen und Anwenden eines Parameter-Objekts

13.4.2 Eigenschaften des Parameter-Objekts

13.5 Das CommandBuilder-Objekt

13.5.1 Erzeugen

13.5.2 Anwenden

13.6 Das DataReader-Objekt

13.6.1 DataReader erzeugen

13.6.2 Daten lesen

13.6.3 Eigenschaften des DataReaders

13.6.4 Methoden des DataReaders

13.7 Das DataAdapter-Objekt

13.7.1 DataAdapter erzeugen

13.7.2 Command-Eigenschaften

13.7.3 Fill-Methode

13.7.4 Update-Methode

13.8 Praxisbeispiele

13.8.1 Wichtige ADO.NET-Objekte im Einsatz

13.8.2 Eine Aktionsabfrage ausführen

13.8.3 Eine Auswahlabfrage aufrufen

13.8.4 Die Datenbank aktualisieren

13.8.5 Den ConnectionString speichern

14 Das DataSet

14.1 Grundlegende Features des DataSets

14.1.1 Die Objekthierarchie

14.1.2 Die wichtigsten Klassen

14.1.3 Erzeugen eines DataSets

14.2 Das DataTable-Objekt

14.2.1 DataTable erzeugen

14.2.2 Spalten hinzufügen

14.2.3 Zeilen zur DataTable hinzufügen

14.2.4 Auf den Inhalt einer DataTable zugreifen

14.3 Die DataView

14.3.1 Erzeugen eines DataView

14.3.2 Sortieren und Filtern von Datensätzen

14.3.3 Suchen von Datensätzen

14.4 Typisierte DataSets

14.4.1 Ein typisiertes DataSet erzeugen

14.4.2 Das Konzept der Datenquellen

14.4.3 Typisierte DataSets und TableAdapter

14.5 Die Qual der Wahl

14.5.1 DataReader – der schnelle Lesezugriff

14.5.2 DataSet – die Datenbank im Hauptspeicher

14.5.3 Objektrelationales Mapping – die Zukunft?

14.6 Praxisbeispiele

14.6.1 Im DataView sortieren und filtern

14.6.2 Suche nach Datensätzen

14.6.3 Ein DataSet in einen XML-String serialisieren

14.6.4 Untypisierte in typisierte DataSets konvertieren

14.6.5 Eine LINQ to SQL-Abfrage ausführen

15 Verteilen von Anwendungen

15.1 ClickOnce-Deployment

15.1.1 Übersicht/Einschränkungen

15.1.2 Die Vorgehensweise

15.1.3 Ort der Veröffentlichung

15.1.4 Anwendungsdateien

15.1.5 Erforderliche Komponenten

15.1.6 Aktualisierungen

15.1.7 Veröffentlichungsoptionen

15.1.8 Veröffentlichen

15.1.9 Verzeichnisstruktur

15.1.10 Der Webpublishing-Assistent

15.1.11 Neue Versionen erstellen

15.2 InstallShield

15.2.1 Installation

15.2.2 Aktivieren

15.2.3 Ein neues Setup-Projekt

15.2.4 Finaler Test

15.3 Hilfedateien programmieren

15.3.1 Der HTML Help Workshop

15.3.2 Bedienung am Beispiel

15.3.3 Hilfedateien in die VB-Anwendung einbinden

15.3.4 Eine alternative Hilfe-IDE verwenden

16 Weitere Techniken

16.1 Zugriff auf die Zwischenablage

16.1.1 Das Clipboard-Objekt

16.1.2 Zwischenablage-Funktionen für Textboxen

16.2 Arbeiten mit der Registry

16.2.1 Allgemeines

16.2.2 Registry-Unterstützung in .NET

16.3 .NET-Reflection

16.3.1 Übersicht

16.3.2 Assembly laden

16.3.3 Mittels GetType und Type Informationen sammeln

16.3.4 Dynamisches Laden von Assemblies

16.4 Praxisbeispiele

16.4.1 Zugriff auf die Registry

16.4.2 Dateiverknüpfungen erzeugen

16.4.3 Die Zwischenablage überwachen und anzeigen

16.4.4 Die WIA-Library kennenlernen

16.4.5 Auf eine Webcam zugreifen

16.4.6 Auf den Scanner zugreifen

16.4.7 OpenOffice.org Writer per OLE steuern

16.4.8 Nutzer und Gruppen des Systems ermitteln

16.4.9 Testen, ob Nutzer in einer Gruppe enthalten ist

16.4.10 Testen, ob der Nutzer ein Administrator ist

16.4.11 Die IP-Adressen des Computers bestimmen

16.4.12 Die IP-Adresse über den Hostnamen bestimmen

16.4.13 Diverse Systeminformationen ermitteln

16.4.14 Sound per MCI aufnehmen

16.4.15 Mikrofonpegel anzeigen

16.4.16 Pegeldiagramm aufzeichnen

16.4.17 Sound-und Video-Dateien per MCI abspielen

17 Konsolenanwendungen

17.1 Grundaufbau/Konzepte

17.1.1 Unser Hauptprogramm – Module1.vb

17.1.2 Rückgabe eines Fehlerstatus

17.1.3 Parameterübergabe

17.1.4 Zugriff auf die Umgebungsvariablen

17.2 Die Kommandozentrale: System.Console

17.2.1 Eigenschaften

17.2.2 Methoden/Ereignisse

17.2.3 Textausgaben

17.2.4 Farbangaben

17.2.5 Tastaturabfragen

17.2.6 Arbeiten mit Streamdaten

17.3 Praxisbeispiel: Farbige Konsolenanwendung

Teil III: Windows Apps

18 Erste Schritte

18.1 Grundkonzepte und Begriffe

18.1.1 Windows Runtime (WinRT)

18.1.2 Windows Store Apps

18.1.3 Fast and Fluid

18.1.4 Process Sandboxing und Contracts

18.1.5 .NET WinRT-Profil

18.1.6 Language Projection

18.1.7 Vollbildmodus – war da was?

18.1.8 Windows Store

18.1.9 Zielplattformen

18.2 Entwurfsumgebung

18.2.1 Betriebssystem

18.2.2 Windows-Simulator

18.2.3 Remote-Debugging

18.3 Ein (kleines) Einstiegsbeispiel

18.3.1 Aufgabenstellung

18.3.2 Quellcode

18.3.3 Oberflächenentwurf

18.3.4 Installation und Test

18.3.5 Touchscreen

18.3.6 Fazit

18.4 Weitere Details zu WinRT

18.4.1 Wo ist WinRT einzuordnen?

18.4.2 Die WinRT-API

18.4.3 Wichtige WinRT-Namespaces

18.4.4 Der Unterbau

18.5 Praxisbeispiel

18.5.1 WinRT in Desktop-Applikationen nutzen

19 App-Oberflächen entwerfen

19.1 Grundkonzepte

19.1.1 XAML (oder HTML 5) für die Oberfläche

19.1.2 Die Page, der Frame und das Window

19.1.3 Das Befehlsdesign

19.1.4 Die Navigationsdesigns

19.1.5 Achtung: Fingereingabe!

19.1.6 Verwendung von Schriftarten

19.2 Seitenauswahl und -navigation

19.2.1 Die Startseite festlegen

19.2.2 Navigation und Parameterübergabe

19.2.3 Den Seitenstatus erhalten

19.3 App-Darstellung

19.3.1 Vollbild quer und hochkant

19.3.2 Was ist mit Andocken und Füllmodus?

19.3.3 Reagieren auf die Änderung

19.4 Skalieren von Apps

19.5 Praxisbeispiele

19.5.1 Seitennavigation und Parameterübergabe

19.5.2 Die Fensterkopfzeile anpassen

20 Die wichtigsten Controls

20.1 Einfache WinRT-Controls

20.1.1 TextBlock, RichTextBlock

20.1.2 Button, HyperlinkButton, RepeatButton

20.1.3 CheckBox, RadioButton, ToggleButton, ToggleSwitch

20.1.4 TextBox, PasswordBox, RichEditBox

20.1.5 Image

20.1.6 ScrollBar, Slider, ProgressBar, ProgressRing

20.1.7 Border, Ellipse, Rectangle

20.2 Layout-Controls

20.2.1 Canvas

20.2.2 StackPanel

20.2.3 ScrollViewer

20.2.4 Grid

20.2.5 VariableSizedWrapGrid

20.2.6 SplitView

20.2.7 Pivot

20.2.8 RelativPanel

20.3 Listendarstellungen

20.3.1 ComboBox, ListBox

20.3.2 ListView

20.3.3 GridView

20.3.4 FlipView

20.4 Sonstige Controls

20.4.1 CaptureElement

20.4.2 MediaElement

20.4.3 Frame

20.4.4 WebView

20.4.5 ToolTip

20.4.6 CalendarDatePicker

20.4.7 DatePicker/TimePicker

20.5 Praxisbeispiele

20.5.1 Einen StringFormat-Konverter implementieren

20.5.2 Besonderheiten der TextBox kennen lernen

20.5.3 Daten in der GridView gruppieren

20.5.4 Das SemanticZoom-Control verwenden

20.5.5 Die CollectionViewSource verwenden

20.5.6 Zusammenspiel ListBox/AppBar

21 Apps im Detail

21.1 Ein Windows App-Projekt im Detail

21.1.1 Contracts und Extensions

21.1.2 AssemblyInfo.vb

21.1.3 Verweise

21.1.4 App.xaml und App.xaml.vb

21.1.5 Package.appxmanifest

21.1.6 Application1_TemporaryKey.pfx

21.1.7 MainPage.xaml & MainPage.xaml.vb

21.1.8 Assets/Symbole

21.1.9 Nach dem Kompilieren

21.2 Der Lebenszyklus einer Windows App

21.2.1 Möglichkeiten der Aktivierung von Apps

21.2.2 Der Splash Screen

21.2.3 Suspending

21.2.4 Resuming

21.2.5 Beenden von Apps

21.2.6 Die Ausnahmen von der Regel

21.2.7 Debuggen

21.3 Daten speichern und laden

21.3.1 Grundsätzliche Überlegungen

21.3.2 Worauf und wie kann ich zugreifen?

21.3.3 Das AppData-Verzeichnis

21.3.4 Das Anwendungs-Installationsverzeichnis

21.3.5 Das Downloads-Verzeichnis

21.3.6 Sonstige Verzeichnisse

21.3.7 Anwendungsdaten lokal sichern und laden

21.3.8 Daten in der Cloud ablegen/laden (Roaming)

21.3.9 Aufräumen

21.3.10 Sensible Informationen speichern

21.4 Praxisbeispiele

21.4.1 Die Auto-Play-Funktion unterstützen

21.4.2 Einen zusätzlichen Splash Screen einsetzen

21.4.3 Eine Dateiverknüpfung erstellen

22 App-Techniken

22.1 Arbeiten mit Dateien/Verzeichnissen

22.1.1 Verzeichnisinformationen auflisten

22.1.2 Unterverzeichnisse auflisten

22.1.3 Verzeichnisse erstellen/löschen

22.1.4 Dateien auflisten

22.1.5 Dateien erstellen/schreiben/lesen

22.1.6 Dateien kopieren/umbenennen/löschen

22.1.7 Verwenden der Dateipicker

22.1.8 StorageFile-/StorageFolder-Objekte speichern

22.1.9 Verwenden der Most Recently Used-Liste

22.2 Datenaustausch zwischen Apps/Programmen

22.2.1 Zwischenablage

22.2.2 Teilen von Inhalten

22.2.3 Eine App als Freigabeziel verwenden

22.2.4 Zugriff auf die Kontaktliste

22.3 Spezielle Oberflächenelemente

22.3.1 MessageDialog

22.3.2 ContentDialog

22.3.3 Popup-Benachrichtigungen

22.3.4 PopUp/Flyouts

22.3.5 Das PopupMenu einsetzen

22.3.6 Eine AppBar verwenden

22.4 Datenbanken und Windows Store Apps

22.4.1 Der Retter in der Not: SQLite!

22.4.2 Verwendung/Kurzüberblick

22.4.3 Installation

22.4.4 Wie kommen wir zu einer neuen Datenbank?

22.4.5 Wie werden die Daten manipuliert?

22.5 Vertrieb der App

22.5.1 Verpacken der App

22.5.2 App-Installation per Skript

22.6 Ein Blick auf die App-Schwachstellen

22.6.1 Quellcodes im Installationsverzeichnis

22.6.2 Zugriff auf den App-Datenordner

22.7 Praxisbeispiele

22.7.1 Ein Verzeichnis auf Änderungen überwachen

22.7.2 Eine App als Freigabeziel verwenden

22.7.3 ToastNotifications einfach erzeugen

Anhang

A Glossar

B Wichtige Dateiextensions

Index

Download-Kapitel