Visual C# 2017 - Grundlagen, Profiwissen und Rezepte

Inhalt

Vorwort

TEIL I: Grundlagen

1 Einstieg in Visual Studio 2017

1.1 Die Installation von Visual Studio 2017

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 2017

1.4 Die Entwicklungsumgebung Visual Studio 2017

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 Praxisbeispiele

1.6.1 Unsere erste Windows-Forms-Anwendung

1.6.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 Sortieren mit IComparable/IComparer

3.9.7 Einen Objektbaum in generischen Listen abspeichern

3.9.8 OOP beim Kartenspiel erlernen

3.9.9 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.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 Abfrageoperatoren

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

7 C#-Sprachneuerungen im Überblick

7.1 C# 4.0 – Visual Studio 2010

7.1.1 Datentyp dynamic

7.1.2 Benannte und optionale Parameter

7.1.3 Covarianz und Contravarianz

7.2 C# 5.0 – Visual Studio 2012

7.2.1 Async und Await

7.2.2 CallerInfo

7.3 Visual Studio 2013

7.4 C# 6.0 – Visual Studio 2015

7.4.1 String Interpolation

7.4.2 Schreibgeschützte AutoProperties

7.4.3 Initialisierer für AutoProperties

7.4.4 Expression Body Funktionsmember

7.4.5 using static

7.4.6 Bedingter Nulloperator

7.4.7 Ausnahmenfilter

7.4.8 nameof-Ausdrücke

7.4.9 await in catch und finally

7.4.10 Indexinitialisierer

7.5 C# 7.0 – Visual Studio 2017

7.5.1 out-Variablen

7.5.2 Tupel

7.5.3 Mustervergleich

7.5.4 Discards

7.5.5 Lokale ref-Variablen und Rückgabetypen

7.5.6 Lokale Funktionen

7.5.7 Mehr Expression-Bodied Member

7.5.8 throw-Ausdrücke

7.5.9 Verbesserung der numerischen literalen Syntax

Teil II: Technologien

8 Zugriff auf das Dateisystem

8.1 Grundlagen

8.1.1 Klassen für den Zugriff auf das Dateisystem

8.1.2 Statische versus Instanzen-Klasse

8.2 Übersichten

8.2.1 Methoden der Directory-Klasse

8.2.2 Methoden eines DirectoryInfo-Objekts

8.2.3 Eigenschaften eines DirectoryInfo-Objekts

8.2.4 Methoden der File-Klasse

8.2.5 Methoden eines FileInfo-Objekts

8.2.6 Eigenschaften eines FileInfo-Objekts

8.3 Operationen auf Verzeichnisebene

8.3.1 Existenz eines Verzeichnisses/einer Datei feststellen

8.3.2 Verzeichnisse erzeugen und löschen

8.3.3 Verzeichnisse verschieben und umbenennen

8.3.4 Aktuelles Verzeichnis bestimmen

8.3.5 Unterverzeichnisse ermitteln

8.3.6 Alle Laufwerke ermitteln

8.3.7 Dateien kopieren und verschieben

8.3.8 Dateien umbenennen

8.3.9 Dateiattribute feststellen

8.3.10 Verzeichnis einer Datei ermitteln

8.3.11 Alle im Verzeichnis enthaltenen Dateien ermitteln

8.3.12 Dateien und Unterverzeichnisse ermitteln

8.4 Zugriffsberechtigungen

8.4.1 ACL und ACE

8.4.2 SetAccessControl-Methode

8.4.3 Zugriffsrechte anzeigen

8.5 Weitere wichtige Klassen

8.5.1 Die Path-Klasse

8.5.2 Die Klasse FileSystemWatcher

8.5.3 Die Klasse ZipArchive

8.6 Datei- und Verzeichnisdialoge

8.6.1 OpenFileDialog und SaveFileDialog

8.6.2 FolderBrowserDialog

8.7 Praxisbeispiele

8.7.1 Infos über Verzeichnisse und Dateien gewinnen

8.7.2 Eine Verzeichnisstruktur in die TreeView einlesen

