Erhalten Sie Zugang zu diesem und mehr als 300000 Büchern ab EUR 5,99 monatlich.
- Herausgeber: Carl Hanser Verlag GmbH & Co. KG
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Deutsch
- Veröffentlichungsjahr: 2019
Dieser komplett überarbeitete Klassiker der C#-/.NET-Programmierung bietet Ihnen Know-how und zahlreiche Rezepte, mit denen Sie häufig auftretende Probleme meistern. Einsteiger erhalten ein umfangreiches Tutorial zu den Grundlagen der C#-Programmierung mit Visual Studio 2019, dem Profi liefert es fortgeschrittene Programmiertechniken zu allen wesentlichen Einsatzgebieten der Windows-Programmierung. Zum sofortigen Ausprobieren finden Sie am Ende eines jeden Kapitels hochwertige Lösungen für nahezu jedes Problem.
Mit diesem Buch haben Sie den idealen Begleiter für Ihre tägliche Arbeit und zugleich – dank der erfrischenden und unterhaltsamen Sprache – eine spannende Lektüre, die Lust macht, auch Projekte in der Freizeit umzusetzen.
Das Buch gliedert sich in einen Grundlagenteil zur Programmierung mit Visual Studio 2019 und C# 8.0, eine Einführung in die Windows Presentation Foundation (WPF) sowie einen Technologieteil zu fortgeschrittenen Themen.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 911
Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:
Ähnliche
Jürgen Kotz
Visual C# 2019
Grundlagen, Profiwissen und Rezepte
Der Autor:
Jürgen Kotz, München
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. Autor 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 Autor 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 Markenschutz-Gesetzgebung 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.
© 2019 Carl Hanser Verlag München, www.hanser-fachbuch.deLektorat: Sylvia HasselbachCopy editing: Walter Saumweber, RatingenUmschlagdesign: Marc Müller-Bremer, München, www.rebranding.deUmschlagrealisation: Max KostopoulosTitelmotiv: © thinkstockphotos.de/liuzishanGesamtherstellung: Kösel, KrugzellAusstattung patentrechtlich geschützt. Kösel FD 351, Patent-Nr. 0748702
Print-ISBN: 978-3-446-45802-4E-Book-ISBN: 978-3-446-46099-7E-Pub-ISBN: 978-3-446-46253-3
Inhalt
Titelei
Impressum
Inhalt
Vorwort
Teil I: Grundlagen
1 Einstieg in Visual Studio 2019
1.1 Die Installation von Visual Studio 2019
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 2019
1.4 Die Entwicklungsumgebung Visual Studio 2019
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.6 Vererbung und Polymorphie
3.6.1 Method-Overriding
3.6.2 Klassen implementieren
3.6.3 Implementieren der Objekte
3.6.4 Ausblenden von Mitgliedern durch Vererbung
3.6.5 Allgemeine Hinweise und Regeln zur Vererbung
3.6.6 Polymorphes Verhalten
3.6.7 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.5.7 Kreisberechnung
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 Generics bieten Typsicherheit
5.4.2 Generische Methoden
5.4.3 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 Neuerungen von C# 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 Kovarianz und Kontravarianz
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
7.6 C# 7.1 bis 7.3 – Visual Studio 2019
7.6.1 C# 7.1
7.6.2 C# 7.2
7.6.3 C# 7.3
7.6.4 Visual Studio 2019 – Live Share
Teil II: WPF-Anwendungen
8 Einführung in WPF
8.1 Einführung
8.1.1 Was kann eine WPF-Anwendung?
8.1.2 Die eXtensible Application Markup Language
8.1.3 Verbinden von XAML und C#-Code
8.1.4 Zielplattformen
8.1.5 Applikationstypen
8.1.6 Vor- und Nachteile von WPF-Anwendungen
8.1.7 Weitere Dateien im Überblick
8.2 Alles beginnt mit dem Layout
8.2.1 Allgemeines zum Layout
8.2.2 Positionieren von Steuerelementen
8.2.3 Canvas
8.2.4 StackPanel
8.2.5 DockPanel
8.2.6 WrapPanel
8.2.7 UniformGrid
8.2.8 Grid
8.2.9 ViewBox
8.2.10 TextBlock
8.3 Das WPF-Programm
8.3.1 Die App-Klasse
8.3.2 Das Startobjekt festlegen
8.3.3 Kommandozeilenparameter verarbeiten
8.3.4 Die Anwendung beenden
8.3.5 Auswerten von Anwendungsereignissen
8.4 Die Window-Klasse
8.4.1 Position und Größe festlegen
8.4.2 Rahmen und Beschriftung
8.4.3 Das Fenster-Icon ändern
8.4.4 Anzeige weiterer Fenster
8.4.5 Transparenz
8.4.6 Abstand zum Inhalt festlegen
8.4.7 Fenster ohne Fokus anzeigen
8.4.8 Ereignisfolge bei Fenstern
8.4.9 Ein paar Worte zur Schriftdarstellung
8.4.10 Ein paar Worte zur Darstellung von Controls
8.4.11 Wird mein Fenster komplett mit WPF gerendert?
9 Übersicht WPF-Controls
9.1 Allgemeingültige Eigenschaften
9.2 Label
9.3 Button, RepeatButton, ToggleButton
9.3.1 Schaltflächen für modale Dialoge
9.3.2 Schaltflächen mit Grafik
9.4 TextBox, PasswordBox
9.4.1 TextBox
9.4.2 PasswordBox
9.5 CheckBox
9.6 RadioButton
9.7 ListBox, ComboBox
9.7.1 ListBox
9.7.2 ComboBox
9.7.3 Den Content formatieren
9.8 Image
9.8.1 Grafik per XAML zuweisen
9.8.2 Grafik zur Laufzeit zuweisen
9.8.3 Bild aus Datei laden
9.8.4 Die Grafikskalierung beeinflussen
9.9 MediaElement
9.10 Slider, ScrollBar
9.10.1 Slider
9.10.2 ScrollBar
9.11 ScrollViewer
9.12 Menu, ContextMenu
9.12.1 Menu
9.12.2 Tastenkürzel
9.12.3 Grafiken
9.12.4 Weitere Möglichkeiten
9.12.5 ContextMenu
9.13 ToolBar
9.14 StatusBar, ProgressBar
9.14.1 StatusBar
9.14.2 ProgressBar
9.15 Border, GroupBox, BulletDecorator
9.15.1 Border
9.15.2 GroupBox
9.15.3 BulletDecorator
9.16 RichTextBox
9.16.1 Verwendung und Anzeige von vordefiniertem Text
9.16.2 Neues Dokument zur Laufzeit erzeugen
9.16.3 Sichern von Dokumenten
9.16.4 Laden von Dokumenten
9.16.5 Texte per Code einfügen/modifizieren
9.16.6 Texte formatieren
9.16.7 EditingCommands
9.16.8 Grafiken/Objekte einfügen
9.16.9 Rechtschreibkontrolle
9.17 FlowDocumentPageViewer & Co.
9.17.1 FlowDocumentPageViewer
9.17.2 FlowDocumentReader
9.17.3 FlowDocumentScrollViewer
9.18 FlowDocument
9.18.1 FlowDocument per XAML beschreiben
9.18.2 FlowDocument per Code erstellen
9.19 Expander, TabControl
9.19.1 Expander
9.19.2 TabControl
9.20 Popup
9.21 TreeView
9.22 ListView
9.23 DataGrid
9.24 Calendar/DatePicker
9.25 Ellipse, Rectangle, Line und Co.
9.25.1 Ellipse
9.25.2 Rectangle
9.25.3 Line
10 Wichtige WPF-Techniken
10.1 Eigenschaften
10.1.1 Abhängige Eigenschaften (Dependency Properties)
10.1.2 Angehängte Eigenschaften (Attached Properties)
10.2 Einsatz von Ressourcen
10.2.1 Was sind eigentlich Ressourcen?
10.2.2 Wo können Ressourcen gespeichert werden?
10.2.3 Wie definiere ich eine Ressource?
10.2.4 Statische und dynamische Ressourcen
10.2.5 Wie werden Ressourcen adressiert?
10.2.6 Systemressourcen einbinden
10.3 Das WPF-Ereignismodell
10.3.1 Einführung
10.3.2 Routed Events
10.3.3 Direkte Events
10.4 Verwendung von Commands
10.4.1 Einführung zu Commands
10.4.2 Verwendung vordefinierter Commands
10.4.3 Das Ziel des Commands
10.4.4 Vordefinierte Commands
10.4.5 Commands an Ereignismethoden binden
10.4.6 Wie kann ich ein Command per Code auslösen?
10.4.7 Command-Ausführung verhindern
10.5 Das WPF-Style-System
10.5.1 Übersicht
10.5.2 Benannte Styles
10.5.3 Typ-Styles
10.5.4 Styles anpassen und vererben
10.6 Verwenden von Triggern
10.6.1 Eigenschaften-Trigger (Property Triggers)
10.6.2 Ereignis-Trigger
10.6.3 Daten-Trigger
10.7 Einsatz von Templates
10.7.1 Neues Template erstellen
10.7.2 Template abrufen und verändern
10.8 Transformationen, Animationen, StoryBoards
10.8.1 Transformationen
10.8.2 Animationen mit dem StoryBoard realisieren
11 WPF-Datenbindung
11.1 Grundprinzip
11.1.1 Bindungsarten
11.1.2 Wann eigentlich wird die Quelle aktualisiert?
11.1.3 Geht es auch etwas langsamer?
11.1.4 Bindung zur Laufzeit realisieren
11.2 Binden an Objekte
11.2.1 Objekte im XAML-Code instanziieren
11.2.2 Verwenden der Instanz im C#-Quellcode
11.2.3 Anforderungen an die Quell-Klasse
11.2.4 Instanziieren von Objekten per C#-Code
11.3 Binden von Collections
11.3.1 Anforderung an die Collection
11.3.2 Einfache Anzeige
11.3.3 Navigieren zwischen den Objekten
11.3.4 Einfache Anzeige in einer ListBox
11.3.5 DataTemplates zur Anzeigeformatierung
11.3.6 Mehr zu List- und ComboBox
11.3.7 Verwendung der ListView
11.4 Noch einmal zurück zu den Details
11.4.1 Navigieren in den Daten
11.4.2 Sortieren
11.4.3 Filtern
11.4.4 Live Shaping
11.5 Anzeige von Datenbankinhalten
11.5.1 Datenmodell per EF-Designer erzeugen
11.5.2 Die Programmoberfläche
11.5.3 Der Zugriff auf die Daten
11.6 Formatieren von Werten
11.6.1 IValueConverter
11.6.2 BindingBase.StringFormat-Eigenschaft
11.7 Das DataGrid als Universalwerkzeug
11.7.1 Grundlagen der Anzeige
11.7.2 UI-Virtualisierung
11.7.3 Spalten selbst definieren
11.7.4 Zusatzinformationen in den Zeilen anzeigen
11.7.5 Vom Betrachten zum Editieren
11.8 Praxisbeispiel – Collections in Hintergrundthreads füllen
Teil III: Technologien
12 Zugriff auf das Dateisystem
12.1 Grundlagen
12.1.1 Klassen für den Zugriff auf das Dateisystem
12.1.2 Statische versus Instanzen-Klasse
12.2 Übersichten
12.2.1 Methoden der Directory-Klasse
12.2.2 Methoden eines DirectoryInfo-Objekts
12.2.3 Eigenschaften eines DirectoryInfo-Objekts
12.2.4 Methoden der File-Klasse
12.2.5 Methoden eines FileInfo-Objekts
12.2.6 Eigenschaften eines FileInfo-Objekts
12.3 Operationen auf Verzeichnisebene
12.3.1 Existenz eines Verzeichnisses/einer Datei feststellen
12.3.2 Verzeichnisse erzeugen und löschen
12.3.3 Verzeichnisse verschieben und umbenennen
12.3.4 Aktuelles Verzeichnis bestimmen
12.3.5 Unterverzeichnisse ermitteln
12.3.6 Alle Laufwerke ermitteln
12.3.7 Dateien kopieren und verschieben
12.3.8 Dateien umbenennen
12.3.9 Dateiattribute feststellen
12.3.10 Verzeichnis einer Datei ermitteln
12.3.11 Alle im Verzeichnis enthaltenen Dateien ermitteln
12.3.12 Dateien und Unterverzeichnisse ermitteln
12.4 Weitere wichtige Klassen
12.4.1 Die Path-Klasse
12.4.2 Die Klasse FileSystemWatcher
12.4.3 Die Klasse ZipArchive
12.5 Datei- und Verzeichnisdialoge
12.5.1 OpenFileDialog
12.5.2 SaveFileDialog
12.6 Praxisbeispiele
12.6.1 Infos über Verzeichnisse und Dateien gewinnen
12.6.2 Eine Verzeichnisstruktur in die TreeView einlesen
13 Dateien lesen und schreiben
13.1 Grundprinzip der Datenpersistenz
13.1.1 Dateien und Streams
13.1.2 Die wichtigsten Klassen
13.1.3 Erzeugen eines Streams
13.2 Dateiparameter
13.2.1 FileAccess
13.2.2 FileMode
13.2.3 FileShare
13.3 Textdateien
13.3.1 Eine Textdatei beschreiben bzw. neu anlegen
13.3.2 Eine Textdatei lesen
13.4 Binärdateien
13.4.1 Lese-/Schreibzugriff
13.4.2 Die Methoden ReadAllBytes und WriteAllBytes
13.4.3 Erzeugen von BinaryReader/BinaryWriter
13.5 Sequenzielle Dateien
13.5.1 Lesen und Schreiben von strukturierten Daten
13.5.2 Serialisieren von Objekten
13.6 Dateien verschlüsseln
13.6.1 Das Methodenpärchen Encrypt/Decrypt
13.6.2 Verschlüsseln mit der CryptoStream-Klasse
13.7 Praxisbeispiele
13.7.1 Auf eine Textdatei zugreifen
13.7.2 Einen Objektbaum persistent speichern
13.7.3 Eine Datei verschlüsseln
13.7.4 PDFs erstellen/exportieren
13.7.5 Eine CSV-Datei erstellen
13.7.6 Eine CSV-Datei mit LINQ lesen und auswerten
13.7.7 Einen korrekten Dateinamen erzeugen
14 Asynchrone Programmierung
14.1 Übersicht
14.1.1 Multitasking versus Multithreading
14.1.2 Deadlocks
14.1.3 Racing
14.2 Programmieren mit Threads
14.2.1 Einführungsbeispiel
14.2.2 Wichtige Thread-Methoden
14.2.3 Wichtige Thread-Eigenschaften
14.2.4 Einsatz der ThreadPool-Klasse
14.3 Sperrmechanismen
14.3.1 Threading ohne lock
14.3.2 Threading mit lock
14.3.3 Die Monitor-Klasse
14.3.4 Mutex
14.3.5 Methoden für die parallele Ausführung sperren
14.3.6 Semaphore
14.4 Interaktion mit der Programmoberfläche
14.4.1 Die Werkzeuge
14.4.2 Einzelne Steuerelemente mit Invoke aktualisieren
14.4.3 Mehrere Steuerelemente aktualisieren
14.4.4 Ist ein Invoke-Aufruf nötig?
14.4.5 Und was ist mit WPF?
14.5 Timer-Threads
14.6 Asynchrone Programmierentwurfsmuster
14.6.1 Kurzübersicht
14.6.2 Polling
14.6.3 Callback verwenden
14.6.4 Callback mit Parameterübergabe verwenden
14.6.5 Callback mit Zugriff auf die Programmoberfläche
14.7 Asynchroner Aufruf beliebiger Methoden
14.7.1 Die Beispielklasse
14.7.2 Asynchroner Aufruf ohne Callback
14.7.3 Asynchroner Aufruf mit Callback und Anzeigefunktion
14.7.4 Aufruf mit Rückgabewerten (per Eigenschaft)
14.7.5 Aufruf mit Rückgabewerten (per EndInvoke)
14.8 Es geht auch einfacher – async und await
14.8.1 Der Weg von synchron zu asynchron
14.8.2 Achtung: Fehlerquellen!
14.8.3 Eigene asynchrone Methoden entwickeln
14.9 Praxisbeispiele
14.9.1 Prozess- und Thread-Informationen gewinnen
14.9.2 Ein externes Programm starten
15 Die Task Parallel Library
15.1 Überblick
15.1.1 Parallel-Programmierung
15.1.2 Möglichkeiten der TPL
15.1.3 Der CLR-Threadpool
15.2 Parallele Verarbeitung mit Parallel.Invoke
15.2.1 Aufrufvarianten
15.2.2 Einschränkungen
15.3 Verwendung von Parallel.For
15.3.1 Abbrechen der Verarbeitung
15.3.2 Auswerten des Verarbeitungsstatus
15.3.3 Und was ist mit anderen Iterator-Schrittweiten?
15.4 Collections mit Parallel.ForEach verarbeiten
15.5 Die Task-Klasse
15.5.1 Einen Task erzeugen
15.5.2 Den Task starten
15.5.3 Datenübergabe an den Task
15.5.4 Wie warte ich auf das Ende des Tasks?
15.5.5 Tasks mit Rückgabewerten
15.5.6 Die Verarbeitung abbrechen
15.5.7 Fehlerbehandlung
15.5.8 Weitere Eigenschaften
15.6 Zugriff auf das User Interface
15.6.1 Task-Ende und Zugriff auf die Oberfläche
15.6.2 Zugriff auf das UI aus dem Task heraus
15.7 Weitere Datenstrukturen im Überblick
15.7.1 Threadsichere Collections
15.7.2 Primitive für die Threadsynchronisation
15.8 Parallel LINQ (PLINQ)
15.9 Praxisbeispiele
15.9.1 BlockingCollection
15.9.2 PLINQ
16 Debugging, Fehlersuche und Fehlerbehandlung
16.1 Der Debugger
16.1.1 Allgemeine Beschreibung
16.1.2 Die wichtigsten Fenster
16.1.3 Debugging-Optionen
16.1.4 Praktisches Debugging am Beispiel
16.2 Arbeiten mit Debug und Trace
16.2.1 Wichtige Methoden von Debug und Trace
16.2.2 Besonderheiten der Trace-Klasse
16.2.3 TraceListener-Objekte
16.3 Caller Information
16.3.1 Attribute
16.3.2 Anwendung
16.4 Fehlerbehandlung
16.4.1 Anweisungen zur Fehlerbehandlung
16.4.2 try-catch
16.4.3 try-finally
16.4.4 Das Standardverhalten bei Ausnahmen festlegen
16.4.5 Die Exception-Klasse
16.4.6 Fehler/Ausnahmen auslösen
16.4.7 Eigene Fehlerklassen
16.4.8 Exceptionhandling zur Debugzeit
16.4.9 Code Contracts
17 JSON und XML in Theorie und Praxis
17.1 JSON – JavaScriptObjectNotation
17.1.1 Grundlagen
17.1.2 De-/Serialisierung mit JSON
17.2 XML – etwas Theorie
17.2.1 Übersicht
17.2.2 Der XML-Grundaufbau
17.2.3 Wohlgeformte Dokumente
17.2.4 Processing Instructions (PI)
17.2.5 Elemente und Attribute
17.3 XSD-Schemas
17.3.1 XML-Schemas in Visual Studio analysieren
17.3.2 XML-Datei mit XSD-Schema erzeugen
17.3.3 XSD-Schema aus einer XML-Datei erzeugen
17.4 Verwendung des DOM unter .NET
17.4.1 Übersicht
17.4.2 DOM-Integration in C#
17.4.3 Laden von Dokumenten
17.4.4 Erzeugen von XML-Dokumenten
17.4.5 Auslesen von XML-Dateien
17.4.6 Direktzugriff auf einzelne Elemente
17.4.7 Einfügen von Informationen
17.4.8 Suchen in den Baumzweigen
17.5 XML-Verarbeitung mit LINQ to XML
17.5.1 Die LINQ to XML-API
17.5.2 Neue XML-Dokumente erzeugen
17.5.3 Laden und Sichern von XML-Dokumenten
17.5.4 Navigieren in XML-Daten
17.5.5 Auswählen und Filtern
17.5.6 Manipulieren der XML-Daten
17.5.7 XML-Dokumente transformieren
17.6 Weitere Möglichkeiten der XML-Verarbeitung
17.6.1 Schnelles Suchen in XML-Daten mit XPathNavigator
17.6.2 Schnelles Auslesen von XML-Daten mit XmlReader
17.6.3 Erzeugen von XML-Daten mit XmlWriter
17.6.4 XML transformieren mit XSLT
17.7 Praxisbeispiele
17.7.1 Mit dem DOM in XML-Dokumenten navigieren
17.7.2 XML-Daten in eine TreeView einlesen
17.7.3 In Dokumenten mit dem XPathNavigator navigieren
18 Einführung in ADO.NET und Entity Framework
18.1 Eine kleine Übersicht
18.1.1 Die ADO.NET-Klassenhierarchie
18.1.2 Die Klassen der Datenprovider
18.1.3 Das Zusammenspiel der ADO.NET-Klassen
18.2 Das Connection-Objekt
18.2.1 Allgemeiner Aufbau
18.2.2 SqlConnection
18.2.3 Schließen einer Verbindung
18.2.4 Eigenschaften des Connection-Objekts
18.2.5 Methoden des Connection-Objekts
18.2.6 Der ConnectionStringBuilder
18.2.7 ConnectionString in der Konfigurationsdatei
18.3 Das Command-Objekt
18.3.1 Erzeugen und Anwenden eines Command-Objekts
18.3.2 Erzeugen mittels CreateCommand-Methode
18.3.3 Eigenschaften des Command-Objekts
18.3.4 Methoden des Command-Objekts
18.3.5 Freigabe von Connection- und Command-Objekten
18.4 Parameter-Objekte
18.4.1 Erzeugen und Anwenden eines Parameter-Objekts
18.4.2 Eigenschaften des Parameter-Objekts
18.5 Das CommandBuilder-Objekt
18.5.1 Erzeugen
18.5.2 Anwenden
18.6 Das DataReader-Objekt
18.6.1 DataReader erzeugen
18.6.2 Daten lesen
18.6.3 Eigenschaften des DataReaders
18.6.4 Methoden des DataReaders
18.7 Das DataAdapter-Objekt
18.7.1 DataAdapter erzeugen
18.7.2 Command-Eigenschaften
18.7.3 Fill-Methode
18.7.4 Update-Methode
18.7.5 DataSet
18.8 Entity Framework
18.8.1 Überblick
18.8.2 CodeFirst
18.8.3 CodeFirst aus Datenbank
18.9 Praxisbeispiele
18.9.1 Wichtige ADO.NET-Objekte im Einsatz
18.9.2 Eine Aktionsabfrage ausführen
18.9.3 Eine StoredProcedure aufrufen
18.9.4 Daten mit Entity Framework laden und als JSON speichern
19 Weitere Techniken
19.1 Zugriff auf die Zwischenablage
19.1.1 Das Clipboard-Objekt
19.1.2 Zwischenablage-Funktionen für Textboxen
19.2 .NET-Reflection
19.2.1 Übersicht
19.2.2 Assembly laden
19.2.3 Mittels GetType und Type Informationen sammeln
19.2.4 Dynamisches Laden von Assemblies
19.3 Praxisbeispiele
19.3.1 Nutzer und Gruppen des aktuellen Systems ermitteln
19.3.2 Testen, ob Nutzer in einer Gruppe enthalten ist
19.3.3 Die IP-Adressen des Computers ermitteln
19.3.4 Diverse Systeminformationen ermitteln
Anhang A: Glossar
Anhang B: Wichtige Dateiextensions
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 dieses Buch 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 C# 7.3 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 möchte ich 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 C# schlagen, bis er eine Lichtung erreicht hat, die ihm erste Erfolgserlebnisse vermittelt.
Für den Profi möchte ich 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 Buches und die Onlinekapitel sind in fünf Themenkomplexe gruppiert:
1. Grundlagen der Programmierung mit C# (Buch)
2. WPF-Anwendungen (Buch)
3. Technologien (Buch)
4. Windows Forms-Anwendungen (online)
5. Bonuskapitel (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
Auf vielfachen Wunsch habe ich mich dazu entschlossen, ab dieser Auflage des Buches die Beispiele auch mit WPF zu erstellen. Der Einfachheit halber werden im ersten Teil die Beispiele weiter mit Windows Forms erstellt. Der zweite Teil des Buches behandelt dann ausführlich WPF und im dritten Teil „Technologien“ werden die Beispiele dann mit WPF dargestellt. Alle Beispieldaten dieses Buches und das Bonuskapitel zu Windows Forms können Sie unter der folgenden Adresse herunterladen:
www.hanser-fachbuch.de
Geben Sie bitte im Suchfeld „Visual C# 2019“ ein und klicken Sie auf der Buchdetailseite auf die Registerkarte Extras.
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.
Für einige Beispiele ist ein installierter Microsoft SQL Server Express LocalDB oder jegliche andere Instanz eines SQL-Servers 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 C# bzw. das .NET Framework 4.7.2 zu bieten haben. Manches ist sicher in einem anderen Spezialtitel noch besser oder ausführlicher beschrieben. Aber Sie halten mit diesem 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 mich gerne kontaktieren:
Ich hoffe, dass ich Ihnen mit diesem Buch einen nützlichen Begleiter bei der .NET-Programmierung zur Seite gestellt habe, der es verdient, seinen Platz nicht im Regal, sondern griffbereit neben dem Computer einzunehmen.
Jürgen Kotz
München, im Sommer 2019
Einstieg in Visual Studio 2019 (Kapitel 1)
Grundlagen der Sprache C# (Kapitel 2)
Objektorientiertes Programmieren (Kapitel 3)
Arrays, Strings und Funktionen (Kapitel 4)
Weitere wichtige Sprachfeatures (Kapitel 5)
Einführung in LINQ (Kapitel 6)
Neuerungen von C# im Überblick (Kapitel 7)
