Bild: C# und .NET 8 - Grundlagen, Profiwissen und Rezepte - Hanser

C# und .NET 8 - Grundlagen, Profiwissen und Rezepte

Jürgen Kotz Christian Wenz(Autor*in)

Hanser (Verlag)

1. Auflage

Erschienen am 6. Mai 2024

1080 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-446-48060-5 (ISBN)

49,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Wasserzeichen-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.

Alles über E-Books, Kopierschutz & Dateiformate finden Sie in unserem Info- & Hilfebereich.

- Für Einsteiger, Fortgeschrittene und Profis - Windows(WPF und .NET MAUI)- und Web-Programmierung (ASP.NET Core, Blazor und Co.) - Datenbankprogrammierung mit Entity Framework Core 8 - Online: Bonuskapitel u. a. zur GUI-Entwicklung mit Windows Forms sowie alle Beispiele aus dem Buch unter http://plus.hanser-fachbuch.de - Ihr exklusiver Vorteil: E-Book inside beim Kauf des gedruckten Buches Dieser überarbeitete Klassiker der C#-/.NETProgrammierung 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# 12-Programmierung mit Visual Studio 2022, dem Profi liefert es fortgeschrittene Programmiertechniken zu allen wesentlichen Einsatzgebieten der Programmierung mit .NET 8. Zum sofortigen Ausprobieren finden Sie am Ende eines jeden Kapitels hochwertige Lösungen für nahezu jedes Problem. Das Buch gliedert sich in einen Grundlagenteil zur Programmierung, eine Einführung in die Desktop-Programmierung mit WPF und .NET MAUI(Multi-Platform App UI), einen Technologieteil zu fortgeschrittenen Themen sowie einen Teil zur Web-Programmierung (ASP.NET Core, Web API, Blazor). Es ist der ideale Begleiter für Ihre tägliche Arbeit und zugleich eine unterhaltsame Lektüre, die Lust macht, Projekte auch in der Freizeit umzusetzen. AUS DEM INHALT // - Grundlagen der Sprache - OOP-Konzepte - Arrays, Strings, Funktionen - Einführung in LINQ - Neuerungen in C# - Einführung in WPF - WPF Controls, WPF-Datenbindung - Einführung in .NET MAUI - Asynchrone Programmierung & Task Parallel Library - Debugging, Fehlersuche und -behandlung - Entity Framework Core 8 und JSON-Serialisierung - Webanwendungen und APIs mit ASP.NET Core - Single-Page Applications (SPAs) mit Blazor

Weitere Details

Weitere Ausgaben

Personen

Inhalt

Intro
Inhalt
Vorwort
Zusatzmaterial online
Teil I: Grundlagen
1 .NET 8
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
1.4 Features von .NET 7
1.5 Features von .NET 8
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
2.6 Neuerungen in Visual Studio 2022 Version 17.8
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
8.10 C# 11
8.10.1 Raw String Literals
8.10.2 Generische Mathematik
8.10.3 Generische Attribute
8.10.4 Listenmuster
8.10.5 Lokale Dateitypen
8.10.6 Required Member
8.10.7 Automatische Standardstrukturen
8.11 C# 12
8.11.1 Primäre Konstruktoren auch für Klassen und Strukturen
8.11.2 Sammlungsausdrücke
8.11.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
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
13.4 Definieren einer eigenen View
13.5 Daten in MAUI anzeigen
13.6 Styles in MAUI
13.6.1 Styles
13.6.2 Themes
13.7 Navigation unter MAUI
Teil III: Technologien
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
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
17.5 Neuerungen in Entity Framework Core 7 und 8
17.5.1 JSON-Spalten
17.5.2 Bulk Updates
17.5.3 SaveChanges()
17.5.4 Mapping von Stored Procedures
17.5.5 Optimiertes SQL für Contains-Abfragen
17.5.6 Enums werden innerhalb von JSON-Spalten als ints gespeichert
17.5.7 Primitive Collections
17.6 Serialisierung mit System.Text.Json
17.7 Praxisbeispiele
17.7.1 Daten mit EF Core laden und als JSON speichern
17.7.2 Eine Datenbank mit EF Core 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
18.4.3 Zugriffsbeschränkung
19 Web APIs mit ASP.NET Core
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.5.3 Render-Modi und Streaming
20.6 Praxisbeispiele
20.6.1 Online-Status ermitteln
20.6.2 File-Uploads
20.6.3 Fehlerbehandlung
20.6.4 Datengrid
Anhang A: Glossar
Anhang B: Wichtige Dateiendungen
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken