Visual C# 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 C#-Programm

1.2.1 Vorbereitungen

1.2.2 Quellcode 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 Programmieren mit 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 C#-Sprachfeatures

1.6.3 Code-Editor

1.6.4 NET Framework 4.6

1.7 Praxisbeispiele

1.7.1 Unsere erste Windows Forms-Anwendung

1.7.2 Umrechnung Euro-Dollar

2 Grundlagen der Sprache C#

2.1 Grundbegriffe

2.1.1 Anweisungen

2.1.2 Bezeichner

2.1.3 Schlüsselwörter

2.1.4 Kommentare

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 Typsuffixe

2.2.6 Zeichen und Zeichenketten

2.2.7 object-Datentyp

2.2.8 Konstanten deklarieren

2.2.9 Nullable Types

2.2.10 Typinferenz

2.2.11 Gültigkeitsbereiche und Sichtbarkeit

2.3 Konvertieren von Datentypen

2.3.1 Implizite und explizite Konvertierung

2.3.2 Welcher Datentyp passt zu welchem?

2.3.3 Konvertieren von string

2.3.4 Die Convert-Klasse

2.3.5 Die Parse-Methode

2.3.6 Boxing und Unboxing

2.4 Operatoren

2.4.1 Arithmetische Operatoren

2.4.2 Zuweisungsoperatoren

2.4.3 Logische Operatoren

2.4.4 Rangfolge der Operatoren

2.5 Kontrollstrukturen

2.5.1 Verzweigungsbefehle

2.5.2 Schleifenanweisungen

2.6 Benutzerdefinierte Datentypen

2.6.1 Enumerationen

2.6.2 Strukturen

2.7 Nutzerdefinierte Methoden

2.7.1 Methoden mit Rückgabewert

2.7.2 Methoden ohne Rückgabewert

2.7.3 Parameterübergabe mit ref

2.7.4 Parameterübergabe mit out

2.7.5 Methodenüberladung

2.7.6 Optionale Parameter

2.7.7 Benannte Parameter

2.8 Praxisbeispiele

2.8.1 Vom PAP zur Konsolenanwendung

2.8.2 Ein Konsolen- in ein Windows-Programm verwandeln

2.8.3 Schleifenanweisungen verstehen

2.8.4 Benutzerdefinierte Methoden überladen

2.8.5 Anwendungen von Visual Basic nach C# portieren

3 OOP-Konzepte

3.1 Kleine Einführung in die OOP

3.1.1 Historische Entwicklung

3.1.2 Grundbegriffe der OOP

3.1.3 Sichtbarkeit von Klassen und ihren Mitgliedern

3.1.4 Allgemeiner Aufbau einer Klasse

3.1.5 Das Erzeugen eines Objekts

3.1.6 Einführungsbeispiel

3.2 Eigenschaften

3.2.1 Eigenschaften mit Zugriffsmethoden kapseln

3.2.2 Berechnete Eigenschaften

3.2.3 Lese-/Schreibschutz

3.2.4 Property-Accessoren

3.2.5 Statische Felder/Eigenschaften

3.2.6 Einfache Eigenschaften automatisch implementieren

3.3 Methoden

3.3.1 Öffentliche und private Methoden

3.3.2 Überladene Methoden

3.3.3 Statische Methoden

3.4 Ereignisse

3.4.1 Ereignis hinzufügen

3.4.2 Ereignis verwenden

3.5 Arbeiten mit Konstruktor und Destruktor

3.5.1 Konstruktor und Objektinitialisierer

3.5.2 Destruktor und Garbage Collector

3.5.3 Mit using den Lebenszyklus des Objekts kapseln

3.5.4 Verzögerte Initialisierung

3.6 Vererbung und Polymorphie

3.6.1 Klassendiagramm

3.6.2 Method-Overriding

3.6.3 Klassen implementieren

3.6.4 Implementieren der Objekte

3.6.5 Ausblenden von Mitgliedern durch Vererbung

3.6.6 Allgemeine Hinweise und Regeln zur Vererbung

3.6.7 Polymorphes Verhalten

3.6.8 Die Rolle von System.Object

3.7 Spezielle Klassen

3.7.1 Abstrakte Klassen

3.7.2 Versiegelte Klassen

3.7.3 Partielle Klassen

3.7.4 Statische Klassen