8.7.3 Mit LINQ und RegEx Verzeichnisbäume durchsuchen

9 Dateien lesen und schreiben

9.1 Grundprinzip der Datenpersistenz

9.1.1 Dateien und Streams

9.1.2 Die wichtigsten Klassen

9.1.3 Erzeugen eines Streams

9.2 Dateiparameter

9.2.1 FileAccess

9.2.2 FileMode

9.2.3 FileShare

9.3 Textdateien

9.3.1 Eine Textdatei beschreiben bzw. neu anlegen

9.3.2 Eine Textdatei lesen

9.4 Binärdateien

9.4.1 Lese-/Schreibzugriff

9.4.2 Die Methoden ReadAllBytes und WriteAllBytes

9.4.3 Erzeugen von BinaryReader/BinaryWriter

9.5 Sequenzielle Dateien

9.5.1 Lesen und Schreiben von strukturierten Daten

9.5.2 Serialisieren von Objekten

9.6 Dateien verschlüsseln und komprimieren

9.6.1 Das Methodenpärchen Encrypt/Decrypt

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

9.6.3 Verschlüsseln mit der CryptoStream-Klasse

9.6.4 Dateien komprimieren

9.7 Memory Mapped Files

9.7.1 Grundprinzip

9.7.2 Erzeugen eines MMF

9.7.3 Erstellen eines Map View

9.8 Praxisbeispiele

9.8.1 Auf eine Textdatei zugreifen

9.8.2 Einen Objektbaum persistent speichern

9.8.3 Ein Memory Mapped File (MMF) verwenden

9.8.4 Hex-Dezimal-Bytes-Konverter

9.8.5 Eine Datei verschlüsseln

9.8.6 Eine Datei komprimieren

9.8.7 PDFs erstellen/exportieren

9.8.8 Eine CSV-Datei erstellen

9.8.9 Eine CSV-Datei mit LINQ lesen und auswerten

9.8.10 Einen korrekten Dateinamen erzeugen

10 Asynchrone Programmierung

10.1 Übersicht

10.1.1 Multitasking versus Multithreading

10.1.2 Deadlocks

10.1.3 Racing

10.2 Programmieren mit Threads

10.2.1 Einführungsbeispiel

10.2.2 Wichtige Thread-Methoden

10.2.3 Wichtige Thread-Eigenschaften

10.2.4 Einsatz der ThreadPool-Klasse

10.3 Sperrmechanismen

10.3.1 Threading ohne lock

10.3.2 Threading mit lock

10.3.3 Die Monitor-Klasse

10.3.4 Mutex

10.3.5 Methoden für die parallele Ausführung sperren

10.3.6 Semaphore

10.4 Interaktion mit der Programmoberfläche

10.4.1 Die Werkzeuge

10.4.2 Einzelne Steuerelemente mit Invoke aktualisieren

10.4.3 Mehrere Steuerelemente aktualisieren

10.4.4 Ist ein Invoke-Aufruf nötig?

10.4.5 Und was ist mit WPF?

10.5 Timer-Threads

10.6 Die BackgroundWorker-Komponente

10.7 Asynchrone Programmierentwurfsmuster

10.7.1 Kurzübersicht

10.7.2 Polling

10.7.3 Callback verwenden

10.7.4 Callback mit Parameterübergabe verwenden

10.7.5 Callback mit Zugriff auf die Programmoberfläche

10.8 Asynchroner Aufruf beliebiger Methoden

10.8.1 Die Beispielklasse

10.8.2 Asynchroner Aufruf ohne Callback

10.8.3 Asynchroner Aufruf mit Callback und Anzeigefunktion

10.8.4 Aufruf mit Rückgabewerten (per Eigenschaft)

10.8.5 Aufruf mit Rückgabewerten (per EndInvoke)

10.9 Es geht auch einfacher – async und await

10.9.1 Der Weg von synchron zu asynchron

10.9.2 Achtung: Fehlerquellen!

10.9.3 Eigene asynchrone Methoden entwickeln

