O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

C# 4.0 kurz & gut, 2nd Edition

Book Description

Wer schon mit Java, C++ oder einer früheren Version von C# vertraut ist, trifft mit C# 4.0 – kurz & gut die optimale Wahl: Kein anderes Buch und keine Online-Ressource bietet so viel Inhalt auf so wenig Raum. Konzentriert auf das Wesentliche und sehr praxisorientiert, behandelt dieses Taschenbuch mehr Themen als viele der großen C#-Kompendien.

Die von Lars Schulten aktualisierte Ausgabe thematisiert auch die wichtigsten neuen Features der C#-Version 4.0.

Table of Contents

  1. C# 4.0: kurz & gut
  2. 1. C# 4.0 – kurz & gut
    1. Was ist neu in C# 4.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
      5. Optionale Argumente (C# 4.0)
      6. Benannte Argumente (C# 4.0)
      7. Argumente als Wert übergeben
        1. Der Modifikator ref
        2. Der Modifikator out
        3. Folgen bei der Übergabe als Referenz
        4. Der Modifikator params
      8. var: Implizit typisierte lokale Variablen
    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
      5. Die Referenz this
      6. Eigenschaften
        1. Nur lesbare und berechnete Eigenschaften
        2. Automatische Eigenschaften
        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
    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. Kovarianz und Kontravarianz in C# 4.0
        1. Kovarianz
        2. Kontravarianz
      10. Erstellen abgeleiteter Klassen von generischen Typen
      11. Selbstreferenzielle generische Deklarationen
      12. Statische Daten
      13. 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
      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
      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
    32. LINQ
      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. Dynamische Typen (C# 4.0)
    34. 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
    35. 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
    36. Präprozessor-Direktiven
      1. Bedingte Attribute
      2. Pragma Warning
    37. XML-Dokumentation
      1. Standard-XML-Dokumentations-Tags
    38. Ü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
      2. DLR (C# 4.0)
        1. Native Interoperabilität
        2. Diagnose
      3. Benutzerschnittstellentechnologien
        1. ASP.NET
        2. Windows Presentation Foundation
        3. Windows Forms
      4. Backend-Technologien
        1. ADO.NET
        2. Windows Workflow
        3. COM+ und MSMQ
      5. Technologien für verteilte Systeme
        1. Windows Communication Foundation
        2. Remoting und (ASMX) Web Services
        3. CardSpace
  3. Stichwortverzeichnis