C# 8.0 programmieren

C# 8.0 programmieren

by Ian Griffiths
Released September 2024
Publisher(s): O'Reilly Media, Inc.
ISBN: 9781098196639

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com

C# ist unbestreitbar eine der vielseitigsten Programmiersprachen, die Ingenieuren heute zur Verfügung stehen. In diesem umfassenden Handbuch erfährst du, wie leistungsfähig die Kombination aus C# und .NET sein kann. Der Autor Ian Griffiths führt dich durch die Grundlagen und Techniken von C# 8.0, um Cloud-, Web- und Desktop-Anwendungen zu erstellen.

Dieses Buch richtet sich an erfahrene Programmierer/innen und enthält viele Codebeispiele, die dir helfen, mit den Grundlagen von C# zu arbeiten, z. B. Generics, LINQ und asynchrone Programmierfunktionen. Du lernst .NET Core und die neuesten Erweiterungen von C# 8.0 kennen, darunter asynchrone Streams, löschbare Referenzen, Pattern Matching, die Implementierung von Standardschnittstellen, Bereiche und die neue Indexierungssyntax sowie Änderungen in der .NET-Toolkette.

  • Entdecke, wie C# grundlegende Programmierfunktionen wie Klassen, andere benutzerdefinierte Typen, Sammlungen und Fehlerbehandlung unterstützt.
  • Lerne, wie du mit den Span- und Memory-Typen von .NET Core leistungsstarken und speichereffizienten Code schreibst
  • Abfragen und Verarbeiten verschiedener Datenquellen, wie In-Memory-Objektmodelle, Datenbanken, Datenströme und XML-Dokumente mit LINQ
  • Nutze die Multithreading-Funktionen von .NET, um die parallelen Verarbeitungsmöglichkeiten deines Computers auszunutzen
  • Lerne, wie asynchrone Sprachfunktionen die Reaktionsfähigkeit und Skalierbarkeit von Anwendungen verbessern können