10.10 Praxisbeispiele

10.10.1 Spieltrieb & Multithreading erleben

10.10.2 Prozess- und Thread-Informationen gewinnen

10.10.3 Ein externes Programm starten

11 Die Task Parallel Library

11.1 Überblick

11.1.1 Parallel-Programmierung

11.1.2 Möglichkeiten der TPL

11.1.3 Der CLR-Threadpool

11.2 Parallele Verarbeitung mit Parallel.Invoke

11.2.1 Aufrufvarianten

11.2.2 Einschränkungen

11.3 Verwendung von Parallel.For

11.3.1 Abbrechen der Verarbeitung

11.3.2 Auswerten des Verarbeitungsstatus

11.3.3 Und was ist mit anderen Iterator-Schrittweiten?

11.4 Collections mit Parallel.ForEach verarbeiten

11.5 Die Task-Klasse

11.5.1 Einen Task erzeugen

11.5.2 Den Task starten

11.5.3 Datenübergabe an den Task

11.5.4 Wie warte ich auf das Ende des Task?

11.5.5 Tasks mit Rückgabewerten

11.5.6 Die Verarbeitung abbrechen

11.5.7 Fehlerbehandlung

11.5.8 Weitere Eigenschaften

11.6 Zugriff auf das User-Interface

11.6.1 Task-Ende und Zugriff auf die Oberfläche

11.6.2 Zugriff auf das UI aus dem Task heraus

11.7 Weitere Datenstrukturen im Überblick

11.7.1 Threadsichere Collections

11.7.2 Primitive für die Threadsynchronisation

11.8 Parallel LINQ (PLINQ)

11.9 Praxisbeispiel: Spieltrieb – Version 2

11.9.1 Aufgabenstellung

11.9.2 Global-Klasse

11.9.3 Controller-Klasse

11.9.4 LKW-Klasse

11.9.5 Schiff-Klasse

11.9.6 Oberfläche

12 Fehlersuche und Behandlung

12.1 Der Debugger

12.1.1 Allgemeine Beschreibung

12.1.2 Die wichtigsten Fenster

12.1.3 Debugging-Optionen

12.1.4 Praktisches Debugging am Beispiel

12.2 Arbeiten mit Debug und Trace

12.2.1 Wichtige Methoden von Debug und Trace

12.2.2 Besonderheiten der Trace-Klasse

12.2.3 TraceListener-Objekte

12.3 Caller Information

12.3.1 Attribute

12.3.2 Anwendung

12.4 Fehlerbehandlung

12.4.1 Anweisungen zur Fehlerbehandlung

12.4.2 try-catch

12.4.3 try-finally

12.4.4 Das Standardverhalten bei Ausnahmen festlegen

12.4.5 Die Exception-Klasse

12.4.6 Fehler/Ausnahmen auslösen

12.4.7 Eigene Fehlerklassen

12.4.8 Exceptionhandling zur Entwurfszeit

12.4.9 Code Contracts

13 XML in Theorie und Praxis

13.1 XML – etwas Theorie

13.1.1 Übersicht

13.1.2 Der XML-Grundaufbau

13.1.3 Wohlgeformte Dokumente

13.1.4 Processing Instructions (PI)

13.1.5 Elemente und Attribute

13.1.6 Verwendbare Zeichensätze

13.2 XSD-Schemas

13.2.1 XSD-Schemas und ADO.NET

13.2.2 XML-Schemas in Visual Studio analysieren

13.2.3 XML-Datei mit XSD-Schema erzeugen

13.2.4 XSD-Schema aus einer XML-Datei erzeugen

13.3 Verwendung des DOM unter .NET

13.3.1 Übersicht

13.3.2 DOM-Integration in C#

13.3.3 Laden von Dokumenten

13.3.4 Erzeugen von XML-Dokumenten

13.3.5 Auslesen von XML-Dateien

13.3.6 Direktzugriff auf einzelne Elemente

13.3.7 Einfügen von Informationen

13.3.8 Suchen in den Baumzweigen

13.4 XML-Verarbeitung mit LINQ to XML

