C# 3.0: kurz & gut

Table of contents

1. C# 3.0: kurz & gut
   1. 1. C# 3.0 – kurz & gut
      1. Was ist neu in C# 3.0?
      2. Ein erstes C#-Programm
         1. Kompilieren
      3. Syntax
         1. Bezeichner und Schlüsselwörter
            1. Vermeiden von Konflikten
            2. Kontextabhängige Schlüsselwörter
         2. Literale, Satzzeichen und Operatoren
         3. Kommentare
      4. Typ-Grundlagen
         1. Beispiele für vordefinierte Typen
         2. Beispiele für selbst definierte Typen
            1. Member eines Typs
            2. Symmetrie von vordefinierten und selbst definierten Typen
            3. Konstruktoren und Instantiierung
            4. Instanz-Member versus statische Member
            5. Das Schlüsselwort public
         3. Umwandlungen
         4. Werte-Typen versus Referenz-Typen
            1. Werte-Typen
            2. Referenz-Typen
            3. Null
            4. Speicher-Overhead
         5. Klassifizierung der vordefinierten Typen
      5. Numerische Typen
         1. Numerische Literale
            1. Ermittlung des Typs aus einem numerischen Literal
            2. Numerische Suffixe
         2. Numerische Konvertierungen
            1. Ganzzahlige Konvertierungen
            2. Gleitkommakonvertierungen
            3. Konvertierung zwischen Gleitkomma-Typen und Integer-Typen
            4. Konvertierung von Dezimalzahlen
         3. Arithmetische Operatoren
         4. Inkrement- und Dekrement-Operatoren
         5. Spezielle ganzzahlige Operationen
            1. Ganzzahlige Division
            2. Ganzzahliger Überlauf
            3. Überlaufprüfung bei ganzzahligen Operationen
            4. Überlaufprüfung für konstante Ausdrücke
            5. Bitweise Operatoren
         6. 8- und 16-Bit-Integer
         7. Besondere Float- und Double-Werte
         8. double versus decimal
         9. Rundungsfehler bei Gleitkommazahlen
      6. Boolescher Typ und Boolesche Operatoren
         1. Gleichheits- und Vergleichs-Operatoren
         2. Bedingte Operatoren
      7. Strings und Zeichen
         1. Zeichenkonvertierung
         2. Der Typ String
            1. String-Verkettung
            2. String-Vergleiche
            3. Suchen in Strings
            4. Strings verändern
      8. Arrays
         1. Standard-Element-Initialisierung
            1. Werte-Typen versus Referenz-Typen
         2. Mehrdimensionale Arrays
            1. Rechteckige Arrays
            2. Ungleichförmige Arrays
         3. Vereinfachte Ausdrücke zur Array-Initialisierung
         4. Prüfen der Grenzen
      9. Variablen und Parameter
         1. Der Stack und der Heap
            1. Der Stack
            2. Der Heap
         2. Sichere Zuweisung
         3. Standardwerte
         4. Parameter
            1. Argumente als Wert übergeben
            2. Der Modifikator ref
            3. Der Modifikator out
            4. Folgen bei der Übergabe als Referenz
            5. Der Modifikator params
         5. var: Implizit typisierte lokale Variablen (C# 3.0)
      10. Ausdrücke und Operatoren
          1. Primäre Ausdrücke
          2. Void-Ausdrücke
          3. Zuweisungsausdrücke
          4. Priorität und Assoziativität von Operatoren
             1. Priorität
             2. Links-assoziative Operatoren
             3. Rechts-assoziative Operatoren
          5. Operator-Tabelle
      11. Anweisungen
          1. Deklarationsanweisungen
             1. Lokale Variablen
          2. Ausdrucksanweisungen
          3. Auswahlanweisungen
             1. Die if-Anweisung
             2. Die else-Klausel
             3. Änderung des Programmflusses durch geschweifte Klammern
             4. Die switch-Anweisung
          4. Iterationsanweisungen
             1. while- und do-while-Schleifen
             2. for-Schleifen
             3. foreach-Schleifen
          5. Sprunganweisungen
             1. Die break-Anweisung
             2. Die continue-Anweisung
             3. Die goto-Anweisung
             4. Die return-Anweisung
             5. Die throw-Anweisung
          6. Weitere Anweisungen
      12. Namensräume
          1. Die using-Direktive
          2. Regeln innerhalb eines Namensraums
             1. Geltungsbereich von Namen
             2. Verbergen von Namen
             3. Der Qualifizierer global::
             4. Wiederholte Namensräume
          3. Aliase für Typen und Namensräume
      13. Klassen
          1. Felder
             1. Feld-Initialisierung
             2. Gemeinsames Deklarieren mehrerer Felder
          2. Methoden
             1. Überladen von Methoden
             2. Übergabe als Wert versus Übergabe als Referenz
          3. Instanz-Konstruktor
             1. Überladen von Konstruktoren
             2. Implizite parameterlose Konstruktoren
             3. Reihenfolge von Feld-Initialisierung und Konstruktor
             4. Nicht öffentliche Konstruktoren
          4. Objekt-Initialisierer (C# 3.0)
          5. Die Referenz this
          6. Eigenschaften
             1. Nur lesbare und berechnete Eigenschaften
             2. Automatische Eigenschaften (C# 3.0)
             3. Sichtbarkeit von get und set
          7. Indexer
             1. Implementieren eines Indexers
          8. Konstanten
          9. Statische Konstruktoren
             1. Nichtdeterminismus von statischen Konstruktoren
          10. Statische Klassen
          11. Finalizer
          12. Partielle Klassen und Methoden
              1. Partielle Methoden (C# 3.0)
      14. Vererbung
          1. Polymorphie
          2. Casting
             1. Upcast
             2. Downcast
             3. Der Operator as
             4. Der Operator is
          3. Virtuelle Funktions-Member
          4. Abstrakte Klassen und abstrakte Member
          5. Verbergen geerbter Member
          6. Funktionen und Klassen versiegeln
          7. Das Schlüsselwort base
          8. Konstruktoren und Vererbung
             1. Impliziter Aufruf des parameterlosen Basisklassen-Konstruktors
             2. Reihenfolge von Konstruktor und Feld-Initialisierung
          9. Auflösen beim Überladen
      15. Der Typ object
          1. Boxing und Unboxing
             1. Kopiersemantik beim Boxing und Unboxing
          2. Statische und dynamische Typprüfung
          3. Member von object
          4. GetType( ) und typeof
          5. Equals, ReferenceEquals und GetHashCode
          6. Die Methode ToString
      16. Structs
          1. Semantik beim Erzeugen eines Struct
      17. Zugriffsmodifikatoren
          1. Beispiele
          2. Beschneiden der Sichtbarkeit
          3. Einschränkungen bei Zugriffsmodifikatoren
      18. Interfaces
          1. Erweitern eines Interface
          2. Explizite Implementierung eines Interface
          3. Virtuelles Implementieren von Interface-Membern
          4. Reimplementieren eines Interface in einer Subklasse
      19. Enums
          1. Enum-Konvertierungen
          2. Flag-Enums
          3. Enum-Operatoren
      20. Eingebettete Typen
      21. Generics
          1. Generische Typen
          2. Warum Generics existieren
          3. Generische Methoden
          4. Deklarieren generischer Parameter
          5. typeof und Generics
          6. Der generische Wert default
          7. Generische Constraints
          8. Generics und Kovarianz
          9. Erstellen abgeleiteter Klassen von generischen Typen
          10. Selbstreferenzielle generische Deklarationen
          11. Statische Daten
          12. Initialisierung generischer Collections
      22. Delegates
          1. Schreiben von Plug-in-Methoden mit Delegates
          2. Multicast-Delegates
          3. Instanzmethoden versus statische Methoden als Ziele
          4. Generische Delegate-Typen
          5. Delegate-Kompatibilität
             1. Typ-Kompatibilität
             2. Parameter-Kompatibilität
             3. Rückgabetyp-Kompatibilität
      23. Events
          1. Standard-Event-Muster
          2. Event-Accessors
          3. Event-Modifikatoren
      24. Lambda-Ausdrücke (C# 3.0)
          1. Explizite Angabe von Lambda-Parameter-Typen
          2. Generische Lambda-Ausdrücke und die Func-Delegates
          3. Äußere Variablen
      25. Anonyme Methoden
      26. try-Anweisungen und Exceptions
          1. Die catch-Klausel
          2. Der finally-Block
             1. Die using-Anweisung
          3. Werfen von Exceptions
             1. Eine Exception weiterwerfen
          4. Wichtige Eigenschaften von System.Exception
          5. Die wichtigsten Exception-Typen
      27. Enumeration und Iteratoren
          1. Enumeration
          2. Iteratoren
          3. Iterator-Semantik
             1. Mehrere yield-Anweisungen
             2. yield break
          4. Sequenzen kombinieren
      28. Nullbare Typen
          1. Null-Grundlagen
             1. Die Struct Nullable<T>
             2. Implizite und explizite nullbare Konvertierungen
             3. Boxing und Unboxing nullbarer Werte
          2. Übernommene Operatoren
             1. Gleichheitsoperatoren (== !=)
             2. Relationale Operatoren (< <= >= >)
             3. Alle anderen Operatoren (+ − * / % & | ^ << >> + ++ − −− ! ~)
             4. Mischen von nullbaren und nicht nullbaren Typen
          3. bool?
          4. Null-Verbindungsoperator
      29. Überladen von Operatoren
          1. Operator-Funktionen
          2. Überladen von Gleichheits- und Vergleichsoperatoren
          3. Eigene implizite und explizite Konvertierungen
      30. Extension-Methoden (C# 3.0)
          1. Verketten von Extension-Methoden
          2. Mehrdeutigkeit und Auflösung
             1. Namensräume
             2. Extension-Methoden versus Instanz-Methoden
             3. Extension-Methoden versus Extension-Methoden
      31. Anonyme Typen (C# 3.0)
      32. LINQ (C# 3.0)
          1. Grundlagen von LINQ
             1. Eine einfache Abfrage
             2. Projizieren
             3. Take und Skip
             4. Element-Operatoren
             5. Aggregationsoperatoren
             6. Quantifikatoren
             7. Set-Operatoren
          2. Verzögerte Ausführung
          3. Standard-Abfrageoperatoren
          4. Abfrageoperatoren verketten
          5. Query-Syntax
             1. Query-Syntax versus Lambda-Syntax
          6. Das Schlüsselwort let
          7. Abfragefortsetzungen
          8. Mehrere Generatoren
          9. Verknüpfen
             1. GroupJoin
          10. Ordnen
          11. Gruppieren
          12. OfType und Cast
      33. Attribute
          1. Attribut-Klassen
          2. Benannte und Positionsparameter
          3. Attribut-Ziele
          4. Angeben mehrerer Attribute
          5. Schreiben eigener Attribute
          6. Auslesen von Attributen zur Laufzeit
      34. Unsicherer Code und Zeiger
          1. Zeiger-Grundlagen
          2. Unsicherer Code
          3. Die Anweisung fixed
          4. Der Zeiger-auf-Member-Operator
          5. Arrays
             1. Das Schlüsselwort stackalloc
             2. Puffer fester Größe
          6. void*
          7. Zeiger auf nicht verwalteten Code
      35. Präprozessor-Direktiven
          1. Bedingte Attribute
          2. Pragma Warning
      36. XML-Dokumentation
          1. Standard-XML-Dokumentations-Tags
      37. Überblick über das Framework
          1. Das Basis-Framework
             1. System-Typen
             2. Textverarbeitung
             3. Collections
             4. Abfragen
             5. XML
             6. Streams und E/A
             7. Netzwerk
             8. Serialisierung
             9. Assemblies, Reflection und Attribute
             10. Sicherheit
             11. Threading
             12. Anwendungsdomänen
             13. Native Interoperabilität
             14. Diagnose
          2. Benutzerschnittstellentechnologien
             1. ASP.NET
             2. Windows Presentation Foundation
             3. Windows Forms
          3. Backend-Technologien
             1. ADO.NET
             2. Windows Workflow
             3. COM+ und MSMQ
          4. Technologien für verteilte Systeme
             1. Windows Communication Foundation
             2. Remoting und (ASMX) Web Services
             3. CardSpace