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# 3.0: kurz & gut

Book Description

Dieses Buch ist für vielbeschäftigte Programmierer gedacht, die eine knappe, aber dennoch gut verständliche Beschreibung von C# 3.0 und LINQ suchen. C# 3.0 - kurz & gut informiert Sie über genau das, was Sie wissen müssen, um schnell mit C# 3.0 sta

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