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

Handbuch der .NET 4.0-Programmierung. Band 1: C# 2010 und .NET-Grundlagen

Book Description

Das .NET Framework 4.0 eröffnet Entwicklern viele neue Möglichkeiten. Autor Rolf Wenger geht in diesem Buch zunächst auf die Grundlagen der .NET-Programmierung ein: Wie funktioniert die Sprache C#? Welche elementaren Klassen enthält die .NET-Bibliothek? Wie greift man auf Datenbanken zu? Dieses Buch ist der erste Band einer dreiteiligen Reihe, mit der Wenger eines der umfassendsten Nachschlagewerke zur .NET-Programmierung liefert. In den folgenden Bänden werden u.a. Windows Forms, ASP.NET, WCF (Windows Communication Foundation), WPF (Windows Presentation Foundation) und Silverlight behandelt.

Table of Contents

  1. Handbuch der .NET 4.0-Programmierung: Band 1: C# und .NET-Grundlagen
  2. Vorwort
  3. Einleitung
    1. Zielpublikum dieses Buchs
    2. Der Nutzen dieses Buchs
    3. Die Codebeispiele
    4. Ein Wort zu den Bezeichnern
    5. Feedback
    6. Support für dieses Buch
  4. 1. .NET Framework und Visual Studio
    1. Eine erste Definition von .NET
    2. Welche Alternativen zu .NET existieren?
      1. Entwickeln mit Java
      2. Native Entwicklungen
    3. Wie funktioniert .NET?
      1. Die Installation der Common Language Runtime
      2. Die Common Language Runtime
        1. Der Just-In-Time-Compiler
        2. Verwaltung der Typen und Typkonvertierung zur Laufzeit
        3. Das Typensystem
        4. Grundlegende Typendefinition
        5. Werttypen
        6. Referenztypen
        7. Werttypen umwandeln (Boxing und Unboxing)
        8. Speicherverwaltung (Garbage Collector)
        9. Durchsetzen der Sicherheit
        10. Sicherstellen der Interoperabilität
      3. Die Dynamic Language Runtime
    4. Visual Studio 2010
      1. Konfiguration und Einstellungen
      2. Mit Visual Studio eine Lösung aufbauen
      3. Die Konfiguration kontrollieren und korrigieren
        1. Grundeinstellungen der Anwendung
        2. Assembly-Informationen
        3. Einstellungen zur Kompilation der Anwendung
        4. Zusätzliche Schritte automatisieren
        5. Einstellungen für das Ausführen des entwickelten Programms
        6. Ressourcen definieren
        7. Client Application Services
        8. Einstellungsdatei der Anwendung nutzen
        9. Zusätzliche Pfade für benutzte Assemblys einstellen
        10. Signierung benutzen
        11. Sicherheit und Verteilung konfigurieren
        12. Codeanalyse nutzen
      4. Code verändern
      5. Code mithilfe von Codierungsunterstützung erstellen
      6. Code ausführen
      7. Eine Anwendung entwanzen (debuggen)
        1. Debugging ohne Haltepunkt
        2. Debugging mit Haltepunkt
        3. Inhalte eigener Daten beim Debuggen ansehen und verändern
        4. Dynamische Evaluation von Ausdrücken
        5. Abbrechen einer Debugging-Sitzung
      8. Tastenkürzel
      9. Die Lösung mit einer eigenen Bibliothek ergänzen
        1. Codieren der Klassenbibliothek
        2. Die Klassenbibliothek benutzen
    5. Von Assemblys und Prozessen
      1. Einen Prozessraum aufbauen
      2. Konfiguration von .NET-Anwendungen
      3. Suchen und Finden von Programmdateien und Assemblys
        1. In eine Assembly hineinschauen
        2. Eine Assembly mit einem starken Namen versehen
        3. Der globale Assemblycache
        4. Ablage der Bibliothek bei der Anwendung
        5. Gemeinsame Nutzung von Assemblys im globalen Assemblycache
        6. Organisation des globalen Assemblycaches
        7. Laden von Assemblys
        8. Versionsrichtlinien anwenden
        9. Im globalen Assemblycache suchen
        10. Hinweis auf die Codebasis
        11. Hierarchische Suche der Assembly
  5. 2. Die Sprache C#
    1. Das »Henne-Ei-Problem«
      1. Typen
      2. Objekte und Variablen
      3. Methoden
      4. Parameter und Rückgabewerte
      5. Anweisungen und Operatoren
      6. Programme und Strukturen
    2. Grundlegende Elemente eines C#-Programms
      1. Die Grundstruktur
      2. Schlüsselwörter der Sprache
        1. Typen
        2. Modifizierende Schlüsselwörter
        3. Anweisungen
        4. Operatoren
        5. Language Integrated Query
        6. Typenumwandlungen
        7. Namensraum
        8. Zugriffssteuerung
        9. Literale
      3. Kommentierungen
        1. Zeilenendkommentare
        2. Blockkommentare
        3. Dokumentationskommentare
        4. Einschalten der XML-Dokumentationskommentare
        5. Richtig kommentieren
      4. Variablen oder Objekte
        1. Allgemeine Namensgebung von Bezeichnern
        2. Regeln von Microsoft für Bezeichner
        3. Allgemeine Regeln zur Schreibweise
        4. Namen von Assemblys
        5. Namen von Namensräumen
        6. Namen von Klassen, Strukturen und Schnittstellen
        7. Namen von Typelementen
        8. Namen von Parametern
        9. Namen von Ressourcen
        10. Eigene Regeln von Bezeichnern
      5. Organisation, Schreibweise und Verwendung von Namensräumen
        1. Schreibweise von Namensräumen
        2. Nutzung von Namensräumen
        3. Explizite Nutzung eines Namensraumes
        4. Implizite Nutzung eines Namensraumes
        5. Organisation von Namensräumen
        6. Konfliktlösung gleicher Namensräume verschiedener Assemblys
      6. Literale
        1. Leerräume
        2. Zeichenliterale
        3. Textliterale
        4. Ganzzahlliteral
        5. Gleitkommaliterale
        6. Literale Schlüsselwörter
      7. Anweisungen für die Ablaufsteuerung
        1. Verzweigungen
        2. Die einfache Verzweigung mit if
        3. Die mehrfache Verzweigung mit switch
        4. Schleifensteuerung
        5. Die Schleifensteuerung mit while
        6. Die Schleifensteuerung mit do while
        7. Die Schleifensteuerung mit for
        8. Die Schleifensteuerung mit foreach
        9. Sprunganweisungen
        10. Die Sprunganweisung continue
        11. Die Sprunganweisung break
        12. Die Sprunganweisung return
        13. Fehlerbehandlung
        14. Fehlerbehandlung mit try-catch
        15. Fehlerbehandlung mit try-finally
        16. Fehlerbehandlung mit try-catch-finally
      8. Präprozessoranweisungen
        1. Definieren von Konstanten
        2. Bedingte Übersetzung
        3. Konfigurieren von Warnungen und Fehlern
        4. Coderegionen
      9. Operatoren und Ausdrücke
        1. Arithmetische Operatoren
        2. Logische Operatoren
        3. Vergleichsoperatoren
        4. Operatoren für Bitverschiebung
        5. Zuweisungsoperatoren
        6. Operatoren für Objekterzeugung und Typinformationen
        7. Adress- und Zugriffsoperatoren für nativen Speicherzugriff
        8. Sonstige Operatoren
        9. Reihenfolge der Auflösung von Ausdrücken
      10. Datentypen
    3. Vordefinierte Typen
      1. Der Typ object
      2. Der Typ string
      3. Der Typ bool
      4. Der Typ byte
      5. Der Typ sbyte
      6. Der Typ char
      7. Der Typ short
      8. Der Typ ushort
      9. Der Typ int
      10. Der Typ uint
      11. Der Typ long
      12. Der Typ ulong
      13. Der Typ float
      14. Der Typ double
      15. Der Typ decimal
      16. Der Typ void
    4. Benutzerdefinierte Typen
      1. Der Typ enum
      2. Der Typ Array
        1. Eindimensionale Arrays
        2. Mehrdimensionale Arrays
        3. Verzweigte Arrays
      3. Der Typ class
        1. Klassen organisieren
        2. Umsetzung der Kapselung in Form der Sichtbarkeit
        3. Die Klasse als Hülle
        4. Elemente von Klassen
        5. Typen in Klassen verschachteln
        6. Klassen vererben
        7. Überladen von Elementen
        8. Überdecken von Elementen
        9. Überschreiben von Elementen
        10. Abstrakte Klassen
        11. Felder und Konstanten
        12. Felder verkörpern Informationen
        13. Felder in vererbten Typen
        14. Eigenschaften
        15. Vollständig implementierte Eigenschaften
        16. Automatisch implementierte Eigenschaften
        17. Eigenschaften in vererbten Typen
        18. Indexer
        19. Methoden
        20. Einfache Methoden
        21. Benannte und optionale Parameter in Methoden
        22. Bedeutung der this-Referenz
        23. Statische Methoden
        24. Überladen von Methoden
        25. Methoden in vererbten Typen
        26. Partielle Methoden
        27. Konstruktion und Destruktion
        28. Konstruktoren
        29. Konstruktoren in vererbten Typen
        30. Destruktoren
        31. Destruktoren in der Vererbung
        32. Operatoren
      4. Der Typ delegate
        1. Delegaten mit benannten Methoden
        2. Einen Delegaten als Ereignis modifizieren
        3. Delegaten mit anonymen Methoden
      5. Der Typ interface
        1. Grundelemente einer Schnittstelle
        2. Eine Schnittstelle implizit realisieren
        3. Eine Schnittstelle explizit realisieren
        4. Eine Basisumsetzung einer Schnittstelle mit einer abstrakten Klasse kombinieren
      6. Der Typ struct
    5. Generische Typen
      1. Syntaktische Grundlagen
      2. Generische Klassen
        1. Vererbung generischer Klassen von konkreten Klassen
        2. Vererbung generischer Klassen von generischen Klassen
        3. Geschlossen konstruierte generische Typen
        4. Offen konstruierte generische Typen
        5. Vererbung konkreter Klassen von generischen Klassen
        6. Definition von Bedingungen für generische Typen
      3. Generische Schnittstellen
      4. Generische Methoden
      5. Generische Typen und Arrays
      6. Generische Delegaten
      7. Nullzuweisung bei Objekten aus generischen Typen
      8. Nullfähige Werttypen
    6. Anonyme Typen
      1. Implizites Festlegen von Typen
      2. Arbeiten mit Objekten anonymer Typen
    7. Erweiterungsmethoden
      1. Eine Erweiterungsmethode erstellen
      2. Erweiterungsmethoden für Klassen und Strukturen erstellen
      3. Erweiterungsmethoden für Schnittstellen erstellen
      4. Erweiterungsmethoden für Aufzählungen erstellen
      5. Erweiterungsmethoden nutzen
  6. 3. Objektmengen verarbeiten
    1. Spezielle Situationen für Objekte
      1. Konvertieren von Datentypen
        1. Implizite Konvertierungen
        2. Explizite Konvertierungen
        3. Konvertierung durch typenspezifische Methoden
        4. Eigene implizite und explizite Konvertierungsdefinitionen
        5. Konvertierungen mit der Schnittstelle IConvertible
        6. Konvertierungen mit der Klasse TypeConverter
      2. Kopieren von Objekten
        1. Eine flache Kopie erstellen
        2. Eine tiefe Kopie erstellen
        3. Die Schnittstelle ICloneable umsetzen
      3. Deterministische Kontrolle des Lebenszyklus
        1. Die Schnittstelle IDisposable anwenden
        2. Eine verbesserte Version der Anwendung von IDisposable erstellen
        3. Unterschied zwischen internen und externen Ressourcen beherrschen
        4. Das Dispose-Muster automatisch verwenden
      4. Vergleichen von Objekten
        1. Realisieren der Standardmethoden für das Vergleichen von Objekten
        2. Die Methode GetHashCode() überschreiben
        3. Die Schnittstelle IEquatable<T> anwenden
        4. Vergleichsfunktionalität für Sortierungen bereitstellen
    2. Ausnahmen beherrschen und nutzen
      1. Verschiedene Arten von Fehlern
      2. Definitionsfehler
      3. Anwendungsfehler (Softwarefehler)
      4. Laufzeitfehler
      5. Bedienungsfehler
      6. Eine Ausnahme erkennen
      7. Ausnahmeklassen und -objekte
      8. Aufbau eines Fehlerobjekts (Standardklasse)
      9. Eine eigene Ausnahmeklasse erstellen
      10. Architektur von Ausnahmen bestimmen
      11. Schutz des Programms beim Zugriff auf externe Ressourcen
      12. Stabilisieren von Benutzeroberflächen
      13. Überwachen von extremer Speicherauslastung
      14. Die Behandlung von Ausnahmen konzipieren
      15. Allgemeiner Aufbau einer Ausnahmebehandlung
      16. Ausnahmen auslösen
      17. Eine bestehende Ausnahme erneut auslösen
      18. Eine bestehende Ausnahme neu auslösen
      19. Eine Ausnahme durch eine neue Ausnahme ersetzen
      20. Eine Ausnahme in eine innere Ausnahme umwandeln
      21. Ausnahmen behandeln
      22. Die Ausnahme in der Ausnahmebehandlung
    3. Objektmengen verwalten
      1. Grundlagen der Auflistungsklassen
      2. Grundlagen der generischen Auflistungsklassen
      3. Die Qual der Wahl von Auflistungsklassen
      4. Die konkreten Klassen
        1. Aussage zur Performance
        2. Die Klasse ArrayList
        3. Die Klasse BitArray
        4. Die Klasse Hashtable
        5. Die Klassen Queue und Queue<T>
        6. Die Klasse ConcurrentQueue<T>
        7. Die Klassen SortedList und SortedList<T>
        8. Die Klassen Stack und Stack<T>
        9. Die Klasse ConcurrentStack<T>
        10. Die Klasse Dictionary<K,V>
        11. Die Klasse SortedDictionary<K,V>
        12. Die Klasse ConcurrentDictionary<K,V>
        13. Die Klasse LinkedList<T>
        14. Die Klasse List<T>
        15. Die Klasse HashSet<T>
        16. Die Klasse SortedSet<T>
        17. Die Klasse ObservableCollection<T>
        18. Die Klasse BlockingCollection<T>
        19. Die Klasse ConcurrentBag<T>
      5. Auflistungen selber herstellen
        1. Vererbungen von bestehenden Klassen des Frameworks
        2. Aggregation einer bestehenden Klasse des Frameworks
        3. Komplette Neuerstellung einer Auflistungsklasse
        4. Die Realisierung von auflistbaren Typen
    4. Language Integrated Query – LINQ
      1. Die verschiedenen Ebenen von LINQ
        1. LINQ to Objects
        2. LINQ to XML
        3. LINQ to DataSet
        4. LINQ to SQL
        5. LINQ to Entities
      2. Grundlegende Syntax der Verwendung von LINQ
        1. LINQ-Abfrage in der Abfrageform formulieren
        2. LINQ-Abfrage in der Ausdrucksform formulieren
      3. Lambda-Ausdrücke
      4. Elemente von LINQ
        1. Einfache Abfragen als Grundlage
        2. Eine uneingeschränkte Resultatmenge erstellen
        3. Eine gruppierte Resultatmenge erstellen
        4. Eine eingeschränkte Resultatmenge mittels Selektion erstellen
        5. Eine Resultatmenge sortieren
        6. Eine eingeschränkte Resultatmenge mittels einer Projektion erstellen
        7. Die Reihenfolge einer Resultatmenge umkehren
        8. Auf ein einzelnes Element zugreifen
        9. Das erste oder letzte Element
        10. Das erste Element, das letzte Element oder ein Standardelement
        11. Garantiert ein Einzelelement abfragen
        12. Direktzugriff auf ein Objekt über den Index
        13. Ein Standardelement verwenden, wenn die Resultatmenge leer ist
        14. Beispiel zum Thema einzelnes Element
        15. Einen Datenverbund herstellen
        16. Die eingebettete Untermenge
        17. Einen inneren Verbund herstellen (Inner Join)
        18. Einen äußeren Verbund herstellen (Outer Join)
        19. Verknüpfen von Resultatmengen
        20. Duplikate vermeiden
        21. Mehrere Mengen zusammenführen
        22. Nur die Schnittmenge zweier gleichartiger Mengen verarbeiten
        23. Elemente in einer weiteren Menge filtern
        24. Aggregatmethoden in LINQ
        25. Bestimmen der Anzahl von Elementen einer Menge
        26. Bestimmen der Summe einer Spalte
        27. Bestimmen von Minimal- und Maximalwert einer Spalte
        28. Bestimmen des Durchschnittswerts einer Spalte
        29. Herstellen einer bedingten Aggregation
        30. Partitionen erstellen
        31. Auswahl einer fixen Anzahl von Elementen aus einer Menge
        32. Auswahl einer geregelten Anzahl von Elementen aus einer Menge
        33. Überspringen einer fixen Anzahl von Elementen in einer Menge
        34. Überspringen einer geregelten Anzahl von Elementen in einer Menge
        35. Weitere Operatoren von LINQ
        36. Erstellen einer leeren Menge
        37. Prüfen, ob alle Objekte einer Menge bestimmten Kriterien entsprechen
        38. Prüfen, ob mindestens ein Objekt in einer Menge bestimmten Kriterien entspricht
        39. Eine Menge auf das Vorhandensein eines bestimmtes Objekts prüfen
        40. Zwei Abfragen zusammenführen
        41. Generieren von Zahlenbereichen
        42. Generieren einer Liste gleicher Elemente
        43. Zwei Mengen zusammenführen
        44. Zwei Mengen vergleichen
        45. Resultatmengen konvertieren
        46. Spezielle Auflistungen in IEnumerable umwandeln
        47. Eine Menge in ein Array umwandeln
        48. Eine Menge in eine Liste umwandeln
        49. Eine Menge in ein Verzeichnis umwandeln
        50. Eine Menge in eine Lookuptabelle umwandeln
        51. Eine Teilmenge eines bestimmten Typs extrahieren
        52. Eine Typenumwandlung auf eine Menge anwenden
  7. 4. Elementare Klassen der Bibliothek
    1. Der Umgang mit Attributen
      1. Anwendung von Attributklassen
        1. Attributklassen in der .NET-Bibliothek
        2. Benutzen eines Attributs
        3. Gruppierung von Attributen
        4. Entwurfszeitattribute
        5. Kompilierungszeitattribute
        6. Laufzeitattribute
      2. Attribute abfragen
      3. Eigene Attributklassen erstellen
    2. Formatieren von Daten
      1. Numerische Standardformate
      2. Eigene numerische Formate
      3. Standard-Datumsformate
      4. Eigene Datumsformate
      5. Formate von Aufzählungen
      6. Umsetzung der Formate mit Sprachen
      7. Eigene Formatierungen erstellen
    3. Der Umgang mit der Zeit
      1. Der Umgang mit dem Kalender
      2. Mit Zeitpunkten arbeiten
        1. Ein Datums-/Zeitobjekt erstellen
        2. Ein Datums-/Zeitelement abfragen
        3. Mit Datums-/Zeitelementen rechnen
        4. Umgang mit DateTime als lokale Zeit oder Standardzeit
      3. Zeitzonen
      4. Die Stoppuhr
    4. .NET und die Mathematik
      1. Die Klasse Math
        1. Mathematische Konstanten
        2. Trigonometrische Funktionen
        3. Logarithmische Funktionen
        4. Potenzierung und Radizierung
        5. Funktionen für Rundung und Wertkontrolle
      2. Präzision bei mathematischen Berechnungen
        1. Auslöschungen
        2. Absorptionen
        3. Unterläufe
        4. Verstöße gegen das Assoziativ- oder Distributivgesetze
        5. Vergleichsfehler
      3. Der Zufallszahlengenerator
      4. Die Struktur BigInteger
      5. Die Struktur Complex
    5. Die Systemumgebung erforschen
      1. Die Klasse Environment
      2. Die externen Speicher
      3. Weitere Systeminformationen und das Bildschirmsystem
      4. Informationen über die Netzwerkausrüstung
      5. Auf die Windows-Registrierung zugreifen
    6. Von Prozessen, Anwendungsdomänen und Assemblys
      1. Informationen über laufende Prozesse abfragen
      2. Einen Prozess starten
        1. Direktes Starten eines Prozesses
        2. Indirektes Starten eines Prozesses
      3. Einen anderen Prozess beenden
      4. Einen Prozess unter einem anderen Anwenderkonto starten
      5. Die Anwendungsdomäne, der Isolator innerhalb des Prozesses
      6. Informationen über eine Anwendungsdomäne abfragen
      7. Eine zusätzliche Anwendungsdomäne erstellen und nutzen
    7. Anwendungen konfigurierbar gestalten
      1. Das Projekt vorbereiten
      2. Eigene Konfigurationswerte erstellen
      3. Eigene Konfigurationswerte lesen und schreiben
      4. Eigene Konfigurationswerte in Bibliotheken (DLL)
    8. Diagnose und Debugging
      1. Informationen für die Diagnose sammeln und interpretieren
        1. Den Debugger programmatisch ansteuern
        2. Informationen über die aktuelle Methode einholen
        3. Informationen über den Programmstapel sichern
      2. Das Ereignisprotokoll von Windows nutzen
        1. Funktionsweise des Ereignisprotokolls
        2. Eine eigene Ereignisquelle erstellen oder löschen
        3. Einträge in eine Ereignisquelle schreiben
        4. Einträge aus einer Ereignisquelle lesen
      3. Den Ablauf einer Anwendung verfolgen
        1. Deklarative oder imperative Nutzung der Ablaufverfolgung
        2. Ausgabeebenen und Quellen der Ablaufverfolgung
        3. Typen für die Ablaufverfolgung
        4. Einfache Nutzung der Ablaufverfolgung
        5. Deklarative Nutzung
        6. Imperative Nutzung
        7. Nutzung der Ausgabequellen für die Ablaufverfolgung
        8. Deklarative Nutzung
        9. Imperative Nutzung
        10. Einen eigenen Listener für die Ablaufverfolgung erstellen
    9. Garbage Collector
      1. Funktionsweise des Garbage Collector
      2. Einflussnahme auf die Wirkungsweise des Garbage Collectors
      3. Verhalten der GC in mehreren Prozessen
  8. 5. Der Umgang mit Dateien
    1. Arbeiten mit dem Dateisystem
      1. Informationen über Laufwerke abrufen
      2. Handhaben von Verzeichnissen
        1. Nicht qualifizierte Datenzugriffe handhaben
        2. Auflisten von Verzeichnissen und Dateien
      3. Handhaben von Dateien
      4. Verwalten von Berechtigungen
      5. Das Dateisystem überwachen
    2. Datenströme und das E/A-Konzept von .NET
    3. Serialisierung von einfachen Textdaten
      1. Von Zeichen und Zeichencodierungen
        1. Zeichencodierung im Wandel der Zeit
        2. Eine UTF-8-Codierung als Beispiel
        3. Typen für die Zeichencodierung in .NET
        4. Unterstützte Codierungen in .NET
      2. Mit statischen Methode der Klasse File arbeiten
      3. Arbeiten mit Klassen für Textdatenströme
    4. Binäre Serialisierung
      1. Manuelle binäre Serialisierung
      2. Automatische binäre Serialisierung
        1. Die automatische binäre Serialisierung steuern
        2. Einen Datengraphen bereitstellen
        3. Die automatische binäre Serialisierung beeinflussen
        4. Anwendung der Schnittstelle ISerializable
        5. Definition von Methoden für die funktionelle Beeinflussung
        6. Direkter Einfluss auf den Formatierer
        7. Dynamischer Typwechsel
        8. Herstellen der Typkompatibilität für das Deserialisieren
    5. XML-Serialisierung
      1. Manuelle XML-Serialisierung
      2. Automatische XML-Serialisierung
        1. Die automatische XML-Serialisierung steuern
        2. Einen Datengraphen für XML bereitstellen
        3. Azyklische Graphen und vernetzte Objekte
        4. Nicht geeignete Auflistungen serialisieren
        5. Vererbungsstrukturen nach XML serialisieren
        6. Das Beispiel
      3. Die Schnittstelle IXmlSerializable nutzen
      4. LINQ to XML
        1. LINQ-Erweiterungen
        2. Die grundlegenden Klassen von LINQ to XML
        3. Erstellen von XML-Daten
        4. Lesen von XML-Daten
        5. Verändern von XML-Daten
  9. 6. Auf Datenbanken zugreifen
    1. Relationales und objektorientiertes Modell
      1. Gerichtete Assoziation
      2. Bidirektionale Assoziation
      3. Gerichtete 1:m-Assoziation
      4. Bidirektionale 1:m-Assoziation
      5. n:m-Assoziation
      6. Attributierte Assoziation
      7. Aggregationen und Kompositionen
      8. Vererbung
        1. Vererbung durch Hierarchieverflachung
        2. Vererbung durch Hierarchiekombination
        3. Vererbung durch Hierarchietreue
        4. Systematisierung
    2. Andere Datenbanksysteme
    3. Architektur der .NET-Datenbankzugriffe
      1. Vergleich der verschiedenen Techniken
      2. Und wie steht es um die Geschwindigkeit der Techniken?
      3. Details in den Architekturüberlegungen
        1. Datenbanken versus Dateien
        2. Verwendung von Datentypen
        3. Verwendung von Sichten
        4. Erstellung der Primärschlüssel
      4. Verwendete Namensräume
    4. Umgang mit dem Beispiel des Kapitels
      1. Installieren der Datenbanken
      2. Betrachten und Ändern von Dateninhalten
      3. Struktur der Beispiele
    5. Direkte Nutzung der Datenprovider
      1. Grundlagen der Datenveränderung
      2. Konfigurieren einer Anwendung für einen Datenbankzugriff
      3. Herstellen von providerabhängigen Zugriffsobjekten
      4. Das Verbindungsobjekt
      5. Erstellen und Nutzen des Befehlsobjekts
      6. Daten mit dem Datenreader lesen
      7. Datenadapter und CommandBuilder
      8. Das Transaktionsobjekt
    6. Nutzen der Datenkonsumenten
      1. Die Klassen DataSet und DataTable in der Übersicht
      2. Datenprovider typisiert oder nicht typisiert benutzen
      3. Erstellen eines typisierten Datenzugriffs
      4. Nutzen typisierter Datasets
        1. Erstellen von Daten
        2. Lesen von Daten
        3. Verändern von Daten
        4. Löschen von Daten
        5. Nutzen einer eigenen Transaktion
    7. LINQ to SQL
      1. Die Wirkungsweise von LINQ to SQL
      2. Erstellen eines Datenbankzugriffs mit LINQ to SQL
      3. Verfeinern der Vererbungsbeziehung
      4. Nutzen von LINQ to SQL
        1. Erstellen von Daten
        2. Lesen von Daten
        3. Verändern von Daten
        4. Löschen von Daten
      5. Nutzen einer eigenen Transaktion
    8. Entity Framework
      1. Die Wirkungsweise des Entity Framework
      2. Erstellen eines Modells für eine Datenbank
      3. Erstellen einer Vererbungsbeziehung aus der Datenbank
      4. Nutzen des Entity Framework
        1. Erstellen von Daten
        2. Lesen von Daten
        3. Verändern von Daten
        4. Löschen von Daten
      5. Nutzen einer eigenen Transaktion
  10. 7. Verarbeitungen parallelisieren
    1. Von Prozessen und Threads
      1. Parallelisieren von Aufgaben
      2. Wichtige Eigenschaften von Threads
        1. Vordergrund- und Hintergrundthreads
        2. Threads mit verschiedenen Prioritäten
      3. Anatomie einer Threadmethode
    2. Mittel für das Parallelisieren von Aufgaben
      1. Anwendung mehrfach starten (Multitasking)
      2. Timer nutzen
      3. Methoden asynchron aufrufen
      4. Threadpool nutzen
      5. Eigene Threads erstellen
      6. Die Klasse BackgroundWorker nutzen
    3. Parallele Programmierung
      1. Von datenorientierter und aufgabenorientierter Verarbeitung
      2. Nutzen der datenorientierten parallelen Verarbeitung
        1. Bearbeiten von Daten mit unabhängigen Rechenschritten
        2. Bearbeiten von Daten mit abhängigen Rechenschritten
      3. Abbrechen der parallelen Verarbeitung von innen
      4. Nutzen aufgabenorientierter Verarbeitungen
        1. Starten von parallel verarbeiteten Aufgaben
        2. Starten von abhängigen Aufgaben
      5. Abbrechen einer parallelen Verarbeitung von außen
      6. Fehlerbehandlung in der parallelen Verarbeitung
    4. Client/Server-Anwendungen verwenden
    5. Parallelisieren von LINQ-Abfragen
      1. Umstellen einer Abfrage auf PLINQ
      2. Steuern des Verhaltens von PLINQ
      3. Abbrechen einer Abfrage
    6. Parallele Verarbeitungen synchronisieren
      1. Die Qual der Wahl
      2. Grundregeln der Synchronisation
        1. Erstellen Sie kleine gesperrte Codeabschnitte
        2. Sperren unter allen Umständen aufheben
        3. Deadlocks mit Timeouts vermeiden
        4. Reichweite einer Sperre
        5. Kapseln von Synchronisationen
      3. Synchronisieren mit sprachintegrierten Mitteln
        1. Der Modifizierer volatile
        2. lock()-Anweisung
      4. Synchronisieren mit Mitteln der BCL
        1. Die Klasse Interlocked
        2. Die Klasse Monitor
        3. Die Klasse Mutex
        4. Die Klasse Semaphore
        5. Die Klasse ReaderWriterLock
        6. Die Klassen AutoResetEvent und ManualResetEvent
    7. Nutzung der BCL für die parallele Verarbeitung
      1. Nutzung von ICollection realisierenden Auflistungsklassen
      2. Nutzung der Techniken für grafische Benutzerschnittstellen
      3. Nutzung der Techniken für Client/Server-Anwendungen
    8. Fallen der parallelen Programmierung
      1. Vorsicht vor unbewusstem Multithreading
      2. Parallelisieren lohnt sich nicht immer
      3. Parallelisieren ist nicht immer schneller
      4. In parallelen Verarbeitungen Aufrufe zu nicht threadsicheren Methoden verhindern
      5. Parallelen Overkill verhindern
      6. Vorsicht vor threadaffinen Mechanismen
      7. Wahl der richtigen Synchronisation
    9. Multithreading und Visual Studio-Debugging
      1. Verhalten von Visual Studio für das Debugging
      2. Visual Studio-Fenster Threads
      3. Visual Studio-Fenster Parallel Tasks
  11. 8. Reflexion
    1. Grundlagen der Reflexion
    2. Laden von Assemblys
    3. Auf Elemente in einer Assembly zugreifen
    4. Typen suchen und nutzen
      1. Suchen von Elementen in Containern (BindingFlags)
      2. Objekte mit Reflexion erstellen und Methoden nutzen
      3. Felder und Eigenschaften mit Reflexion verarbeiten
      4. Ereignisse mit Reflexion nutzen
    5. Eine Assembly zur Laufzeit herstellen
      1. Code zur Laufzeit kompilieren
      2. Code aus einer Zeichenfolge erzeugen
      3. Code mithilfe von CodeDom herstellen
        1. Statische Klassen in C#
        2. foreach-Schleife in C#
  12. 9. Globalisierung und Lokalisierung von Anwendungen
    1. Herausforderungen der verschiedenen Kulturen
      1. Die Sprache
      2. Formatieren von Informationen
      3. Sortieren von Ausdrücken
      4. Aufpassen bei Bildern
      5. Farben verwenden
      6. Formate und Darstellungen
    2. Voraussetzungen für die Globalisierung
      1. Verwenden Sie keine fest codierten Zeichenfolgen
      2. Vermeiden von festen Zeichenfolgenzusammensetzungen
      3. Einfache Sprache ohne Slang
      4. Textausgaben in der Benutzeroberfläche großzügig bemessen
      5. Symbole allgemein auslegen
      6. Formatierungen
      7. Datenformate
      8. Eingaben von Daten und Plausibilisierungen
      9. Spezifische Regeln der eingesetzten Technologie
    3. Grundlagen der Lokalisierung
      1. Die Klasse CultureInfo
      2. Kulturspezifische Formatierungen vornehmen
      3. Kulturspezifische Daten variieren
        1. Auslagern von Daten in Ressourcen
        2. Ansprechen von ausgelagerten Daten
        3. Erstellen von Satellitenassemblys
        4. Installieren und Ansprechen von Satellitenassemblys
      4. Spezifische Verwendung des Ressourcenmanagers
    4. Sprachversionen von .NET
  13. A. Entwicklungswerkzeuge
    1. Werkzeuge von .NET
    2. Werkzeuge von Visual Studio
  14. B. Dokumentieren von Quellcode
    1. Übersicht über die XML-Tags für die Kommentierung
    2. Tag-Beispiele
      1. <summary>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      2. <remarks>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      3. <param>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      4. <paramref>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      5. <returns>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      6. <value>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      7. <exception>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      8. <c>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      9. <code>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      10. <example>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      11. <list>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      12. <see>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      13. <seealso>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      14. <para>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      15. <typeparam>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      16. <typeparamref>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      17. <include>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
      18. <permission>
        1. Allgemeine Verwendung
        2. Syntax
        3. Beispiel
  15. C. Zeichensatz
    1. UTF-8 Zeichensatz
  16. D. Codierungen der Kulturen
    1. Übersicht der Kulturnamen und LCID
  17. E. Rolf Wenger – zur Person
  18. Stichwortverzeichnis