13.4.1 Die LINQ to XML-API

13.4.2 Neue XML-Dokumente erzeugen

13.4.3 Laden und Sichern von XML-Dokumenten

13.4.4 Navigieren in XML-Daten

13.4.5 Auswählen und Filtern

13.4.6 Manipulieren der XML-Daten

13.4.7 XML-Dokumente transformieren

13.5 Weitere Möglichkeiten der XML-Verarbeitung

13.5.1 XML-Daten aus Objektstrukturen erzeugen

13.5.2 Schnelles Suchen in XML-Daten mit XPathNavigator

13.5.3 Schnelles Auslesen von XML-Daten mit XmlReader

13.5.4 Erzeugen von XML-Daten mit XmlWriter

13.5.5 XML transformieren mit XSLT

13.6 JSON – JavaScriptObjectNotation

13.6.1 Grundlagen

13.6.2 De-/Serialisierung mit JSON

13.7 Praxisbeispiele

13.7.1 Mit dem DOM in XML-Dokumenten navigieren

13.7.2 XML-Daten in eine TreeView einlesen

13.7.3 In Dokumenten mit dem XPathNavigator navigieren

14 Einführung in ADO.NET und Entity Framework

14.1 Eine kleine Übersicht

14.1.1 Die ADO.NET-Klassenhierarchie

14.1.2 Die Klassen der Datenprovider

14.1.3 Das Zusammenspiel der ADO.NET-Klassen

14.2 Das Connection-Objekt

14.2.1 Allgemeiner Aufbau

14.2.2 SqlConnection

14.2.3 Schließen einer Verbindung

14.2.4 Eigenschaften des Connection-Objekts

14.2.5 Methoden des Connection-Objekts

14.2.6 Der ConnectionStringBuilder

14.3 Das Command-Objekt

14.3.1 Erzeugen und Anwenden eines Command-Objekts

14.3.2 Erzeugen mittels CreateCommand-Methode

14.3.3 Eigenschaften des Command-Objekts

14.3.4 Methoden des Command-Objekts

14.3.5 Freigabe von Connection- und Command-Objekten

14.4 Parameter-Objekte

14.4.1 Erzeugen und Anwenden eines Parameter-Objekts

14.4.2 Eigenschaften des Parameter-Objekts

14.5 Das CommandBuilder-Objekt

14.5.1 Erzeugen

14.5.2 Anwenden

14.6 Das DataReader-Objekt

14.6.1 DataReader erzeugen

14.6.2 Daten lesen

14.6.3 Eigenschaften des DataReaders

14.6.4 Methoden des DataReaders

14.7 Das DataAdapter-Objekt

14.7.1 DataAdapter erzeugen

14.7.2 Command-Eigenschaften

14.7.3 Fill-Methode

14.7.4 Update-Methode

14.8 Entity Framework

14.8.1 Überblick

14.8.2 DatabaseFirst

14.8.3 CodeFirst

14.9 Praxisbeispiele

14.9.1 Wichtige ADO.NET-Objekte im Einsatz

14.9.2 Eine Aktionsabfrage ausführen

14.9.3 Eine StoredProcedure aufrufen

14.9.4 Die Datenbank aktualisieren

15 Das DataSet

15.1 Grundlegende Features des DataSets

15.1.1 Die Objekthierarchie

15.1.2 Die wichtigsten Klassen

15.1.3 Erzeugen eines DataSets

15.2 Das DataTable-Objekt

15.2.1 DataTable erzeugen

15.2.2 Spalten hinzufügen

15.2.3 Zeilen zur DataTable hinzufügen

15.2.4 Auf den Inhalt einer DataTable zugreifen

15.3 Die DataView

15.3.1 Erzeugen einer DataView

15.3.2 Sortieren und Filtern von Datensätzen

15.3.3 Suchen von Datensätzen

15.4 Typisierte DataSets

15.4.1 Ein typisiertes DataSet erzeugen

15.4.2 Das Konzept der Datenquellen

15.4.3 Typisierte DataSets und TableAdapter

