Titelei
Impressum
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.orgWriter 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
Walter Doberenz
Thomas Gewinnus
Jürgen Kotz
Walter Saumweber
Visual C# 2017 – Grundlagen, Profiwissen und Rezepte
Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autoren und Verlag übernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht.
Ebenso übernehmen Autoren und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen und MarkenschutzGesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.
Bibliografische Information der Deutschen Nationalbibliothek: Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) – auch nicht für Zwecke der Unterrichtsgestaltung – reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden.
© 2018 Carl Hanser Verlag München
www.hanser-fachbuch.de
Lektorat: Sylvia Hasselbach
Copyediting: Petra Kienle, Fürstenfeldbruck
Umschlagdesign: Marc Müller-Bremer, München, www.rebranding.de
Umschlagrealisation: Stephan Rönigk
Print-ISBN 978-3-446-45359-3
E-Book-ISBN 978-3-446-45370-8
Verwendete Schriften: SourceSansPro und SourceCodePro (Lizenz)
CSS-Version: 1.0
| Font License | Zurück zum Impressum |
Copyright 2010, 2012, 2014 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
| Vorwort |
C# ist die momentan von Microsoft propagierte Sprache, sie bietet die Möglichkeiten und Flexibilität von C++ und erlaubt trotzdem eine schnelle und unkomplizierte Programmierpraxis wie einst bei Visual Basic. C# ist (fast) genauso mächtig wie C++, wurde aber komplett neu auf objektorientierter Basis geschrieben.
Damit ist C# das ideale Werkzeug zum Programmieren beliebiger Komponenten für das Microsoft .NET Framework, beginnend bei Windows Forms- über WPF-, ASP.NET-, und mobilen-Anwendungen (mittlerweile auch für Android und iOS) bis hin zu systemnahen Applikationen.
Das vorliegende Buch ist ein Angebot für künftige wie auch für fortgeschrittene C#-Programmierer. Seine Philosophie knüpft an die vielen anderen Titel an, die in dieser Reihe in den vergangenen zwanzig Jahren zu verschiedenen Programmiersprachen erschienen sind:
Programmieren lernt man nicht durch lineares Durcharbeiten eines Lehrbuchs, sondern nur durch unermüdliches Ausprobieren von Beispielen, verbunden mit ständigem Nachschlagen in der Referenz.
Der Umfang einer modernen Sprache wie C# in Verbindung mit Visual Studio ist so gewaltig, dass ein seriöses Programmierbuch das Prinzip der Vollständigkeit aufgeben muss und nach dem Prinzip „so viel wie nötig“ sich lediglich eine „Initialisierungsfunktion“ auf die Fahnen schreiben kann.
Gegenüber anderen Büchern zur gleichen oder ähnlichen Thematik nimmt unser Titel für sich in Anspruch, gleichzeitig Lehr- und Übungsbuch zu sein.
Zum Buchinhalt
Wie Sie bereits dem Buchtitel entnehmen können, wagt das vorliegende Werk den Spagat zwischen einem Grundlagen- und einem Profibuch. Sinn eines solchen Buches kann es nicht sein, eine umfassende Schritt-für-Schritt-Einführung in Visual C# 2017 zu liefern oder all die Informationen noch einmal zur Verfügung zu stellen, die Sie in der Produktdokumentation (MSDN) ohnehin schon finden und von denen Sie in der Regel nur ein Mausklick oder die F1-Taste trennt.
Für den Einsteiger wollen wir den einzig vernünftigen und gangbaren Weg beschreiten, nämlich nach dem Prinzip „so viel wie nötig“ eine schmale Schneise durch den Urwald der .NET-Programmierung mit Visual C# 2017 schlagen, bis er eine Lichtung erreicht hat, die ihm erste Erfolgserlebnisse vermittelt.
Für den Profi wollen wir in diesem Buch eine Vielzahl von Informationen und Know-how bereitstellen, wonach er bisher in den mitgelieferten Dokumentationen, im Internet bzw. in anderen Büchern vergeblich gesucht hat.
Die Kapitel des Buchs und die Bonuskapitel haben wir in vier Themenkomplexen gruppiert:
Grundlagen der Programmierung mit C# (Buch)
Technologien (Buch)
Windows Forms-Anwendungen (online)
WPF-Anwendungen (online)
Die Kapitel innerhalb eines Teils bilden einerseits eine logische Aufeinanderfolge, können andererseits aber auch quergelesen werden. Im Praxisteil eines jeden Kapitels werden anhand realer Problemstellungen die behandelten Programmiertechniken im Zusammenhang demonstriert.
Zu den Codebeispielen
Um den Einstieg in C# so einfach wie möglich zu gestalten, haben wir uns entschlossen die Beispiele mit WindowsForms zu erstellen.
Alle Beispieldaten dieses Buchs und die Bonuskapitel können Sie sich unter der folgenden Adresse herunterladen:
downloads.hanser.de
Beim Nachvollziehen der Buchbeispiele beachten Sie bitte Folgendes:
Kopieren Sie die Buchbeispiele auf die Festplatte. Wenn Sie auf die Projektmappendatei (*.sln) klicken, wird Visual Studio in der Regel automatisch geöffnet und das jeweilige Beispiel wird in die Entwicklungsumgebung geladen, wo Sie es z. B. mittels F5-Taste kompilieren und starten können.
Einige wenige Datenbankprojekte verwenden absolute Pfadnamen, die Sie vor dem Kompilieren des Beispiels erst noch anpassen müssen.
Für einige Beispiele sind ein installierter Microsoft SQL Server Express LocalDB erforderlich.
Beachten Sie die zu einigen Beispielen beigefügten Liesmich.txt-Dateien, die Sie auf besondere Probleme hinweisen.
Nobody is perfect
Sie werden in diesem Buch nicht alles finden, was Visual C# 2017 bzw. das .NET Framework 4.7 zu bieten haben. Manches ist sicher in einem anderen Spezialtitel noch besser oder ausführlicher beschrieben. Aber Sie halten mit unserem Buch einen überschaubaren Breitband-Mix in den Händen, der sowohl vertikal vom Einsteiger bis zum Profi als auch horizontal von den einfachen Sprachelementen bis hin zu komplexen Anwendungen jedem etwas bietet, ohne dabei den Blick auf das Wesentliche im .NET-Dschungel zu verlieren.
Wenn Sie Vorschläge oder Fragen zum Buch haben, können Sie uns gern unter
juergen.kotz@primetime-software.de
kontaktieren.
Wir hoffen, dass wir Ihnen mit diesem Buch einen nützlichen Begleiter bei der .NET-Programmierung zur Seite gestellt haben, der es verdient, seinen Platz nicht im Regal, sondern griffbereit neben dem Computer einzunehmen.
|
Jürgen Kotz, Walter Saumweber, Walter Doberenz und Thomas Gewinnus |
|
München, im Dezember 2017 |
| TEIL I: Grundlagen |
Einstieg in Visual Studio 2017
Grundlagen der Sprache C#
Objektorientiertes Programmieren
Arrays, Strings und Funktionen
Weitere wichtige Sprachfeatures
Einführung in LINQ
| 1 | Einstieg in Visual Studio 2017 |