Jürgen Kotz
Christian Wenz
C# und .NET 6
Grundlagen, Profiwissen und Rezepte
Ihr Plus – digitale Zusatzinhalte!
Auf unserem Download-Portal finden Sie zu diesem Titel kostenloses Zusatzmaterial.
Geben Sie auf plus.hanser-fachbuch.de einfach diesen Code ein:
plus-43qr9-pKvN2
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.
© 2022 Carl Hanser Verlag München, www.hanser-fachbuch.de
Lektorat: Sylvia Hasselbach
Copy editing: Walter Saumweber, Ratingen
Umschlagdesign: Marc Müller-Bremer, München, www.rebranding.de
Umschlagrealisation: Max Kostopoulos
Titelmotiv: © thinkstockphotos.de/liuzishan
Gesamtherstellung: Kösel, Krugzell
Ausstattung patentrechtlich geschützt. Kösel FD 351, Patent-Nr. 0748702
Print-ISBN: 978-3-446-46930-3
E-Book-ISBN: 978-3-446-47349-2
E-Pub-ISBN: 978-3-446-47423-9
Update inside.
Mit unserem kostenlosen Update-Service
zum Buch erhalten Sie aktuelle Infos zu C# und dem .NET Framework.
Und so funktioniert es:
1. Registrieren Sie sich unter:
www.hanser-fachbuch.de/Csharp-update
2. Geben Sie diesen Code ein:
5UKz-TaNroZp-mR5n
Der Update-Service läuft bis März 2024.
Als registrierter Nutzer werden Sie in diesem Zeitraum persönlich per E-Mail informiert, sobald ein neues Buch-Update zum Download verfügbar ist.
Wenn Sie Fragen haben, wenden Sie sich gerne an:
Csharp-update@hanser.de
Titelei
Impressum
Inhalt
Vorwort
Zusatzmaterial online
Teil I: Grundlagen
1 .NET 6
1.1 Microsofts .NET-Technologie
1.1.1 Zur Geschichte von .NET
1.1.2 .NET-Features und Begriffe
1.2 .NET Core
1.2.1 Geschichte von .NET Core
1.2.2 LTS – Long Term Support und zukünftige Versionen
1.2.3 .NET Standard
1.3 Features von .NET 6
2 Einstieg in Visual Studio 2022
2.1 Die Installation von Visual Studio 2022
2.1.1 Überblick über die Produktpalette
2.1.2 Anforderungen an Hard- und Software
2.2 Unser allererstes C#-Programm
2.2.1 Vorbereitungen
2.2.2 Quellcode schreiben
2.2.3 Programm kompilieren und testen
2.2.4 Einige Erläuterungen zum Quellcode
2.2.5 Konsolenanwendungen sind out
2.3 Die Windows-Philosophie
2.3.1 Mensch-Rechner-Dialog
2.3.2 Objekt- und ereignisorientierte Programmierung
2.3.3 Programmieren mit Visual Studio 2022
2.4 Die Entwicklungsumgebung Visual Studio 2022
2.4.1 Neues Projekt
2.4.2 Die wichtigsten Fenster
2.4.3 Projektvorlagen in Visual Studio 2022 – Minimal APIs
2.5 Praxisbeispiele
2.5.1 Unsere erste Windows-Forms-Anwendung
2.5.2 Umrechnung Euro-Dollar
3 Grundlagen der Sprache C#
3.1 Grundbegriffe
3.1.1 Anweisungen
3.1.2 Bezeichner
3.1.3 Schlüsselwörter
3.1.4 Kommentare
3.2 Datentypen, Variablen und Konstanten
3.2.1 Fundamentale Typen
3.2.2 Wertetypen versus Verweistypen
3.2.3 Benennung von Variablen
3.2.4 Deklaration von Variablen
3.2.5 Typsuffixe
3.2.6 Zeichen und Zeichenketten
3.2.7 object-Datentyp
3.2.8 Konstanten deklarieren
3.2.9 Nullable Types
3.2.10 Typinferenz
3.2.11 Gültigkeitsbereiche und Sichtbarkeit
3.3 Konvertieren von Datentypen
3.3.1 Implizite und explizite Konvertierung
3.3.2 Welcher Datentyp passt zu welchem?
3.3.3 Konvertieren von string
3.3.4 Die Convert-Klasse
3.3.5 Die Parse-Methode
3.3.6 Boxing und Unboxing
3.4 Operatoren
3.4.1 Arithmetische Operatoren
3.4.2 Zuweisungsoperatoren
3.4.3 Logische Operatoren
3.4.4 Rangfolge der Operatoren
3.5 Kontrollstrukturen
3.5.1 Verzweigungsbefehle
3.5.2 Schleifenanweisungen
3.6 Benutzerdefinierte Datentypen
3.6.1 Enumerationen
3.6.2 Strukturen
3.7 Nutzerdefinierte Methoden
3.7.1 Methoden mit Rückgabewert
3.7.2 Methoden ohne Rückgabewert
3.7.3 Parameterübergabe mit ref
3.7.4 Parameterübergabe mit out
3.7.5 Methodenüberladung
3.7.6 Optionale Parameter
3.7.7 Benannte Parameter
3.8 Praxisbeispiele
3.8.1 Vom PAP zur Konsolenanwendung
3.8.2 Ein Konsolen- in ein Windows-Programm verwandeln
3.8.3 Schleifenanweisungen verstehen
3.8.4 Benutzerdefinierte Methoden überladen
3.8.5 Anwendungen von Visual Basic nach C# portieren
4 OOP-Konzepte
4.1 Kleine Einführung in die OOP
4.1.1 Historische Entwicklung
4.1.2 Grundbegriffe der OOP
4.1.3 Sichtbarkeit von Klassen und ihren Mitgliedern
4.1.4 Allgemeiner Aufbau einer Klasse
4.1.5 Das Erzeugen eines Objekts
4.1.6 Einführungsbeispiel
4.2 Eigenschaften
4.2.1 Eigenschaften mit Zugriffsmethoden kapseln
4.2.2 Berechnete Eigenschaften
4.2.3 Lese-/Schreibschutz
4.2.4 Property-Accessoren
4.2.5 Statische Felder/Eigenschaften
4.2.6 Einfache Eigenschaften automatisch implementieren
4.3 Methoden
4.3.1 Öffentliche und private Methoden
4.3.2 Überladene Methoden
4.3.3 Statische Methoden
4.4 Ereignisse
4.4.1 Ereignis hinzufügen
4.4.2 Ereignis verwenden
4.5 Arbeiten mit Konstruktor und Destruktor
4.5.1 Konstruktor und Objektinitialisierer
4.5.2 Destruktor und Garbage Collector
4.5.3 Mit using den Lebenszyklus des Objekts kapseln
4.6 Vererbung und Polymorphie
4.6.1 Method-Overriding
4.6.2 Klassen implementieren
4.6.3 Implementieren der Objekte
4.6.4 Ausblenden von Mitgliedern durch Vererbung
4.6.5 Allgemeine Hinweise und Regeln zur Vererbung
4.6.6 Polymorphes Verhalten
4.6.7 Die Rolle von System.Object
4.7 Spezielle Klassen
4.7.1 Abstrakte Klassen
4.7.2 Versiegelte Klassen
4.7.3 Partielle Klassen
4.7.4 Statische Klassen
4.8 Schnittstellen (Interfaces)
4.8.1 Definition einer Schnittstelle
4.8.2 Implementieren einer Schnittstelle
4.8.3 Abfragen, ob Schnittstelle vorhanden ist
4.8.4 Mehrere Schnittstellen implementieren
4.8.5 Schnittstellenprogrammierung ist ein weites Feld
4.9 Datensatztypen – Records
4.9.1 Definition eines Record
4.9.2 Mutable Properties
4.9.3 Nicht-destruktive Änderung
4.9.4 Dekonstruktion
4.10 Praxisbeispiele
4.10.1 Eigenschaften sinnvoll kapseln
4.10.2 Eine statische Klasse anwenden
4.10.3 Vom fetten zum schlanken Client
4.10.4 Schnittstellenvererbung verstehen
4.10.5 Rechner für komplexe Zahlen
4.10.6 Sortieren mit IComparable/IComparer
4.10.7 Einen Objektbaum in generischen Listen abspeichern
4.10.8 OOP beim Kartenspiel erlernen
4.10.9 Eine Klasse zur Matrizenrechnung entwickeln
4.10.10 Vererbung von Records
5 Arrays, Strings, Funktionen
5.1 Datenfelder (Arrays)
5.1.1 Array deklarieren
5.1.2 Array instanziieren
5.1.3 Array initialisieren
5.1.4 Zugriff auf Array-Elemente
5.1.5 Zugriff mittels Schleife
5.1.6 Mehrdimensionale Arrays
5.1.7 Zuweisen von Arrays
5.1.8 Arrays aus Strukturvariablen
5.1.9 Löschen und Umdimensionieren von Arrays
5.1.10 Eigenschaften und Methoden von Arrays
5.1.11 Übergabe von Arrays
5.2 Verarbeiten von Zeichenketten
5.2.1 Zuweisen von Strings
5.2.2 Eigenschaften und Methoden von String-Variablen
5.2.3 Wichtige Methoden der String-Klasse
5.2.4 Die StringBuilder-Klasse
5.3 Datums- und Zeitberechnungen
5.3.1 Die DateTime-Struktur
5.3.2 Wichtige Eigenschaften von DateTime-Variablen
5.3.3 Wichtige Methoden von DateTime-Variablen
5.3.4 Wichtige Mitglieder der DateTime-Struktur
5.3.5 Konvertieren von Datumstrings in DateTime-Werte
5.3.6 Die TimeSpan-Struktur
5.3.7 DateOnly und TimeOnly
5.4 Mathematische Funktionen
5.4.1 Überblick
5.4.2 Zahlen runden
5.4.3 Winkel umrechnen
5.4.4 Potenz- und Wurzeloperationen
5.4.5 Logarithmus und Exponentialfunktionen
5.4.6 Zufallszahlen erzeugen
5.4.7 Kreisberechnung
5.5 Zahlen- und Datumsformatierungen
5.5.1 Anwenden der ToString-Methode
5.5.2 Anwenden der Format-Methode
5.5.3 Stringinterpolation
5.6 Praxisbeispiele
5.6.1 Zeichenketten verarbeiten
5.6.2 Zeichenketten mit StringBuilder addieren
5.6.3 Methodenaufrufe mit Array-Parametern
6 Weitere Sprachfeatures
6.1 Namespaces (Namensräume)
6.1.1 Ein kleiner Überblick
6.1.2 Einen eigenen Namespace einrichten
6.1.3 Die using-Anweisung
6.1.4 Namespace Alias
6.1.5 Globale using-Anweisungen
6.2 Operatorenüberladung
6.2.1 Syntaxregeln
6.2.2 Praktische Anwendung
6.3 Collections (Auflistungen)
6.3.1 Die Schnittstelle IEnumerable
6.3.2 ArrayList
6.3.3 Hashtable
6.3.4 Indexer
6.4 Generics
6.4.1 Generics bieten Typsicherheit
6.4.2 Generische Methoden
6.4.3 yield – Iteratoren
6.5 Generische Collections
6.5.1 List-Collection statt ArrayList
6.5.2 Vorteile generischer Collections
6.5.3 Constraints
6.6 Das Prinzip der Delegates
6.6.1 Delegates sind Methodenzeiger
6.6.2 Einen Delegate-Typ deklarieren
6.6.3 Ein Delegate-Objekt erzeugen
6.6.4 Anonyme Methoden
6.6.5 Lambda-Ausdrücke
6.6.6 Lambda-Ausdrücke in der Task Parallel Library
6.6.7 Action<> und Func<>
6.7 Dynamische Programmierung
6.7.1 Wozu dynamische Programmierung?
6.7.2 Das Prinzip der dynamischen Programmierung
6.7.3 Optionale Parameter sind hilfreich
6.7.4 Kovarianz und Kontravarianz
6.8 Weitere Datentypen
6.8.1 BigInteger
6.8.2 Complex
6.8.3 Tuple<>
6.8.4 SortedSet<>
6.9 Praxisbeispiele
6.9.1 ArrayList versus generische List
6.9.2 Generische IEnumerable-Interfaces implementieren
6.9.3 Delegates, Func, anonyme Methoden, Lambda Expressions
7 Einführung in LINQ
7.1 LINQ-Grundlagen
7.1.1 Die LINQ-Architektur
7.1.2 Anonyme Typen
7.1.3 Erweiterungsmethoden
7.2 Abfragen mit LINQ to Objects
7.2.1 Grundlegendes zur LINQ-Syntax
7.2.2 Zwei alternative Schreibweisen von LINQ-Abfragen
7.2.3 Übersicht der wichtigsten Abfrageoperatoren
7.3 LINQ-Abfragen im Detail
7.3.1 Die Projektionsoperatoren Select und SelectMany
7.3.2 Der Restriktionsoperator Where
7.3.3 Die Sortierungsoperatoren OrderBy und ThenBy
7.3.4 Der Gruppierungsoperator GroupBy
7.3.5 Verknüpfen mit Join
7.3.6 Aggregat-Operatoren
7.3.7 Verzögertes Ausführen von LINQ-Abfragen
7.3.8 Konvertierungsmethoden
7.3.9 Abfragen mit PLINQ
7.4 Praxisbeispiele
7.4.1 Die Syntax von LINQ-Abfragen verstehen
7.4.2 Aggregat-Abfragen mit LINQ
7.4.3 LINQ im Schnelldurchgang erlernen
7.4.4 Strings mit LINQ abfragen und filtern
7.4.5 Duplikate aus einer Liste entfernen
7.4.6 Arrays mit LINQ initialisieren
7.4.7 Arrays per LINQ mit Zufallszahlen füllen
7.4.8 Einen String mit Wiederholmuster erzeugen
7.4.9 Mit LINQ Zahlen und Strings sortieren
7.4.10 Mit LINQ Collections von Objekten sortieren
7.4.11 Where – Deep Dive
8 Neuerungen von C# im Überblick
8.1 C# 4.0 – Visual Studio 2010
8.1.1 Datentyp dynamic
8.1.2 Benannte und optionale Parameter
8.1.3 Kovarianz und Kontravarianz
8.2 C# 5.0 – Visual Studio 2012
8.2.1 Async und Await
8.2.2 CallerInfo
8.3 Visual Studio 2013
8.4 C# 6.0 – Visual Studio 2015
8.4.1 String Interpolation
8.4.2 Schreibgeschützte AutoProperties
8.4.3 Initialisierer für AutoProperties
8.4.4 Expression Body Member
8.4.5 using static
8.4.6 Bedingter Nulloperator
8.4.7 Ausnahmenfilter
8.4.8 nameof-Ausdrücke
8.4.9 await in catch und finally
8.4.10 Indexinitialisierer
8.5 C# 7.0 – Visual Studio 2017
8.5.1 out-Variablen
8.5.2 Tupel
8.5.3 Mustervergleich
8.5.4 Discards
8.5.5 Lokale ref-Variablen und Rückgabetypen
8.5.6 Lokale Funktionen
8.5.7 Mehr Expression Body Member
8.5.8 throw-Ausdrücke
8.5.9 Verbesserung der numerischen literalen Syntax
8.6 C# 7.1 bis 7.3 – Visual Studio 2019
8.6.1 C# 7.1
8.6.2 C# 7.2
8.6.3 C# 7.3
8.6.4 Visual Studio 2019 – Live Share
8.7 C# 8.0
8.7.1 Standardschnittstellenmethoden
8.7.2 Vereinfachung von switch-Ausdrücken
8.7.3 Eigenschaftenmuster
8.7.4 Vereinfachte using-Ressourcenschutzblöcke
8.7.5 Null-Coalescing-Zuweisungen
8.7.6 Nullable Referenztypen
8.7.7 Indizes und Bereiche
8.7.8 Weitere Sprachneuerungen
8.8 C# 9.0
8.8.1 Records
8.8.2 Init-only Setter
8.8.3 Weitere Verbesserungen in Musterausdrücken
8.8.4 Weitere Sprachneuerungen
8.9 C# 10
8.9.1 Datensatzstrukturen
8.9.2 Globale using-Anweisungen
8.9.3 Weitere Sprachneuerungen
Teil II: Desktop-Anwendungen
9 Einführung in WPF
9.1 Einführung
9.1.1 Was kann eine WPF-Anwendung?
9.1.2 Die eXtensible Application Markup Language
9.1.3 Unsere erste XAML-Anwendung
9.1.4 Zielplattformen
9.1.5 Applikationstypen
9.1.6 Vor- und Nachteile von WPF-Anwendungen
9.1.7 Weitere Dateien im Überblick
9.2 Alles beginnt mit dem Layout
9.2.1 Allgemeines zum Layout
9.2.2 Positionieren von Steuerelementen
9.2.3 Canvas
9.2.4 StackPanel
9.2.5 DockPanel
9.2.6 WrapPanel
9.2.7 UniformGrid
9.2.8 Grid
9.2.9 ViewBox
9.2.10 TextBlock
9.3 Das WPF-Programm
9.3.1 Die App-Klasse
9.3.2 Das Startobjekt festlegen
9.3.3 Kommandozeilenparameter verarbeiten
9.3.4 Die Anwendung beenden
9.3.5 Auswerten von Anwendungsereignissen
9.4 Die Window-Klasse
9.4.1 Position und Größe festlegen
9.4.2 Rahmen und Beschriftung
9.4.3 Das Fenster-Icon ändern
9.4.4 Anzeige weiterer Fenster
9.4.5 Transparenz
9.4.6 Abstand zum Inhalt festlegen
9.4.7 Fenster ohne Fokus anzeigen
9.4.8 Ereignisfolge bei Fenstern
9.4.9 Ein paar Worte zur Schriftdarstellung
9.4.10 Ein paar Worte zur Darstellung von Controls
9.4.11 Wird mein Fenster komplett mit WPF gerendert?
10 Übersicht WPF-Controls
10.1 Allgemeingültige Eigenschaften
10.2 Label
10.3 Button, RepeatButton, ToggleButton
10.3.1 Schaltflächen für modale Dialoge
10.3.2 Schaltflächen mit Grafik
10.4 TextBox, PasswordBox
10.4.1 TextBox
10.4.2 PasswordBox
10.5 CheckBox
10.6 RadioButton
10.7 ListBox, ComboBox
10.7.1 ListBox
10.7.2 ComboBox
10.7.3 Den Content formatieren
10.8 Image
10.8.1 Grafik per XAML zuweisen
10.8.2 Grafik zur Laufzeit zuweisen
10.8.3 Bild aus Datei laden
10.8.4 Die Grafikskalierung beeinflussen
10.9 Slider, ScrollBar
10.9.1 Slider
10.9.2 ScrollBar
10.10 ScrollViewer
10.11 Menu, ContextMenu
10.11.1 Menu
10.11.2 Tastenkürzel
10.11.3 Grafiken
10.11.4 Weitere Möglichkeiten
10.11.5 ContextMenu
10.12 ToolBar
10.13 StatusBar, ProgressBar
10.13.1 StatusBar
10.13.2 ProgressBar
10.14 Border, GroupBox, BulletDecorator
10.14.1 Border
10.14.2 GroupBox
10.14.3 BulletDecorator
10.15 Expander, TabControl
10.15.1 Expander
10.15.2 TabControl
10.16 Popup
10.17 TreeView
10.18 ListView
10.19 DataGrid
10.20 Calendar/DatePicker
10.21 Ellipse, Rectangle, Line und Co.
10.21.1 Ellipse
10.21.2 Rectangle
10.21.3 Line
11 Wichtige WPF-Techniken
11.1 Eigenschaften
11.1.1 Abhängige Eigenschaften (Dependency Properties)
11.1.2 Angehängte Eigenschaften (Attached Properties)
11.2 Einsatz von Ressourcen
11.2.1 Was sind eigentlich Ressourcen?
11.2.2 Wo können Ressourcen gespeichert werden?
11.2.3 Wie definiere ich eine Ressource?
11.2.4 Statische und dynamische Ressourcen
11.2.5 Wie werden Ressourcen adressiert?
11.2.6 Systemressourcen einbinden
11.3 Das WPF-Ereignismodell
11.3.1 Einführung
11.3.2 Routed Events
11.3.3 Direkte Events
11.4 Verwendung von Commands
11.4.1 Einführung zu Commands
11.4.2 Verwendung vordefinierter Commands
11.4.3 Das Ziel des Commands
11.4.4 Vordefinierte Commands
11.4.5 Commands an Ereignismethoden binden
11.4.6 Wie kann ich ein Command per Code auslösen?
11.4.7 Command-Ausführung verhindern
11.5 Das WPF-Style-System
11.5.1 Übersicht
11.5.2 Benannte Styles
11.5.3 Typ-Styles
11.5.4 Styles anpassen und vererben
11.6 Verwenden von Triggern
11.6.1 Eigenschaften-Trigger (Property Triggers)
11.6.2 Ereignis-Trigger
11.6.3 Daten-Trigger
11.7 Einsatz von Templates
11.7.1 Neues Template erstellen
11.7.2 Template abrufen und verändern
11.8 Transformationen, Animationen, StoryBoards
11.8.1 Transformationen
11.8.2 Animationen mit dem StoryBoard realisieren
Teil III: Technologien
12 WPF-Datenbindung
12.1 Grundprinzip
12.1.1 Bindungsarten
12.1.2 Wann eigentlich wird die Quelle aktualisiert?
12.1.3 Geht es auch etwas langsamer?
12.1.4 Bindung zur Laufzeit realisieren
12.2 Binden an Objekte
12.2.1 Objekte im XAML-Code instanziieren
12.2.2 Verwenden der Instanz im C#-Quellcode
12.2.3 Anforderungen an die Quell-Klasse
12.2.4 Instanziieren von Objekten per C#-Code
12.3 Binden von Collections
12.3.1 Anforderung an die Collection
12.3.2 Einfache Anzeige
12.3.3 Navigieren zwischen den Objekten
12.3.4 Einfache Anzeige in einer ListBox
12.3.5 DataTemplates zur Anzeigeformatierung
12.3.6 Mehr zu List- und ComboBox
12.3.7 Verwendung der ListView
12.4 Noch einmal zurück zu den Details
12.4.1 Navigieren in den Daten
12.4.2 Sortieren
12.4.3 Filtern
12.4.4 Live Shaping
12.5 Anzeige von Datenbankinhalten
12.5.1 Installieren der benötigten NuGet-Pakete
12.5.2 Anlegen der Entitätsklassen
12.5.3 Die Programmoberfläche
12.5.4 Der Zugriff auf die Daten
12.6 Formatieren von Werten
12.6.1 IValueConverter
12.6.2 BindingBase.StringFormat-Eigenschaft
12.7 Das DataGrid als Universalwerkzeug
12.7.1 Grundlagen der Anzeige
12.7.2 UI-Virtualisierung
12.7.3 Spalten selbst definieren
12.7.4 Zusatzinformationen in den Zeilen anzeigen
12.7.5 Vom Betrachten zum Editieren
12.8 Praxisbeispiel – Collections in Hintergrundthreads füllen
13 .NET MAUI
13.1 Einführung
13.2 Was kann eine .NET-MAUI-Anwendung?
13.3 Die erste .NET MAUI App
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 (Windows Forms)
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 Es geht auch einfacher – async und await
14.7.1 Der Weg von synchron zu asynchron
14.7.2 Achtung: Fehlerquellen!
14.7.3 Eigene asynchrone Methoden entwickeln
14.8 Asynchrone Streams
14.8.1 Datei erstellen
14.8.2 Datei lesen mit IAsyncEnumerable<T>
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
17 Entity Framework Core 6.0
17.1 Überblick
17.1.1 Objektrelationaler Mapper (ORM)
17.1.2 Provider
17.1.3 Relationale Beziehungen
17.1.4 Benötigte NuGet-Pakete
17.2 CodeFirst
17.2.1 CodeFirst aus Model
17.2.2 CodeFirst mittels ReverseEngineering von bestehender Datenbank
17.3 Migrationen
17.3.1 Initiale Migration bei ReverseEngineering
17.3.2 Weitere Migrationen
17.4 Lesen und Schreiben von Daten mit EF Core 6
17.5 Praxisbeispiele
17.5.1 Daten mit EF Core 6 laden und als JSON speichern
17.5.2 Eine Datenbank mit EF Core 6 anlegen und Testdaten generieren und anzeigen
Teil IV: Webanwendungen
18 Webanwendungen mit ASP.NET Core
18.1 Grundlagen
18.2 Razor Pages
18.2.1 Projektaufbau
18.2.2 Razor-Syntax
18.2.3 Layout-Vorlagen
18.2.4 Modelle für Razor Pages
18.2.5 Mit Formularen arbeiten
18.3 MVC
18.3.1 Projektaufbau
18.3.2 Action-Methoden
18.3.3 Zustandsmanagement
18.4 Praxisbeispiele
18.4.1 CRUD mit Entity Framework
18.4.2 Authentifizierung und Autorisierung
19 ASP.NET Web API
19.1 REST
19.2 Vorlagen
19.3 Daten lesen
19.4 Daten schreiben, aktualisieren, löschen
19.5 Minimale APIs
19.6 Praxisbeispiele
19.6.1 Paginierung
19.6.2 XML statt JSON
19.6.3 CORS
20 Blazor
20.1 Hosting-Modelle
20.2 Projektvorlagen
20.3 Blazor-Komponenten
20.3.1 Code in/für Komponenten
20.3.2 Event-Handling
20.3.3 Datenbindung
20.4 Services und APIs aufrufen
20.5 Weitere Blazor-Features
20.5.1 Zustandsmanagement
20.5.2 JavaScript-Interoperabilität
20.6 Praxisbeispiele
20.6.1 Online-Status ermitteln
20.6.2 File-Uploads
20.6.3 Fehlerbehandlung
Anhang A: Glossar
Anhang B: Wichtige Dateiendungen
| 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.
Mit .NET 6 hat Microsoft jetzt auch die neueste Version von .NET veröffentlicht, die endlich die bereits für .NET 5 geplante, aber aufgrund der Covid-Pandemie verschobene Vereinheitlichung One .NET sowie weitere neue Anwendungsarten (z. B. .NET MAUI, auch wenn das jetzt auf das 2. Quartal 2022 verschoben wurde) und weitere Verbesserungen, vor allem im Performancebereich, für die C#-Entwickler enthält.
Damit ist C# das ideale Werkzeug zum Programmieren beliebiger Komponenten für .NET, beginnend bei WPF-, ASP.NET- und mobilen Anwendungen (auch für Android und iOS) bis hin zu systemnahen Applikationen.
Das vorliegende Buch ist ein Angebot für angehende 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.
Dieses Buch wagt 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# 10.0 zu liefern oder all die Informationen noch einmal zur Verfügung zu stellen, die Sie in der Produktdokumentation ohnehin schon finden und von denen Sie in der Regel nur ein Mausklick oder die F 1-Taste trennt.
Für den Einsteiger möchten 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 C# schlagen, bis er eine Lichtung erreicht hat, die ihm erste Erfolgserlebnisse vermittelt.
Für den Profi möchten wir in diesem Buch eine Vielzahl von Informationen und Knowhow bereitstellen, wonach er bisher in den mitgelieferten Dokumentationen, im Internet bzw. in anderen Büchern vergeblich gesucht hat.
Die Kapitel des Buches sind in vier Themenkomplexe gruppiert; online gibt es noch umfangreiches Zusatzmaterial, das auch immer wieder ergänzt wird:
1. Grundlagen der Programmierung mit C# (Buch)
2. Desktop-Anwendungen (Buch)
3. Technologien (Buch)
4. Webtechnologien (Buch)
5. Windows-Forms-Anwendungen (online)
6. Zugriff auf das Dateisystem (online)
7. ADO.NET (online)
8. XML (online)
Die Kapitel innerhalb eines Teils bilden einerseits eine logische Abfolge, können andererseits aber auch quergelesen werden. Im Praxisteil eines jeden Kapitels werden anhand realer Problemstellungen die behandelten Programmiertechniken im Zusammenhang demonstriert.
Damit Sie möglichst lange mit diesem Buch arbeiten können, haben Sie die Möglichkeit, sich für den kostenlosen Update inside-Service zu registrieren: Geben Sie unter
www.hanser-fachbuch.de/Csharp-update
diesen Code ein:
5UKz-TaNroZp-mR5n
Dann erhalten Sie bis März 2024 Aktualisierungen in Form zusätzlicher Kapitel als PDF. Darin stellen wir Ihnen wichtige Neuerungen vor und gehen auf Änderungen ein, die die Inhalte dieses Buches betreffen.
Sie werden in diesem Buch nicht alles finden, was C# bzw. .NET 6 zu bieten haben. Manches ist sicher in einem anderen Spezialtitel 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 uns gerne kontaktieren:
juergen.kotz@primetime-software.de
info@christianwenz.de
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.
Ein Buch – gerade, wenn es so umfangreich ist – ist stets Teamarbeit. Herzlichen Dank an unsere Lektorin Sylvia Hasselbach, mit der wir seit über 20 Jahren zusammenarbeiten dürfen, sowie an Kristin Rothe und Irene Weilhart. Walter Saumweber hat als Fachlektor seit mehreren Auflagen den Röntgenblick für Ungenauigkeiten und Fehler (sollten wir trotzdem auf weitere Errata aufmerksam gemacht werden, veröffentlichen wir diese auf der Buchseite auf www.hanser-fachbuch.de und auf https://plus.hanser-fachbuch.de bei den Codebeispielen). Lenny Kotz hat uns bei einigen der Grafiken im Buch unterstützt.
Jürgen Kotz und Christian Wenz
München, im Januar 2022
Der Einfachheit halber werden im ersten Teil die Beispiele weiter mit Windows Forms oder als Konsolenanwendungen erstellt. Der zweite Teil des Buches behandelt dann ausführlich WPF sowie .NET MAUI und im dritten Teil „Technologien“ werden die Beispiele dann mit WPF dargestellt. Der vierte Teil ist dann der Webtechnologie vorbehalten. Alle Beispieldaten dieses Buches und die mittlerweile zahlreichen Bonuskapitel können Sie online herunterladen.
Geben Sie auf
https://plus.hanser-fachbuch.de
diesen Code ein:
plus-43qr9-pKvN2
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 der 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.
| Teil I: Grundlagen |
.NET 6 (Kapitel 1)
Einstieg in Visual Studio 2022 (Kapitel 2)
Grundlagen der Sprache C# (Kapitel 3)
OOP-Konzepte (Kapitel 4)
Arrays, Strings, Funktionen (Kapitel 5)
Weitere Sprachfeatures (Kapitel 6)
Einführung in LINQ (Kapitel 7)
Neuerungen von C# im Überblick (Kapitel 8)
| 1 | .NET 6 |