Table of contents

  1. Vorwort
    1. Für wen dieses Buch ist
    2. In diesem Buch verwendete Konventionen
    3. Code-Beispiele verwenden
    4. O'Reilly Online Learning
    5. Wie du uns kontaktierst
    6. Danksagungen
  2. 1. Einführung in C#
    1. Warum C#?
    2. Definierende Merkmale von C#
      1. Verwalteter Code und die CLR
      2. Ziehe Allgemeinheit der Spezialisierung vor
    3. C# Standards und Implementierungen
      1. Viele Microsoft .NETs (vorübergehend)
      2. Mehrere .NET-Versionen mit .NET Standard anvisieren
    4. Visual Studio und Visual Studio Code
    5. Anatomie eines einfachen Programms
      1. Hinzufügen eines Projekts zu einer bestehenden Lösung
      2. Ein Projekt in einem anderen referenzieren
      3. Externe Bibliotheken referenzieren
      4. Einen Einheitstest schreiben
      5. Namensräume
      6. Klassen
      7. Programm Einstiegspunkt
      8. Einheitstests
    6. Zusammenfassung
  3. 2. Grundlegende Codierung in C#
    1. Lokale Variablen
      1. Umfang
    2. Aussagen und Ausdrücke
      1. Aussagen
      2. Ausdrücke
    3. Kommentare und Leerraum
    4. Vorverarbeitungsrichtlinien
      1. Kompilierungssymbole
      2. #Fehler und #Warnung
      3. #Linie
      4. #pragma
      5. #nullable
      6. #region und #endregion
    5. Grundlegende Datentypen
      1. Numerische Typen
      2. Booleans
      3. Zeichenketten und Zeichen
      4. Tupel
      5. Dynamisch
      6. Objekt
    6. Betreiber
    7. Flusskontrolle
      1. Boolesche Entscheidungen mit if-Anweisungen
      2. Multiple Choice mit Switch Statements
      3. Schleifen: while und do
      4. C-Stil für Schleifen
      5. Iteration der Sammlung mit foreach-Schleifen
    8. Muster
      1. Genauer werden mit wann
      2. Muster in Ausdrücken
    9. Zusammenfassung
  4. 3. Typen
    1. Klassen
      1. Statische Mitglieder
      2. Statische Klassen
      3. Referenztypen
    2. Strukturen
      1. Wann man einen Werttyp schreibt
      2. Gewährleistung der Unveränderlichkeit
    3. Mitglieder
      1. Felder
      2. Konstrukteure
      3. Dekonstrukteure
      4. Methoden
      5. Eigenschaften
      6. Indexers
      7. Initialisierungssyntax
      8. Betreiber
      9. Veranstaltungen
      10. Verschachtelte Typen
    4. Schnittstellen
      1. Standard Implementierung der Schnittstelle
    5. Enums
    6. Andere Typen
      1. Anonyme Typen
    7. Partielle Typen und Methoden
    8. Zusammenfassung
  5. 4. Generika
    1. Generische Typen
    2. Zwänge
      1. Typ Beschränkungen
      2. Referenztyp-Einschränkungen
      3. Werttyp-Einschränkungen
      4. Werttypen bis ganz nach unten mit nicht verwalteten Beschränkungen
      5. Nicht-Null-Beschränkungen
      6. Andere besondere Typenzwänge
      7. Mehrere Beschränkungen
    3. Null-ähnliche Werte
    4. Generische Methoden
      1. Typeninferenz
    5. Generika und Tupel
    6. Innerhalb von Generika
    7. Zusammenfassung
  6. 5. Sammlungen
    1. Arrays
      1. Array-Initialisierung
      2. Suchen und Sortieren
      3. Mehrdimensionale Arrays
      4. Kopieren und Größenänderung
    2. Liste<T>
    3. Listen- und Sequenzschnittstellen
    4. Listen und Sequenzen implementieren
      1. IEnumerable<T> mit Iteratoren implementieren
      2. Sammlung<T>
      3. ReadOnlyCollection<T>
    5. Adressierung von Elementen mit Index- und Bereichssyntax
      1. System.Index
      2. System.Bereich
      3. Unterstützung von Index und Bereich in deinen eigenen Typen
    6. Wörterbücher
      1. Sortierte Wörterbücher
    7. Sets
    8. Warteschlangen und Stapel
    9. Verknüpfte Listen
    10. Gleichzeitige Sammlungen
    11. Unveränderliche Sammlungen
      1. UnveränderlichesArray<T>
    12. Zusammenfassung
  7. 6. Vererbung
    1. Vererbung und Konvertierungen
    2. Vererbung von Schnittstellen
    3. Generika
      1. Kovarianz und Kontravarianz
    4. System.Object
      1. Die allgegenwärtigen Methoden von System.Object
    5. Zugänglichkeit und Vererbung
    6. Virtuelle Methoden
      1. Abstrakte Methoden
      2. Vererbung und Bibliotheksversionierung
    7. Versiegelte Methoden und Klassen
    8. Zugriff auf Basismitglieder
    9. Vererbung und Konstruktion
    10. Besondere Grundtypen
    11. Zusammenfassung
  8. 7. Objekt-Lebensdauer
    1. Speicherbereinigung
      1. Erreichbarkeit bestimmen
      2. Versehentlich den Garbage Collector besiegen
      3. Schwache Referenzen
      4. Erinnerung zurückgewinnen
      5. Garbage Collector Modi
      6. Vorübergehende Aussetzung der Speicherbereinigung
      7. Versehentlich die Verdichtung unterlaufen
      8. Speicherbereinigung erzwingen
    2. Zerstörer und Finalisierung
    3. IDisposable
      1. Optionale Entsorgung
    4. Boxen
      1. Boxen Nullable<T>
    5. Zusammenfassung
  9. 8. Ausnahmen
    1. Ausnahme-Quellen
      1. Ausnahmen von APIs
      2. Von der Laufzeitumgebung erkannte Ausfälle
    2. Umgang mit Ausnahmen
      1. Ausnahme-Objekte
      2. Mehrere Fangblöcke
      3. Ausnahme-Filter
      4. Verschachtelte Try-Blöcke
      5. endlich Blöcke
    3. Das Werfen von Ausnahmen
      1. Ausnahmen zurückwerfen
      2. Schnell fehlschlagen
    4. Arten von Ausnahmen
      1. Benutzerdefinierte Ausnahmen
    5. Unbehandelte Ausnahmen
    6. Zusammenfassung
  10. 9. Delegierte, Lambdas und Ereignisse
    1. Delegierte Typen
      1. Einen Delegierten erstellen
      2. Multicast-Delegierte
      3. Aufrufen eines Delegierten
      4. Gemeinsame Delegatentypen
      5. Typ Kompatibilität
      6. Hinter der Syntax
    2. Anonyme Funktionen
      1. Erfasste Variablen
      2. Lambdas und Ausdrucksbäume
    3. Veranstaltungen
      1. Standard-Ereignisdelegat-Muster
      2. Benutzerdefinierte Methoden zum Hinzufügen und Entfernen
      3. Ereignisse und der Garbage Collector
      4. Veranstaltungen versus Delegierte
    4. Delegierte versus Schnittstellen
    5. Zusammenfassung
  11. 10. LINQ
    1. Abfrageausdrücke
      1. Wie sich Abfrageausdrücke erweitern
      2. Unterstützende Abfrageausdrücke
    2. Aufgeschobene Bewertung
    3. LINQ, Generics und IQueryable<T>
    4. Standard LINQ Operatoren
      1. Filtern
      2. Wähle
      3. SelectMany
      4. Bestellung
      5. Containment-Tests
      6. Besondere Positionen und Teilbereiche
      7. Aggregation
      8. Operationen einstellen
      9. Ganzzahlige, ordnungserhaltende Operationen
      10. Gruppierung
      11. Tritt bei
      12. Konvertierung
    5. Sequenzerstellung
    6. Andere LINQ-Implementierungen
      1. Entity Framework
      2. Parallele LINQ (PLINQ)
      3. LINQ to XML
      4. Reaktive Erweiterungen
      5. Tx (LINQ to Logs and Traces)
    7. Zusammenfassung
  12. 11. Reaktive Erweiterungen
    1. Grundlegende Schnittstellen
      1. IObserver<T>
      2. IObservable<T>
    2. Veröffentlichen und Abonnieren mit Delegierten
      1. Eine beobachtbare Quelle mit Delegaten erstellen
      2. Abonnieren einer beobachtbaren Quelle mit Delegaten
    3. Sequence Builders
      1. Leere
      2. Niemals
      3. Rückgabe
      4. Wirf
      5. Reichweite
      6. Wiederholen Sie
      7. Erstelle
    4. LINQ-Abfragen
      1. Gruppierungsoperatoren
      2. Operatoren verbinden
      3. SelectMany Operator
      4. Aggregation und andere Einzelwert-Operatoren
      5. Concat-Operator
    5. Rx-Abfrageoperatoren
      1. Zusammenführen
      2. Windowing Operatoren
      3. Der Scan-Operator
      4. Der Amb-Operator
      5. DistinctUntilChanged
    6. Zeitplannungsprogramme
      1. Zeitplanungsprogramme festlegen
      2. Eingebaute Zeitplanungsprogramme
    7. Themen
      1. Thema<T>
      2. BehaviorSubject<T>
      3. ReplaySubject<T>
      4. AsyncSubject<T>
    8. Anpassung
      1. IEnumerable<T> und IAsyncEnumerable<T>
      2. .NET Ereignisse
      3. Asynchrone APIs
    9. Zeitgesteuerte Operationen
      1. Intervall
      2. Timer
      3. Zeitstempel
      4. ZeitIntervall
      5. Drosselklappe
      6. Beispiel
      7. Timeout
      8. Windowing Operatoren
      9. Verzögerung
      10. VerzögerungAbonnement
    10. Zusammenfassung
  13. 12. Baugruppen
    1. Anatomie einer Baugruppe
      1. .NET-Metadaten
      2. Ressourcen
      3. Multifile Baugruppen
      4. Andere PE-Merkmale
    2. Typ Identität
    3. Baugruppen laden
      1. Entschließung der Versammlung
      2. Explizites Laden
      3. Isolierung und Plugins mit AssemblyLoadContext
    4. Namen der Baugruppe
      1. Starke Namen
      2. Version
      3. Kultur
    5. Schutz
    6. Zusammenfassung
  14. 13. Reflexion
    1. Reflexionsarten
      1. Montage
      2. Modul
      3. MitgliedInfo
      4. Typ und TypInfo
      5. MethodBase, ConstructorInfo und MethodInfo
      6. ParameterInfo
      7. FeldInfo
      8. PropertyInfo
      9. EreignisInfo
    2. Reflexion Kontexte
    3. Zusammenfassung
  15. 14. Attribute
    1. Attribute anwenden
      1. Attribut-Ziele
      2. Compiler-verarbeitete Attribute
      3. CLR-verarbeitete Attribute
    2. Attribute definieren und verbrauchen
      1. Attribut-Typen
      2. Abrufen von Attributen
    3. Zusammenfassung
  16. 15. Dateien und Streams
    1. Die Stream-Klasse
      1. Position und Suche
      2. Spülung
      3. Kopieren
      4. Länge
      5. Entsorgung
      6. Asynchroner Betrieb
      7. Konkrete Stromtypen
      8. Ein Typ, viele Verhaltensweisen
    2. Text-orientierte Typen
      1. TextReader und TextWriter
      2. Konkrete Leser- und Schreibertypen
      3. Kodierung
    3. Dateien und Verzeichnisse
      1. FileStream Klasse
      2. Dateiklasse
      3. Verzeichnis Klasse
      4. Pfad Klasse
      5. FileInfo, DirectoryInfo und FileSystemInfo
      6. Bekannte Ordner
    4. Serialisierung
      1. BinaryReader, BinaryWriter und BinaryPrimitives
      2. CLR-Serialisierung
      3. JSON.NET
    5. Zusammenfassung
  17. 16. Multithreading
    1. Themen
      1. Threads, Variablen und gemeinsamer Zustand
      2. Die Thread-Klasse
      3. Der Themenpool
      4. Thread Affinity und SynchronizationContext
    2. Synchronisation
      1. Monitore und das Schlüsselwort lock
      2. SpinLock
      3. Leser/Schreiber Sperren
      4. Ereignis-Objekte
      5. Barriere
      6. CountdownEvent
      7. Semaphoren
      8. Mutex
      9. Verriegelt
      10. Faule Initialisierung
      11. Unterstützung der Gleichzeitigkeit in anderen Klassenbibliotheken
    3. Aufgaben
      1. Die Task- und Task<T>-Klassen
      2. Fortsetzungen
      3. Zeitplannungsprogramme
      4. Fehlerbehandlung
      5. Benutzerdefinierte Threadless-Aufgaben
      6. Eltern/Kind-Beziehungen
      7. Zusammengesetzte Aufgaben
    4. Andere asynchrone Patterns
    5. Stornierung
    6. Parallelität
      1. Die Parallelklasse
      2. Parallele LINQ
      3. TPL Datenfluss
    7. Zusammenfassung
  18. 17. Asynchrone Spracheigenschaften
    1. Asynchrone Schlüsselwörter: async und await
      1. Ausführungs- und Synchronisierungskontexte
      2. Mehrere Operationen und Schleifen
      3. Eine Aufgabe zurückgeben
      4. Anwendung von async auf verschachtelte Methoden
    2. Das Warten-Muster
    3. Fehlerbehandlung
      1. Argumente validieren
      2. Einzelne und mehrere Ausnahmen
      3. Gleichzeitige Operationen und verpasste Ausnahmen
    4. Zusammenfassung
  19. 18. Speicher-Effizienz
    1. (Nicht) nachmachen
    2. Sequentielle Elemente mit Span<T> repräsentieren
      1. Utility Methoden
      2. Nur Stapel
    3. Sequentielle Elemente mit Memory<T> repräsentieren
    4. ReadOnlySequence<T>
    5. Verarbeitung von Datenströmen mit Pipelines
      1. Verarbeitung von JSON in ASP.NET Core
    6. Zusammenfassung
  20. Index

Product information

  • Title: C# 8.0 programmieren
  • Author(s): Ian Griffiths
  • Release date: September 2024
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9781098196639