15.5 Die Qual der Wahl

15.5.1 DataReader – der schnelle Lesezugriff

15.5.2 DataSet – die Datenbank im Hauptspeicher

15.5.3 Objektrelationales Mapping – die Zukunft?

15.6 Praxisbeispiele

15.6.1 In der DataView sortieren und filtern

15.6.2 Suche nach Datensätzen

15.6.3 Ein DataSet in einen XML-String serialisieren

15.6.4 Untypisiertes DataSet in ein typisiertes konvertieren

16 Verteilen von Anwendungen

16.1 ClickOnce-Deployment

16.1.1 Übersicht/Einschränkungen

16.1.2 Die Vorgehensweise

16.1.3 Ort der Veröffentlichung

16.1.4 Anwendungsdateien

16.1.5 Erforderliche Komponenten

16.1.6 Aktualisierungen

16.1.7 Veröffentlichungsoptionen

16.1.8 Veröffentlichen

16.1.9 Verzeichnisstruktur

16.1.10 Der Webpublishing-Assistent

16.1.11 Neue Versionen erstellen

16.2 Setup-Projekte

16.2.1 Installation

16.2.2 Ein neues Setup-Projekt

16.2.3 Dateisystem-Editor

16.2.4 Registrierungs-Editor

16.2.5 Dateityp-Editor

16.2.6 Benutzeroberflächen-Editor

16.2.7 Editor für benutzerdefinierte Aktionen

16.2.8 Editor für Startbedingungen

17 Weitere Techniken

17.1 Zugriff auf die Zwischenablage

17.1.1 Das Clipboard-Objekt

17.1.2 Zwischenablage-Funktionen für Textboxen

17.2 Arbeiten mit der Registry

17.2.1 Allgemeines

17.2.2 Registry-Unterstützung in .NET

17.3 .NET-Reflection

17.3.1 Übersicht

17.3.2 Assembly laden

17.3.3 Mittels GetType und Type Informationen sammeln

17.3.4 Dynamisches Laden von Assemblies

17.4 Praxisbeispiele

17.4.1 Zugriff auf die Registry

17.4.2 Dateiverknüpfungen erzeugen

17.4.3 Betrachter für Manifestressourcen

17.4.4 Die Zwischenablage überwachen und anzeigen

17.4.5 Die WIA-Library kennenlernen

17.4.6 Auf eine Webcam zugreifen

17.4.7 Auf den Scanner zugreifen

17.4.8 OpenOffice.org Writer per OLE steuern

17.4.9 Nutzer und Gruppen des aktuellen Systems ermitteln

17.4.10 Testen, ob Nutzer in einer Gruppe enthalten ist

17.4.11 Testen, ob der Nutzer ein Administrator ist

17.4.12 Die IP-Adressen des Computers bestimmen

17.4.13 Die IP-Adresse über den Hostnamen bestimmen

17.4.14 Diverse Systeminformationen ermitteln

17.4.15 Alles über den Bildschirm erfahren

17.4.16 Sound per MCI aufnehmen

17.4.17 Mikrofonpegel anzeigen

17.4.18 Pegeldiagramm aufzeichnen

17.4.19 Sound-und Videodateien per MCI abspielen

18 Konsolenanwendungen

18.1 Grundaufbau/Konzepte

18.1.1 Unser Hauptprogramm – Program.cs

18.1.2 Rückgabe eines Fehlerstatus

18.1.3 Parameterübergabe

18.1.4 Zugriff auf die Umgebungsvariablen

18.2 Die Kommandozentrale: System.Console

18.2.1 Eigenschaften

18.2.2 Methoden/Ereignisse

18.2.3 Textausgaben

18.2.4 Farbangaben

18.2.5 Tastaturabfragen

18.2.6 Arbeiten mit Streamdaten

18.3 Praxisbeispiel

18.3.1 Farbige Konsolenanwendung

18.3.2 Weitere Hinweise und Beispiele

Anhang A: Glossar

Anhang B: Wichtige Dateiextensions

Index

Leere Seite