Programmieren mit C# 3.0

Table of contents

1. Programmieren mit C# 3.0
   1. Einleitung
      1. C# und .NET
      2. Über dieses Buch
      3. Was Sie für dieses Buch benötigen
      4. Wie dieses Buch aufgebaut ist
         1. Teil I: Die Sprache C#
         2. Teil II: C# und Daten
         3. Teil III: Programmieren mit C#
         4. Teil IV: Die CLR und das .NET Framework
      5. Leserkreis
      6. Schriftkonventionen
      7. Support
      8. Die Codebeispiele verwenden
      9. Danksagungen
         1. Von Jesse Liberty
         2. Von Donald Xie
      10. Widmungen
          1. Von Jesse Liberty
          2. Von Donald Xie
   2. I. Die Sprache C#
      1. 1. C# 3.0 und .NET 3.5
         1. Die Entwicklung von C#
         2. Die Programmiersprache C#
            1. Ein bisschen Geschichte
            2. C#-Features
         3. Die .NET-Plattform
      2. 2. Erste Schritte: »Hello World«
         1. Klassen, Objekte und Typen
            1. Methoden
            2. Kommentare
            3. Konsolenanwendungen
            4. Namensräume
            5. Der Punkt-Operator (.)
            6. Die using-Direktive
            7. Groß- und Kleinschreibung
            8. Das Schlüsselwort static
         2. Entwicklung von »Hello World«
            1. Bearbeitung von »Hello World«
            2. »Hello World« kompilieren und ausführen
         3. Verwendung des Visual Studio 2008-Debuggers
      3. 3. Grundlagen der Sprache C#
         1. Typen
            1. Eingebaute Typen
               1. Einen eingebauten Typ wählen
               2. Konvertierung eingebauter Typen
         2. Variablen und Konstanten
            1. Definitive Zuweisung
            2. Konstanten
            3. Enumerationen
            4. Strings
            5. Bezeichner
         3. Whitespace
         4. Anweisungen
            1. Unbedingte Verzweigungsanweisungen
            2. Bedingte Verzweigungsanweisungen
               1. if...else-Anweisungen
               2. Geschachtelte if-Anweisungen
               3. Switch-Anweisungen als Alternative zu geschachtelten ifs
               4. Switch für String-Anweisungen
            3. Iterationsanweisungen
               1. Die goto-Anweisung
               2. Die while-Schleife
               3. Die do ... while-Schleife
               4. Die for-Schleife
               5. Die foreach-Anweisung
               6. Die Anweisungen continue und break
         5. Operatoren
            1. Der Zuweisungsoperator (=)
            2. Mathematische Operatoren
               1. Einfache arithmetische Operatoren (+, −, *, /)
               2. Der Modulo-Operator (%) für Divisionsreste
            3. Inkrementierungs- und Dekrementierungsoperatoren
               1. Operatoren zur Berechnung und Neuzuweisung
               2. Die Präfix- und Postfix-Operatoren
            4. Relationale Operatoren
            5. Logische Operatoren mit Bedingungen verwenden
            6. Operatorpräzedenz
            7. Der ternäre Operator
         6. Präprozessordirektiven
            1. Bezeichner definieren
            2. Bezeichnerdefinitionen aufheben
            3. #if, #elif, #else und #endif
      4. 4. Klassen und Objekte
         1. Klassen definieren
            1. Zugriffsmodifikatoren
            2. Argumente zu Methoden
         2. Objekte erzeugen
            1. Konstruktoren
            2. Initialisierer
            3. Das Interface ICloneable
            4. Objekt-Initialisierer
            5. Das Schlüsselwort this
         3. Statische Member verwenden
            1. Statische Methoden aufrufen
            2. Statische Konstruktoren verwenden
            3. Statische Klassen
            4. Statische Felder verwenden
         4. Objekte zerstören
            1. Der C#-Destruktor
            2. Destruktoren und Dispose
            3. Die Methode Close() implementieren
            4. Die using-Anweisung
         5. Parameter übergeben
            1. Übergabe by reference
            2. Definitive Zuweisungen durch out-Parameter vermeiden
         6. Methoden und Konstruktoren überladen
         7. Daten durch Eigenschaften kapseln
            1. Die Zugriffsmethode get
            2. Die Zugriffsmethode set
            3. Modifikatoren für den Zugriff auf Eigenschaften
            4. Automatische Eigenschaften
         8. Schreibgeschützte Felder
      5. 5. Vererbung und Polymorphie
         1. Spezialisierung und Verallgemeinerung
         2. Vererbung
            1. Vererbung implementieren
         3. Polymorphie
            1. Polymorphe Typen erzeugen
            2. Polymorphe Methoden erzeugen
            3. Konstruktoren von Basisklassen aufrufen
            4. Den Zugang kontrollieren
            5. Versionierung mit den Schlüsselwörtern new und override
         4. Abstrakte Klassen
            1. Beschränkungen für abstract
            2. Versiegelte Klassen
         5. Die Wurzel aller Klassentypen: Object
         6. Geschachtelte Klassen
      6. 6. Operatoren überladen
         1. Das Schlüsselwort operator
         2. Andere .NET-Sprachen unterstützen
         3. Nützliche Operatoren erstellen
         4. Logische Paare
         5. Der Gleichheitsoperator
         6. Konvertierungsoperatoren
         7. Operatoren einsetzen
      7. 7. Structs
         1. Structs definieren
         2. Structs erzeugen
            1. Structs als Werttypen
      8. 8. Interfaces
         1. Ein Interface definieren und implementieren
            1. Mehr als ein Interface implementieren
            2. Interfaces erweitern
            3. Interfaces kombinieren
            4. Polymorphie durch Interfaces
            5. Interface versus abstrakte Klasse
         2. Interface-Implementierungen überschreiben
         3. Interfaces explizit implementieren
            1. Interface-Methoden selektiv offenlegen
            2. Verbergen von Members
      9. 9. Arrays, Indexer und Collections
         1. Arrays
            1. Arrays deklarieren
            2. Standardwerte verstehen
            3. Zugriff auf Array-Elemente
         2. Die foreach-Anweisung
            1. Array-Elemente initialisieren
            2. Das Schlüsselwort params
            3. Mehrdimensionale Arrays
               1. Rechteckige Arrays
               2. Ungleichförmige Arrays
            4. Array-Grenzen
            5. Array-Konvertierungen
            6. Arrays sortieren
         3. Indexer
            1. Indexer und Zuweisung
            2. Indizes für andere Werte
         4. Collection-Interfaces
            1. Das Interface IEnumerable<T>
         5. Constraints
         6. List<T>
            1. IComparable implementieren
            2. IComparer implementieren
         7. Queues
         8. Stacks
         9. Dictionaries
            1. IDictionary<K,V>
      10. 10. Strings und reguläre Ausdrücke
          1. Strings
             1. Strings erzeugen
             2. Die Methode ToString()
             3. Strings bearbeiten
             4. Teil-Strings finden
             5. Strings aufspalten
             6. Dynamische String-Bearbeitung
          2. Reguläre Ausdrücke
             1. Verwendung von regulären Ausdrücken: Regex
             2. Verwendung von Regex Match Collections
             3. Regex-Gruppen verwenden
             4. CaptureCollection verwenden
      11. 11. Exceptions
          1. Exceptions auslösen und abfangen
             1. Die throw-Anweisung
             2. Die catch-Anweisung
                1. Korrekturmaßnahmen ergreifen
                2. Entladung des Aufruf-Stacks
             3. Try/Catch Best Practices
             4. Die finally-Anweisung
          2. Exception-Objekte
      12. 12. Delegates und Events
          1. Events
          2. Events und Delegates
             1. Indirekter Aufruf
             2. Publizieren und abonnieren
             3. Die publizierende Klasse: Clock
             4. Registrieren, um benachrichtigt zu werden
             5. Ablauf der Ereignisse
             6. Gefahr bei Delegates
             7. Das Schlüsselwort event
          3. Anonyme Methoden
             1. Lambda-Ausdrücke
             2. Callback-Methoden
   3. II. C# und Daten
      1. 13. Einführung in LINQ
         1. Eine Abfrage definieren und ausführen
            1. Erstellen der Abfrage
               1. Die from-Klausel
               2. Filtern
               3. Projektion (oder select)
            2. Verzögerte Abfrage-Auswertung
         2. LINQ und C#
            1. Join-Abfragen
            2. Sortierung und das Schlüsselwort var
            3. Gruppieren und das Schlüsselwort group
         3. Anonyme Typen
         4. Implizit typisierte lokale Variablen
         5. Extension-Methoden
            1. Extension-Methoden definieren und anwenden
            2. Einschränkungen bei Extension-Methoden
         6. Lambda-Ausdrücke in LINQ
      2. 14. Arbeiten mit XML
         1. XML-Grundlagen (Eine kurze Einführung)
            1. Elemente
            2. XHTML
         2. X steht für eXtensible
         3. Erstellen von XML-Dokumenten
            1. XML-Elemente
            2. XML-Attribute
         4. Suchen in XML mit XPath
            1. Suchen nach einem einzelnen Knoten
            2. Suchen entlang von Achsen
            3. Prädikate
            4. XPath-Funktionen
         5. Suchen mit dem XPathNavigator
            1. Verwenden des XPathNodeIterator
            2. Verwenden von XPathExpression
         6. XML-Serialisierung
            1. Anpassen der XML-Serialisierung durch Attribute
            2. Anpassen der XML-Serialisierung zur Laufzeit
      3. 15. LINQ im Einsatz
         1. Einrichten der Umgebung
         2. Grundlagen für LINQ to SQL
         3. Der Visual Studio LINQ to SQL Designer
         4. Lesen von Daten
            1. Erstellen von Membern für jede Tabelle
            2. Eine LINQ-Abfrage
         5. Aktualisieren von Daten mit LINQ to SQL
            1. Hinzufügen eines Kunden-Datensatzes
            2. Verändern eines Kunden-Datensatzes
         6. Löschen relationaler Daten
         7. LINQ to XML
      4. 16. ADO.NET und relationale Datenbanken
         1. Relationale Datenbanken und SQL
            1. Tabellen, Datensätze und Spalten
            2. Normalisierung
            3. Deklarative referenzielle Integrität
            4. SQL
         2. Das Objektmodell von ADO.NET
            1. DataTable- und DataColumn-Objekte
            2. DataRelation-Objekte
            3. Rows
            4. DataAdapter
            5. DBCommand und DBConnection
            6. DataReader
         3. Erste Schritte mit ADO.NET
   4. III. Programmieren mit C#
      1. 17. ASP.NET-Anwendungen programmieren
         1. Grundlagen der Web Forms
            1. Events bei Web Forms
               1. Postback-Events und Nonpostback-Events
               2. Zustand
            2. Der Lebenszyklus von Web Forms
         2. Ein Webformular erstellen
            1. Code-behind-Dateien
            2. Steuerelemente hinzufügen
            3. Server-Steuerelemente
         3. Datenanbindung
            1. Der generierte HTML-Code
            2. Steuerelemente und Events hinzufügen
      2. 18. WPF-Anwendungen programmieren
         1. WPF (sehr) kurz gefasst
            1. Ein WPF-Beispiel erstellen
            2. Das Beispielprogramm
         2. Die Anwendung erstellen
            1. Grids und Stack Panels
            2. Einmal Informationen im Überfluss
               1. Unsere Ziele
            3. Hinzufügen von Daten
               1. Objekte deklarativ instanziieren
            4. Die Daten in XAML verwenden
            5. Die Listbox definieren
            6. Die vollständige XAML-Datei
            7. Event-Handling (endlich!)
         3. Was hast du gelernt, Dorothy?
      3. 19. Anwendungen mit Windows Forms programmieren
         1. Erstellen der Anwendung
            1. Definieren von Event-Handlern
            2. Die TreeView-Steuerelemente füllen
               1. TreeNode-Objekte
               2. Rekursion durch die Unterverzeichnisse
               3. Die Dateien in das Verzeichnis holen
            3. TreeView-Events behandeln
               1. Auf das Quell-TreeView klicken
               2. Ein Verzeichnis expandieren
               3. Auf das Ziel-TreeView klicken
               4. Das Event des Clear-Buttons behandeln
            4. Das Copy-Button-Event implementieren
               1. Die gewählten Dateien beschaffen
               2. Die Liste der gewählten Dateien sortieren
            5. Das Delete-Button-Event behandeln
   5. IV. Die CLR und das .NET Framework
      1. 20. Attribute und Reflection
         1. Attribute
            1. Arten von Attributen
               1. Attributziele
               2. Attribute anwenden
            2. Benutzerdefinierte Attribute
               1. Ein Attribut deklarieren
               2. Ein Attribut benennen
               3. Ein Attribut anlegen
               4. Ein Attribut anwenden
         2. Reflection
            1. Metadaten betrachten
            2. Typerkundung
            3. Über einen Typ reflektieren
               1. Alle Member eines Typs ermitteln
               2. Methoden eines Typs ermitteln
               3. Einzelne Member eines Typs ermitteln
            4. Spätes Binden
      2. 21. Threads und Synchronisation
         1. Threads
            1. Threads starten
            2. Threads vereinigen
            3. Threads mit Sleep blockieren
            4. Threads abbrechen
         2. Synchronisation
            1. Interlocked verwenden
            2. Locks verwenden
            3. Monitore verwenden
         3. Race Conditions und Deadlocks
            1. Race Conditions
            2. Deadlocks
      3. 22. Streams
         1. Dateien und Verzeichnisse
            1. Mit Verzeichnissen arbeiten
            2. Ein DirectoryInfo-Objekt anlegen
            3. Mit Dateien arbeiten
            4. Dateien verändern
         2. Dateien lesen und schreiben
            1. Binäre Dateien
            2. Gepufferte Streams
            3. Mit Textdateien arbeiten
         3. Asynchrone Ein-/Ausgabe
         4. Ein-/Ausgabe im Netzwerk
            1. Ein Netzwerk-Server mit Streams
            2. Ein Netzwerk-Client mit Streams
            3. Mit mehreren Verbindungen arbeiten
            4. Asynchrones File-Streaming
         5. Webstreams
         6. Serialisierung
            1. Einen Formatter verwenden
            2. Mit Serialisierung arbeiten
               1. Das Objekt serialisieren
               2. Das Objekt deserialisieren
            3. Mit transienten Daten umgehen
         7. Isolierte Speicher
      4. 23. Programmieren mit .NET und COM
         1. ActiveX-Steuerelemente importieren
            1. Ein ActiveX-Control erstellen
            2. Ein Steuerelement in .NET importieren
               1. Ein Steuerelement importieren
               2. Das Steuerelement manuell importieren
               3. Das Steuerelement in das Formular einfügen
         2. P/Invoke
         3. Zeiger
   6. C#-Schlüsselwörter
   7. Kolophon