3.8 Schnittstellen (Interfaces)

3.8.1 Definition einer Schnittstelle

3.8.2 Implementieren einer Schnittstelle

3.8.3 Abfragen, ob Schnittstelle vorhanden ist

3.8.4 Mehrere Schnittstellen implementieren

3.8.5 Schnittstellenprogrammierung ist ein weites Feld

3.9 Praxisbeispiele

3.9.1 Eigenschaften sinnvoll kapseln

3.9.2 Eine statische Klasse anwenden

3.9.3 Vom fetten zum schlanken Client

3.9.4 Schnittstellenvererbung verstehen

3.9.5 Rechner für komplexe Zahlen

3.9.6 Formel-Rechner mit dem CodeDOM

3.9.7 Berechnungsergebnisse als Diagramm darstellen

3.9.8 Sortieren mit IComparable/IComparer

3.9.9 Einen Objektbaum in generischen Listen abspeichern

3.9.10 OOP beim Kartenspiel erlernen

3.9.11 Eine Klasse zur Matrizenrechnung entwickeln

4 Arrays, Strings, Funktionen

4.1 Datenfelder (Arrays)

4.1.1 Array deklarieren

4.1.2 Array instanziieren

4.1.3 Array initialisieren

4.1.4 Zugriff auf Array-Elemente

4.1.5 Zugriff mittels Schleife

4.1.6 Mehrdimensionale Arrays

4.1.7 Zuweisen von Arrays

4.1.8 Arrays aus Strukturvariablen

4.1.9 Löschen und Umdimensionieren von Arrays

4.1.10 Eigenschaften und Methoden von Arrays

4.1.11 Übergabe von Arrays

4.2 Verarbeiten von Zeichenketten

4.2.1 Zuweisen von Strings

4.2.2 Eigenschaften und Methoden von String-Variablen

4.2.3 Wichtige Methoden der String-Klasse

4.2.4 Die StringBuilder-Klasse

4.3 Reguläre Ausdrücke

4.3.1 Wozu werden reguläre Ausdrücke verwendet?

4.3.2 Eine kleine Einführung

4.3.3 Wichtige Methoden/Eigenschaften 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 Die DateTime-Struktur

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 Mathematische Funktionen

4.5.1 Überblick

4.5.2 Zahlen runden

4.5.3 Winkel umrechnen

4.5.4 Potenz- und Wurzeloperationen

4.5.5 Logarithmus und Exponentialfunktionen

4.5.6 Zufallszahlen erzeugen

4.6 Zahlen- und Datumsformatierungen

4.6.1 Anwenden der ToString-Methode

4.6.2 Anwenden der Format-Methode

4.6.3 Stringinterpolation

4.7 Praxisbeispiele

4.7.1 Zeichenketten verarbeiten

4.7.2 Zeichenketten mit StringBuilder addieren

4.7.3 Reguläre Ausdrücke testen

4.7.4 Methodenaufrufe mit Array-Parametern

5 Weitere Sprachfeatures

5.1 Namespaces (Namensräume)

5.1.1 Ein kleiner Überblick

5.1.2 Einen eigenen Namespace einrichten

5.1.3 Die using-Anweisung

5.1.4 Namespace Alias

5.1.5 Namespace Alias Qualifizierer

5.2 Operatorenüberladung

5.2.1 Syntaxregeln

5.2.2 Praktische Anwendung

5.3 Collections (Auflistungen)

5.3.1 Die Schnittstelle IEnumerable

5.3.2 ArrayList

5.3.3 Hashtable

5.3.4 Indexer

5.4 Generics

5.4.1 Klassische Vorgehensweise

5.4.2 Generics bieten Typsicherheit

5.4.3 Generische Methoden

5.4.4 Iteratoren

5.5 Generische Collections

5.5.1 List-Collection statt ArrayList

5.5.2 Vorteile generischer Collections

5.5.3 Constraints

5.6 Das Prinzip der Delegates

5.6.1 Delegates sind Methodenzeiger

5.6.2 Einen Delegate-Typ deklarieren

5.6.3 Ein Delegate-Objekt erzeugen

5.6.4 Delegates vereinfacht instanziieren

5.6.5 Anonyme Methoden

5.6.6 Lambda-Ausdrücke

5.6.7 Lambda-Ausdrücke in der Task Parallel Library

5.7 Dynamische Programmierung

5.7.1 Wozu dynamische Programmierung?

5.7.2 Das Prinzip der dynamischen Programmierung

5.7.3 Optionale Parameter sind hilfreich

5.7.4 Kovarianz und Kontravarianz

5.8 Weitere Datentypen

5.8.1 BigInteger

5.8.2 Complex

5.8.3 Tuple<>

5.8.4 SortedSet<>

5.9 Praxisbeispiele

5.9.1 ArrayList versus generische List

5.9.2 Generische IEnumerable-Interfaces implementieren

5.9.3 Delegates, anonyme Methoden, Lambda Expressions

5.9.4 Dynamischer Zugriff auf COM Interop

6 Einführung in LINQ

6.1 LINQ-Grundlagen

6.1.1 Die LINQ-Architektur

6.1.2 Anonyme Typen

6.1.3 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 den Zugriff auf das Dateisystem

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 enthaltenen 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 Eine Verzeichnisstruktur in die 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 Erzeugen von BinaryReader/BinaryWriter

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 persistent 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 lock

9.3.2 Threading mit lock

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 Den Task starten

10.5.3 Datenübergabe an den Task

10.5.4 Wie warte ich auf das Ende des Task?

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 User-Interface

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-Klasse

10.9.4 LKW-Klasse

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 Verwendung des DOM unter .NET

12.3.1 Übersicht

12.3.2 DOM-Integration in C#

12.3.3 Laden von Dokumenten

12.3.4 Erzeugen von XML-Dokumenten

12.3.5 Auslesen von XML-Dateien

12.3.6 Direktzugriff auf einzelne Elemente

12.3.7 Einfügen von Informationen

12.3.8 Suchen in den Baumzweigen

12.4 XML-Verarbeitung mit LINQ to XML

12.4.1 Die LINQ to XML-API

12.4.2 Neue XML-Dokumente erzeugen

12.4.3 Laden und Sichern von XML-Dokumenten

12.4.4 Navigieren in XML-Daten

12.4.5 Auswählen und Filtern

12.4.6 Manipulieren der XML-Daten

12.4.7 XML-Dokumente transformieren

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 Ein DataSet in einen XML-String konvertieren

12.6.4 Ein DataSet in einer XML-Datei speichern

12.6.5 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

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 einer 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 In der DataView sortieren und filtern

14.6.2 Suche nach Datensätzen

14.6.3 Ein DataSet in einen XML-String serialisieren

14.6.4 Untypisiertes in ein typisiertes DataSet 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 Visual C#-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 Betrachter für Manifestressourcen

16.4.4 Die Zwischenablage überwachen und anzeigen

16.4.5 Die WIA-Library kennenlernen

16.4.6 Auf eine Webcam zugreifen

16.4.7 Auf den Scanner zugreifen

16.4.8 OpenOffice.org Writer per OLE steuern

16.4.9 Nutzer und Gruppen des aktuellen Systems ermitteln

16.4.10 Testen, ob Nutzer in einer Gruppe enthalten ist

16.4.11 Testen, ob der Nutzer ein Administrator ist

16.4.12 Die IP-Adressen des Computers bestimmen

16.4.13 Die IP-Adresse über den Hostnamen bestimmen

16.4.14 Diverse Systeminformationen ermitteln

16.4.15 Environment Variablen auslesen

16.4.16 Alles über den Bildschirm erfahren

16.4.17 Sound per MCI aufnehmen

16.4.18 Mikrofonpegel anzeigen

16.4.19 Pegeldiagramm aufzeichnen

16.4.20 Sound-und Video-Dateien per MCI abspielen

17 Konsolenanwendungen

17.1 Grundaufbau/Konzepte

17.1.1 Unser Hauptprogramm – Program.cs

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

17.3.1 Farbige Konsolenanwendung

17.3.2 Weitere Hinweise und Beispiele

Teil III: Windows Apps

18 Erste Schritte

18.1 Grundkonzepte und Begriffe

18.1.1 Windows Runtime (WinRT)

18.1.2 Windows 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.cs

21.1.3 Verweise

21.1.4 App.xaml und App.xaml.cs

21.1.5 Package.appxmanifest

21.1.6 Application1_TemporaryKey.pfx

21.1.7 MainPage.xaml & MainPage.xaml.cs

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/CommandBar 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