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

Microsoft Visual C# 2012 - Das Entwicklerbuch. Mit einem ausführlichen Teil zur Erstellung von Windows Store Apps

Book Description

Das umfassende Arbeitsbuch für die Programmierung mit Visual C# 2012. Inkl. WPF und Erstellung von Windows Store-Apps

Table of Contents

  1. Microsoft Visual C# 2012 – Das Entwicklerbuch
  2. A Note Regarding Supplemental Files
  3. Einleitung
    1. Zielgruppe
    2. Aufbau des Buchs
    3. Die Beispielsammlung zu diesem Buch
    4. Die Visual Studio 2012-Edition auf der beiliegenden Buch-DVD
    5. Korrekturen und Kommentare
  4. I. Einführung in .NET 4.5 und Visual C# 2012
    1. 1. Das .NET Framework
      1. Historie
      2. Bausteine des .NET Frameworks
        1. Common Language Infrastructure
        2. Common Language Runtime
        3. Common Intermediate Language
        4. Just-In-Time-Compiler
      3. Assemblys
        1. Ausführungsmodell für Assemblys
      4. .NET Framework und die Windows Runtime
    2. 2. Visual Studio 2012
      1. Visual Studio
        1. Geschichte
        2. Visual Studio 2012, .NET Framework 4.5 und C#
        3. Arbeiten in der Entwicklungsumgebung
          1. Die Startseite
          2. Software-Erstellung
          3. 1. Schritt: Projekt anlegen
          4. 2. Schritt: Quelltexte bearbeiten
          5. 3. Schritt: Projekt erstellen
          6. 4. Schritt: Projekt testen
          7. RAD-Entwicklung
          8. Testen, analysieren, debuggen
          9. Veröffentlichung und Installation
          10. Anpassbarkeit
      2. Die Projektverwaltung
        1. Übersicht
        2. Projektmappen
          1. Projekte und Projektmappen
          2. Der Projektmappen-Explorer
          3. Die Dateien-Vorschau
          4. Das Festplatten-Abbild
          5. Die wichtigsten Projektdateien
        3. Startprojekte, Verweise und Projektabhängigkeiten
          1. Who’s first?
          2. Verweise
          3. Abhängigkeiten
        4. Eigene Projektvorlagen
      3. Der Code-Editor
        1. Kleine Annehmlichkeiten
        2. IntelliSense
          1. QuickInfo
          2. Moduswechsel, Deaktivierung und expliziter Aufruf
        3. using-Smarttag
        4. Umschließung
        5. Codeausschnitte
        6. Umgestaltung
      4. Erstellung
        1. MSBuild
        2. Build-Konfigurationen
      5. Konfiguration
        1. Umgebungseinstellungen
        2. Tools/Optionen
          1. Mit letztem Projekt statt mit Startseite starten
          2. Anzahl der zuletzt geöffneten Projekte
          3. Tastenkombinationen
          4. Einzüge im Editor
          5. Fehlerunterstreichung deaktivieren
        3. Externe Tools einrichten
      6. Fensterverwaltung
        1. Die Andock-Hilfe
        2. Die Pinnnadel
        3. Der IDE-Navigator
      7. Navigation
        1. Suchen
        2. Zur Definition wechseln
        3. Klassenansicht und Objektkatalog
        4. Aufrufhierarchie
      8. Hilfe
        1. Übersicht
        2. Lokal oder Online
        3. Die Online-Hilfe
          1. Die C#-Referenz und die Bibliotheksdokumentation
        4. Die lokale Hilfe
    3. 3. Die ersten Programme
      1. Konsolenanwendungen
        1. Schritt 1: Projekt anlegen
        2. Schritt 2: Quelltext bearbeiten
        3. Schritt 3: Kompilieren
        4. Schritt 4: Ausführen
      2. GUI-Anwendungen
        1. Schritt 1: Projekt anlegen
        2. Schritt 2: Formular bearbeiten
        3. Schritt 3: Kompilieren
        4. Schritt 4: Ausführen
    4. 4. Stilkonventionen
      1. Bezeichner
      2. Konventionen
      3. Blöcke
  5. II. C#-Grundlagen
    1. 5. Anatomie eines C#-Programms
      1. Programmaufbau
        1. Klassen
        2. Eintrittspunkt Main()
          1. Rückgabewert und Batch-Dateien
          2. Parameter und Befehlszeilenargumente
      2. using-Direktive und Framework-Klassen
        1. Ein- und Ausgabe
          1. Ausgabe
          2. Eingabe
        2. Kommentare
          1. Einzeilige Kommentare
          2. Mehrzeilige Kommentare
          3. Dokumentationskommentare
      3. Dateien und Assemblys
        1. Klassen und Dateien
        2. Dateien und Assemblys
          1. Anwendungen aus einzelnen Dateien erstellen
          2. Anwendungen aus mehreren Dateien erstellen
          3. Bibliotheken und andere Zieltypen erstellen
          4. Bibliotheken in Anwendungen verwenden
      4. Imperative Programmierung in C#
        1. Daten und Datentypen
        2. Literale und Variablen
        3. Operatoren und Ausdrücke
        4. Anweisungen
          1. Blöcke
          2. Verzweigungen
          3. Schleifen
        5. Funktionen (Methoden)
      5. Objektorientierte Programmierung in C#
        1. Wie sind OOP-Objekte beschaffen?
        2. Objekte und Klassen
          1. Die Klassendefinition
          2. Klassen und Objekte
          3. Die Objekterzeugung
          4. Klassen sind Verweistypen
          5. Der Konstruktor
          6. Programmieren mit Objekten
        3. Die Klasse als Zentrum der objektorientierten Programmierung
          1. Abgeschlossenheit
          2. Sichere Verwendung
          3. Kapselung
        4. Konzepte, die auf der Klasse aufbauen
          1. Modularität
          2. Vererbung
          3. Polymorphie
        5. Die Klasse als Funktionensammlung
    2. 6. Variablen, Daten und Typen
      1. Das C#-Datenmodell
        1. Datenrepräsentation
        2. Typisierung
        3. Wert- und Verweistypen
          1. Programmierung
          2. Übersicht
        4. Erweiterbarkeit
      2. Literale
      3. Variablen
        1. Definition
        2. Initialisierung
        3. Eindeutige Zuweisung
          1. Eindeutige Zuweisung für lokale Variablen
          2. Eindeutige Zuweisung für Felder
        4. Gültigkeitsbereiche
      4. Konstanten
      5. Typen: Primitive Typen
        1. Der bool-Typ
        2. Ganzzahlige Typen
          1. Ein Lob auf den Datentyp int
          2. Über- und Unterlauf
        3. Gleitkommatypen
          1. Null, NaN und Infinity
          2. Signifikante Stellen und Genauigkeit
        4. Zeichen
          1. Unicode
          2. Escapesequenzen
        5. Der decimal-Typ
      6. Typen: Definierbare Typen
        1. Klassen
        2. Schnittstellen
        3. Strukturen
        4. Arrays
        5. Enumerationen (Aufzählungen)
        6. Delegaten
      7. Typen: Strings
      8. Typumwandlung und Boxing
        1. Implizite Typumwandlungen
        2. Explizite Typumwandlungen
        3. Boxing und Unboxing
    3. 7. Operatoren und Ausdrücke
      1. Operatoren und Ausdrücke
        1. Klassifizierung nach Operanden
        2. Ausdrücke
      2. Auswertungsreihenfolge
        1. Vorrang der Operatoren
        2. Assoziativität der Operatoren
        3. Operanden
        4. Klammerung
      3. Nebeneffekte und andere Fallstricke!
        1. Methodenaufrufe in Ausdrücken
        2. Teilausdruck nicht abgearbeitet
        3. Aufeinanderfolgende Operatoren
        4. Binäre numerische Erweiterungen (Promotionen)
      4. Die arithmetischen Operatoren
        1. Division und Modulo
          1. Verwendung mit Ganzzahlen
          2. Verwendung mit Gleitkommazahlen
        2. Inkrement und Dekrement
      5. Die Zuweisungsoperatoren
      6. Die relationalen Operatoren
      7. Die logischen Operatoren
        1. Logisches UND (&&, &)
        2. Logisches ODER (||, |)
        3. Logisches XOR (^)
        4. Logisches NICHT (!)
      8. Die Bit-Operatoren
        1. &, &= (bitweises UND)
        2. |, |= (bitweises ODER)
        3. ^, ^= (bitweises XOR)
        4. ~ (bitweises Komplement)
        5. << (Linksverschiebung)
        6. >> (Rechtsverschiebung)
      9. Die Operatoren für die Typidentifizierung und -umwandlung
        1. Typidentifizierung
          1. Der is-Operator
          2. Der typeof-Operator
        2. Typumwandlung
          1. Typumwandlung für Werttypen
          2. Typumwandlungen für Verweistypen
      10. Sonstige Operatoren
        1. Datenzugriff
      11. checked und unchecked
        1. Der new-Operator
        2. Der Bedingungsoperator ?:
        3. Der ??-Operator
        4. Operatoren für nicht gesicherten Code
    4. 8. Ablaufsteuerung
      1. Verzweigungen
        1. Die einfache if-Anweisung
        2. Die if...else-Verzweigung
        3. if...else-Ketten und -Verschachtelungen
          1. Der Bedingungsoperator ?:
        4. Die switch-Verzweigung
          1. Lokale Variablen in switch-Verzweigungen
          2. Fall-through-Verhalten und Unterstützung für Enumerationstypen
      2. Schleifen
        1. Die while-Schleife
          1. Verwendung der Schleifenvariable im Anweisungsblock
          2. Endlosschleifen
        2. Die do...while-Schleife
        3. Die for-Schleife
          1. Auslassung von Schleifenteilen
          2. Schleifenvariable in Schleifenkopf deklarieren
        4. Die foreach-Schleife für Arrays und Auflistungen
      3. Sprunganweisungen
        1. Die continue-Anweisung
        2. Die break-Anweisung
        3. Die goto-Anweisung
    5. 9. Arrays, Enumerationen und Strukturen
      1. Arrays
        1. Definition und Erzeugung
          1. Variablendefinition
          2. Array-Erzeugung
          3. Speicherbelegung für Arrays
          4. Zugriff auf Elemente
        2. Initialisierungslisten
        3. System.Array
          1. Arrays in Strings umwandeln
          2. Array-Länge bestimmen
          3. Arrays in Schleifen durchlaufen
          4. Array-Elemente löschen
          5. Arrays kopieren
          6. Ganze Arrays kopieren mit Clone()
          7. Arrays in andere Arrays einfügen mit CopyTo()
          8. Teilarrays in andere Arrays einfügen mit Array.Copy()
          9. Arrays sortieren und durchsuchen
          10. Sortieren
          11. Binäre Suche
          12. Lineare Suche
        4. Mehrdimensionale Arrays
          1. Definition
          2. Initialisierung
          3. Programmierung
        5. Arrays von Arrays
          1. Definition
          2. Initialisierung
          3. Programmierung
      2. Enumerationen
        1. Definition
        2. Verwendung
        3. Enumerationen und switch
        4. Die Klasse System.Enum
      3. Strukturen
        1. Definition
        2. Verwendung
        3. Unterschiede zwischen Strukturen und Klassen
  6. III. Objektorientierte Programmierung in C#
    1. 10. Klassen
      1. Die Klassendefinition
        1. Zugriff auf Klasse steuern
        2. Zugriff auf Member steuern
        3. Spezielle Klassen
        4. Partielle Klassen
      2. Konstanten
      3. Felder
        1. Definition
          1. Initialisierung
          2. Modifizierer
        2. Instanzfelder
        3. Statische Felder
          1. Initialisierung
          2. Verwendung
          3. Statische Felder als gemeinsamer Speicher für die Objekte einer Klasse
          4. Statische Felder als globale Konstanten oder Variablen
      4. Methoden
        1. Allgemeines
          1. Modifizierer
          2. Implementierung und Aufruf
        2. Instanzmethoden und this
          1. this verwenden
        3. Statische Methoden
          1. Statische Methoden und Konstruktoren
        4. Datenaustausch
          1. Parameter
          2. Wert- und Referenzparameter
          3. Ausgabeparameter (out)
          4. Arrays als Parameter
          5. Variable Parameterlisten (params)
          6. Rückgabewert
          7. Methoden vorzeitig beenden
        5. Rekursion
        6. Überladung
          1. Warum Überladung?
          2. Auflösung der Überladung
          3. Überladene Methoden aufeinander zurückführen
      5. Eigenschaften
        1. Nur-Lesen- und Nur-Schreiben-Eigenschaften
        2. Eigenschaften ohne private-Feld
        3. Unterschiedliche Modifizierer für Get und Set
      6. Konstruktoren
        1. Klassen ohne selbst definierten Konstruktor
        2. Der Standardkonstruktor
        3. Überladene Konstruktoren
          1. this in der Konstruktordeklaration
        4. Statische Konstruktoren
      7. Destruktoren
        1. Aufruf
        2. Eigener Destruktor
      8. Verschachtelte Typdefinitionen
        1. Zugriff aus anderen Klassen
    2. 11. Schnittstellen
      1. Vertragsbasierte Programmierung
        1. Modell 1: Schnittstellengestützte Methoden
          1. Der Vertrag
          2. Der Vertragsanbieter
          3. Der Vertragsnehmer
        2. Modell 2: Schnittstellen als Labels für Klassen
      2. Schnittstellen definieren
        1. Schnittstellen-Member
        2. Schnittstellenvererbung
      3. Schnittstellen implementieren
        1. Die Dokumentation ist wichtig (IComparable-Beispiel)
        2. Schnittstellen-Member verbergen
      4. Namenskonflikte in Schnittstellen lösen
    3. 12. Vererbung, Polymorphie und Klassen-Design
      1. Vererbung
        1. Das Prinzip der Vererbung
          1. Der grundlegende Mechanismus
          2. Vererbung kontra Komposition
          3. Einige wichtige Fakten
        2. Geerbte Member
          1. Geerbte Elemente bilden Unterobjekte
          2. Zugriff auf geerbte Member
          3. Konstruktor und Basisklassenkonstruktor
          4. Ausführung des Basisklassenkonstruktors
          5. Explizite Auswahl eines Basisklassenkonstruktors
          6. Überladen, verdecken, überschreiben
          7. Verdeckung
          8. Überladung
          9. Überschreibung
        3. Die oberste Basisklasse Object
          1. Vorteile für die Programmierung
          2. Die Methoden von Object
        4. Vererbung über Assembly- und Sprachgrenzen hinweg
          1. Ableitung von Klassen anderer .NET-Sprachen
          2. Common Language Specification (CLS) und Common Type System (CTS)
          3. Eine CLS-kompatible Visual Basic-Klasse
          4. Die C#-Anwendung
      2. Polymorphie
        1. Grundprinzip und Implementierung
          1. Polymorphie durch Vererbung
          2. Polymorphie durch Schnittstellen
        2. Dynamische und statische Bindung
          1. Statische Bindung
          2. Dynamische Bindung
          3. Am weitesten abgeleitete Implementierung
          4. Verwendung von new, virtual und override
          5. Virtuelle Methoden versiegeln
        3. Generische Programmierung
          1. Mit Polymorphie planen
          2. Basisklassen-Arrays
          3. Basisklassenparameter
        4. Typidentifizierung zur Laufzeit
        5. Abstrakte Klassen
          1. Abstrakte Member
          2. Abstrakte Klassen
          3. Abstrakte Klassen kontra Schnittstellen
      3. Der Klassen-Designer
        1. Klassendiagramme erzeugen
        2. Klassendiagramme bearbeiten
          1. Typen hinzufügen
          2. Bestehende Typen
          3. Neue Typen anlegen
          4. Vererbung, Schnittstellenimplementierung und Komposition
          5. Member bearbeiten
          6. Darstellung anpassen
        3. Projekt-Dokumentationen erstellen
        4. Analyse-Spezifikationen umsetzen
        5. Projekte pflegen
    4. 13. Indexer, Enumeratoren und Iteratoren
      1. Indexer
        1. Syntax
        2. Beispiel
      2. Enumeratoren
        1. Funktionsweise
        2. Implementierung
          1. IEnumerable
          2. IEnumerator
      3. Iteratoren
        1. foreach-Unterstützung durch Iteratoren
        2. Klassen mit mehreren (benannten) Iteratoren
        3. Eigene Lösungen, die auf IEnumerable basieren
    5. 14. Operatorenüberladung
      1. Syntax
      2. Regeln
        1. Überladbare Operatoren
        2. Regeln für die Überladung
      3. Fallbeispiel: Unäre Inkrement- und Dekrement-Operatoren
      4. Fallbeispiel: Binäre mathematische Operatoren
      5. Fallbeispiel: Relationale Operatoren
      6. Fallbeispiel: Konvertierungsoperatoren
      7. Fallbeispiel: true und false
    6. 15. Ausnahmebehandlung
      1. Konzeption und Zielsetzung
        1. Kein Weg zurück
        2. Behandeln von Ausnahmen
      2. Das try...catch-Grundgerüst
        1. Ausnahmen abfangen
        2. Mehrere catch-Handler
        3. Ausnahmen als Informationsträger
      3. Die finally-Klausel
      4. finally-Block
      5. using-Anweisung
      6. Ausnahmen auslösen
        1. Ausnahmen weiterleiten
        2. Innere Ausnahmen
      7. Die vordefinierten Ausnahmeklassen
        1. Member der Klasse Exception
        2. CLR-generierte Ausnahmen
      8. Eigene Ausnahmeklassen schreiben
  7. IV. Fortgeschrittenes C#
    1. 16. Werttypen und Verweistypen
      1. Zwischen C++ und Smalltalk
        1. Das Werte-Modell
        2. Das Verweis-Modell
        3. Umsetzung in C++ und Smalltalk
      2. Der C#-Weg
        1. Speicherreservierung und Lebensdauer
          1. Speicherzuteilung
          2. Lebensdauer
          3. Garbage Collection
          4. Heap-Belegung
          5. Heap-Freigabe
          6. Heap-Generationen
          7. Wie werden Objekte aufgelöst?
          8. Explizites Löschen
          9. Garbage Collector, Destruktor und IDisposable
        2. Objekte kopieren
          1. Flaches und tiefes Kopieren
          2. Kopiermethoden
          3. Clone() und MemberwiseClone()
        3. Copy() und Konstruktor
        4. Objekte vergleichen
          1. Gleichheit feststellen
          2. Regeln für die Überschreibung von Equals()
          3. Überschreibung von GetHashCode()
          4. Beispiel
          5. Größenvergleiche
          6. IComparable und die Methode CompareTo()
          7. IComparer und Compare()
          8. Beispiel
        5. Boxing und Unboxing
        6. Wert- und Referenzparameter
        7. Nullfähigkeit
          1. Werttypen
        8. Nullable<T>
          1. Test auf null
      3. Zusammenfassung
    2. 17. Namespaces, Gültigkeitsbereiche und Zugriffsschutz
      1. Namespaces
        1. Namespaces definieren
          1. Verschachtelte Namespaces
          2. Globaler Namespace
          3. Namespaces und Quelltextdateien
        2. Namespaces erweitern
        3. Typen aus Namespaces verwenden
        4. using-Direktive
        5. using-Aliase
          1. ::-Operator
        6. Konfliktlösung mit Namespaces
      2. Gültigkeitsbereiche
        1. Übersicht
        2. Verdeckung
        3. Auflösung der Verdeckung
      3. Zugriffsmodifizierer im Überblick
    3. 18. Delegaten und Ereignisse
      1. Delegaten
        1. Definition
        2. Instanziierung
          1. Vereinfachte Syntax
          2. Anonyme Methoden
        3. Aufruf
        4. Delegaten als Methoden-Hooks
        5. Delegaten mit Aufruflisten
          1. Methoden entfernen
          2. Verweisparameter
      2. Ereignisse
        1. Das Prinzip
          1. Umsetzung in C#
        2. Ereignisse veröffentlichen
        3. Ereignisse abonnieren
        4. Ereignis-Argumente
          1. Der object-Parameter
          2. Der EventArgs-Parameter
          3. Benutzerdefinierte EventArgs-Klassen
    4. 19. Attribute
      1. Vordefinierte Attribute
      2. Benutzerdefinierte Attribute
        1. Benutzerdefinierte Attribut-Klasse erstellen
        2. Komponente erstellen, die mit der Attribut-Klasse arbeitet
        3. Attribut-Klasse verwenden
    5. 20. C#-Generika
      1. Einführung in Generika
      2. Generische Typen
        1. Generische Klassen
          1. Vererbung
          2. Methoden überschreiben
          3. Methoden überladen
          4. Statische Member
        2. Generische Strukturen
        3. Generische Schnittstellen
        4. Generische Delegaten und Prädikate
        5. Kovarianz und Kontravarianz
      3. Generische Methoden
        1. Aufruf
        2. Swap
      4. Einschränkungen für Typparameter
        1. Ungebundene Typen
        2. Einschränkungen
          1. Primäre Einschränkungen
          2. Sekundäre Einschränkungen
          3. Konstruktor-Einschränkung
        3. Vererbung
      5. Null, default und die Problematik der Werttypen
        1. Das Problem der Standardwerte
        2. Das Problem der Leere
          1. Verweistypen
          2. Werttypen
          3. Nullable-Typen
      6. Ein Blick hinter die Kulissen
        1. Typisierung mit Werttypen
        2. Typisierung mit Verweistypen
    6. 21. XML-basierte Dokumentierung
      1. Einführung
      2. XML-Dokumentationskommentare
        1. Die empfohlenen Tags
        2. Eigene Tags definieren
        3. Beispiele
      3. XML-Dokument erzeugen
      4. Lesbare Dokumentationsseiten
        1. Transformation mit ndoc
        2. Transformation mit eigenem XSLT-Code
          1. Beispiel und Vorlage für eine XSL-Datei
          2. Transformieren
    7. 22. Lambda-Ausdrücke
      1. Rückblick
      2. Einführung in Lambda-Ausdrücke
      3. Verwenden von Delegaten des Typs Func
      4. Prädikate und Projektionen
      5. Ausdrucksbäume
    8. 23. Spracherweiterungen
      1. Lokale Typinferenz
      2. Erweiterungsmethoden
      3. Objektinitialisierer
      4. Anonymer Typ
      5. Dynamic
      6. Ko- und Kontravarianz
      7. Optionale (oder Standard-) Parameter
      8. Benannte Argumente
      9. Verbesserte COM-Interoperabilität
      10. Asynchrone Ausführung mit async und await
        1. async und await
        2. Auf Aufgaben warten
        3. async/await und der UI-Thread
          1. Verbesserung 1: gleichzeitige Ausführung
          2. Verbesserung 2: asynchrone Ausführung mit async und await
  8. V. Nützliche .NET-Klassen
    1. 24. Strings und reguläre Ausdrücke
      1. String-Erzeugung
      2. String-Literale
        1. Escapesequenzen
        2. @-Literale
        3. Zeilenumbrüche
        4. Pooling
      3. String-Vergleiche
        1. Test auf Nutzinhalt
        2. Gleichheit und Ungleichheit
        3. Größenvergleiche
        4. Kulturunabhängige Größenvergleiche
      4. String-Manipulationen
        1. Aneinanderreihung
        2. Einfügen, Löschen, Ersetzen
        3. Suchen
        4. Zerlegen und Zusammenfügen
          1. Substring()
          2. Split()
          3. Join()
        5. Trimmen und auffüllen (Padding)
        6. Umwandeln
          1. Groß- und Kleinschreibung
          2. Konvertierung von und in andere Datentypen
          3. Umwandlung in Zeichen-Array
        7. Auf einzelne Zeichen zugreifen
        8. Kopieren
      5. Formatierung mit Platzhaltern
      6. ToString(), IFormattable und die Formatbezeichner
        1. IFormattable
          1. Formatbezeichner
          2. Benutzerdefinierte numerische Formatbezeichner
      7. String.Format() und die kombinierte Formatierung
        1. Eigene Typen mit Unterstützung für Formatbezeichner
        2. Eigene Formatierer mit IFormatProvider und ICustomFormatter
          1. Der Formatierungsmechanismus
          2. ICustomFormatter und IFormatProvider implementieren
          3. Formatieren
      8. StringBuilder
        1. String-Manipulation
        2. Kapazität
      9. Reguläre Ausdrücke
        1. Syntax regulärer Ausdrücke
          1. Zeichen und Zeichenklassen
          2. Quantifizierer
          3. Gierige Quantifizierer
          4. Gruppierung
          5. Assertionen (Anker)
        2. Suchen mit Regex und Match
          1. Stringaufbau prüfen
          2. Grep-Programm
        3. Ersetzen mit Regex
    2. 25. Streams, Dateien, XML und Serialisierung
      1. Reader und Writer
      2. Verzeichnisse
        1. Auflisten von Verzeichnissen
        2. Anlegen und Löschen von Verzeichnissen
        3. Rekursives Löschen von Dateien und Verzeichnissen
        4. Verschieben von Verzeichnissen
        5. Mit Verzeichnissen arbeiten
        6. Pfadangaben
      3. Streams
        1. Dateien schreiben
        2. Dateien lesen
        3. Die File-Klasse
        4. MemoryStream
        5. NetworkStream
        6. BufferedStream
        7. CryptoStream
        8. DeflateStream und GZipStream
        9. Asynchrones Streaming
      4. XML
        1. Allgemeines
          1. Aufbau und Terminologie eines XML-Dokuments
          2. Verfügbare APIs
        2. Programmieren mit XML
          1. Die Klasse XMLDocument
          2. Ein XML-Element hinzufügen
          3. Ein XML-Attribut hinzufügen
          4. XML-Daten lesen
          5. XML-Daten schreiben
          6. LINQ to XML
          7. Erstellen
          8. Lesen
          9. Schreiben
        3. XPath und XQuery
          1. Arbeiten mit XPath
          2. Arbeiten mit XQuery
          3. Arbeiten mit XPath und XQuery
        4. LINQ to XML
          1. XSLT-Transformation
      5. Serialisierung
        1. Formatter
        2. Serialisierung von persistenten und transienten Daten
        3. Objekte serialisieren
        4. Objekte deserialisieren
    3. 26. Auflistungen
      1. Grundlagen
        1. Die Basis-Schnittstellen
        2. Die Auflistungsklassen
      2. Die Qual der Wahl
        1. Kriterium I: Generisch oder nicht generisch
        2. Kriterium II: Eigenschaften
        3. Kriterium III: Effizienz
        4. Die Auflistungen im Vergleich
      3. Nicht generische Auflistungen
        1. ArrayList
        2. Hashtable
        3. BitArray
      4. Generische Auflistungen
        1. List
        2. Dictionary
        3. LinkedList
        4. Stack
        5. SortedSet
    4. 27. Datum, Mathematik und die Systemumgebung
      1. Datum und Uhrzeit
        1. Datum und Uhrzeit abfragen
          1. Ticks
          2. Details abfragen
        2. Datum und Uhrzeit manipulieren
        3. Formatierung
        4. Zeitzonen
        5. Kalender
        6. Zeitspannen
        7. Laufzeitmessungen
      2. Numerik
        1. Die Klasse Math
        2. Die trigonometrischen Funktionen
        3. Die Klasse BigInteger
        4. Die Klasse Complex
          1. Rechnen mit komplexen Zahlen
      3. Zufallszahlen
        1. Zufallszahlengenerator erzeugen
        2. Zufallszahlen erzeugen
      4. Systemumgebung
        1. Informationen zur Systemumgebung abfragen
        2. Umgebungsvariablen
        3. Externe Anwendungen ausführen
  9. VI. Windows Presentation Foundation
    1. 28. Einführung in WPF
      1. Grundprinzipien
        1. Ereignisbehandlung
        2. Trennung von Design und Logik
      2. Die erste WPF-Anwendung
        1. Schritt 1: WPF-Projekt anlegen
        2. WPF-Assemblys
        3. Das WPF-Grundgerüst
        4. Namespaces
        5. Anwendung und Hauptfenster
          1. Schritt 2: XAML-Datei weitergeben
          2. Schritt 3: Anwendungslogik hinzufügen
        6. Ereignisse behandeln
        7. Zugriff auf XAML-Elemente via C#-Code
          1. Schritt 4: Projekt erstellen und testen
      3. Der XAML-Designer
        1. Grundlegende Arbeitsschritte
          1. Komponenten kopieren
          2. Komponenten löschen
          3. Z-Reihenfolge
        2. Der Entwurf-Bereich
          1. Das Grid-Panel
        3. Der XAML-Bereich
          1. IntelliSense
        4. Das Eigenschaftenfenster
      4. Das WPF-Modell
        1. Zielsetzung
        2. GUI-Bibliothek
        3. Grafik-Modell
          1. Vektorgrafik statt Pixel
          2. DirectX statt Clipping
          3. Sorry, no Graphics
        4. Layout-Konzept
        5. Eigenschaften-Konzept
        6. Ereignismodell
          1. Bubbling und Tunneling
          2. Was Sie über die Ereignisbehandlung unbedingt wissen müssen
          3. Befehle
        7. Ausführungsmodelle
      5. Ressourcen
        1. Ressourcen hinzufügen
        2. Ressourcen bearbeiten
        3. Ressourcen verwenden
        4. Ressourcen entfernen
    2. 29. WPF-Fenster, -Seiten und -Steuerelemente
      1. Fenster und Seiten
        1. Fensterbasierte Anwendungen
          1. Das Hauptfenster
          2. Konfiguration
          3. Weitere Fenster aufrufen
          4. Dialogfelder
        2. Browseranwendungen
          1. Erstellung
          2. Ausführung
          3. Browserkonfiguration
          4. Seitennavigation
        3. Fensterbasierte Anwendungen mit Frames und Seiten
      2. Die Steuerelemente
        1. Die Basisklassen
        2. Übersicht
      3. Datenbindung
        1. Datenbindung zwischen Steuerelementen
        2. Datenbindung zu selbst definierten Klassen
        3. Datenbindung für Auflistungen
        4. Typkonvertierung bei der Datenbindung
      4. Menüs, Symbolleisten und Menübänder
        1. Aufbau von klassischen Menüs
        2. Ereignisbehandlung
        3. Kontextmenüs
        4. Symbolleisten
        5. Menüband (Ribbon)
          1. Anwendung vorbereiten
          2. Aufbau von Menübändern
          3. Symbolleiste für den Schnellzugriff
          4. Anwendungsmenü
          5. Registerkarten
          6. Gruppen
          7. Größenmanagement für Gruppen
          8. Ereignisbehandlung
    3. 30. Drag & Drop, Drucken und andere weiterführende Techniken
      1. Dateien öffnen und speichern
        1. Menübefehle
        2. Nicht gespeicherte Änderungen
          1. bool dirty
          2. Änderungen in Dokument
          3. Menübefehle aktivieren und deaktivieren
        3. Die Methoden zum Anlegen, Öffnen und Speichern
          1. Neu
          2. Öffnen
          3. Speichern
          4. Speichern unter
      2. Zwischenablage
        1. Die Klasse Clipboard
        2. Daten in die Zwischenablage einfügen
        3. Daten aus der Zwischenablage übernehmen
        4. Die vordefinierten Datenformate
        5. Daten in mehreren Formaten einfügen
        6. Aktivierung der Zwischenablagebefehle
      3. Drag & Drop für Dateien
      4. Suchen in Textfeldern
        1. Suchen in einer TextBox
        2. Suchen in einer RichTextBox
      5. Drucken
        1. Einführung
        2. Drucken in fünf Minuten
        3. Skaliertes ausdrucken
        4. Text eines RichTextBox-Elements drucken
      6. Sound
        1. Die vordefinierten Signaltöne
        2. WAV-Dateien abspielen
          1. Sounddateien laden und abspielen
          2. Sounddateien asynchron laden
    4. 31. Grafik
      1. Grundtechniken
      2. Transformationen
      3. 3D-Ansichten
        1. Die Benutzeroberfläche
        2. Die Objekte
        3. Die Szenerie
        4. Kamera verschieben
        5. Zoomen
      4. Bilder
        1. Bilder in Image-Element einpassen
        2. Bilder in optimaler Größe laden
        3. Thumbnails
      5. Animation
    5. 32. XAML
      1. Grundlagen
        1. XAML zur Laufzeit laden
        2. Eigene Klassen instanziieren
        3. Klassen definieren
      2. Namespaces
        1. CLR-Namespaces
        2. XML-Namespaces
      3. Elemente
        1. Elementinhalt
        2. Eigenschaften als Elemente
      4. Attribute
        1. Typkonvertierung
        2. Attached-Eigenschaften
        3. Markuperweiterungen (Markup Extensions)
        4. Die Attribute (und Elemente) des XAML-Namespace
      5. Ressourcen, Stile und Template-Vorlagen
        1. Ressourcen definieren
        2. Ressourcen verwenden
        3. Stile
        4. Trigger
        5. Template-Vorlagen
      6. WPF-Ausführungsmodelle
  10. VII. Windows Store-Apps
    1. 33. Einführung in Windows Store-Apps
      1. Einführung
        1. Neues Design
        2. Neue Laufzeitumgebung
        3. Einpassung in die neue Windows-Benutzeroberfläche
      2. Die erste Windows Store-App
        1. Entwicklerlizenz
          1. Schritt 1: Projekt anlegen
        2. Die Projektdateien
        3. MainPage.xaml
        4. XAML-Superschnellkurs
        5. MainPage.xaml.cs
        6. App.xaml
        7. App.xaml.cs
        8. Sonstige Projektdateien
        9. Startseite austauschen
          1. Schritt 2: Aufbau der Oberfläche
          2. Zentriertes Layout mit Grid
          3. Steuerelemente einfügen
          4. Bilder in ein Projekt aufnehmen und anzeigen
          5. Schritt 3: Ereignisbehandlung
          6. Vorbereitende Maßnahmen
          7. Ereignisse mit Behandlungsmethoden verbinden
          8. Eigenschaftenfenster
          9. XAML-Ansicht
          10. Zugriff auf XAML-Elemente von C#-Code aus
          11. Asynchrone Programmierung zur Vermeidung von App-Abstürzen
          12. Wichtige Ereignisse
          13. Direkte Überschreibung virtueller Ereignismethoden in abgeleiteten Klassen
          14. Schritt 4: Kompilieren und ausführen
          15. Schritt 5: Testen und debuggen
    2. 34. Layouts und Steuerelemente
      1. Seitenlayout
        1. Layouting für App-Seiten
        2. Layoutcontainer
        3. Seitentitel
        4. Seitenhintergrund
          1. Bilder als Hintergrund
        5. Animationen
        6. Bilder für unterschiedliche DPI-Auflösungen
        7. Anpassung an Snap-Modus, Quer- und Hochformat
          1. Flexible Designs
          2. Zentrierung
          3. Platzierung mit Layoutcontainer
          4. Verankerung und Ränder
          5. Testen
          6. Individuelle Layouts für Snap-Modus, Hoch- und Querformat
          7. Die vordefinierten Ansichten
          8. Vorgehensweise
          9. ViewState ermitteln
          10. Layout via C# ändern
          11. Layout via XAML ändern
      2. Steuerelemente
        1. Die Basisklassen
        2. Verwendung von ContentControl-Elementen
        3. Verwendung von ItemsControl-Elementen (Listensteuerelemente)
          1. Listensteuerelemente mit Elementen füllen
          2. Datenbindung
          3. Darstellung
          4. Direkte Manipulation des Erscheinungsbilds
          5. Steuerung der Präsentation durch das Listensteuerelement
          6. Ereignisbehandlung
        4. Übersicht
      3. Befehlsleisten
        1. Layout
        2. Die Befehlsleisten-Schaltflächen
          1. Vordefinierte Schaltflächen
          2. Vordefinierte Schaltflächen anpassen
          3. Eigene Schaltflächen
        3. Einbindung in eine App
        4. Kontextabhängige Befehle ein- und ausblenden
      4. Kacheln und Begrüßungsbildschirm
        1. Breite Kachel
        2. Live-Kacheln
          1. Schritt 1: Layout aussuchen
          2. Schritt 2: Entscheiden, wo was in die Kachel geschrieben wird
          3. Schritt 3: Die Kachel aktualisieren
    3. 35. Spezielle Techniken
      1. Lebenszyklus
        1. Der Zyklus im Detail
        2. Auf Zyklusereignisse reagieren
          1. Den letzten App-Zustand wiederherstellen
          2. App-Zustand speichern und wiederherstellen
          3. Das Resuming-Ereignis
      2. Mehrere Seiten
        1. Frame und die LayoutAwarePage-Vorlagen
        2. Seitennavigation
          1. Parameter übergeben
        3. Teilseiten ein- und ausblenden
      3. Benachrichtigungen
      4. Debugausgaben im Ausgabefenster
      5. Dateien und Dateiauswahl
        1. Das Grundkonzept
          1. App-Verzeichnisse
          2. Funktionen (Capabilities)
        2. Dateien öffnen
        3. Dateien speichern
        4. FileOpenPicker und FileSavePicker
          1. FileOpenPicker
          2. FileSavePicker
      6. Drucken (Charm)
        1. Druckregistrierung
        2. Inhalt eines UI-Elements drucken
        3. Die Druckvorschau unterstützen
        4. Druckeinstellungen unterstützen
      7. Einstellungen (Charm)
        1. Schritt 1: Aufruf des Einstellungen-Charms erkennen
        2. Schritt 2: Links zum Aufruf der Einstellungen-Leisten einfügen
        3. Schritt 3: Die Einstellungen-Leiste anlegen
        4. Schritt 4: Die Einstellungen-Leiste einblenden
        5. Schritt 5: Ereignisbehandlung
      8. Suchvertrag (Charm)
        1. Den Suchvertrag abschließen
        2. Die Suchereignisse
        3. Suche für eine aktive App
        4. Suche für eine nicht aktive App
      9. Geolokation
        1. Erweiterungen von Rechten
        2. Auswertung der Standortdaten
    4. 36. Von der Idee zum Windows Store
      1. Die Idee
      2. Die Benutzeroberfläche
        1. Die Spielfläche
        2. Die Ansichten (VisualStates)
          1. Snapped-Ansicht
          2. Hochformat
          3. Restliche Formate
      3. Implementierung
        1. Die Klasse Question
        2. GameLogic
        3. Verbesserungen
      4. Aufbereitung für die Weitergabe
        1. App-Paket erstellen
        2. Das Paket auf dem Zielrechner installieren
      5. Aufbereitung für den Windows Store
        1. Testen
        2. Windows Store-Auftritt planen
        3. Entwickler-Konto anlegen
        4. Veröffentlichen
  11. VIII. Multithreading
    1. 37. Prozesse
      1. Prozesse
        1. Die Process-Klasse
        2. Prozess starten
        3. Prozess binden
        4. Prozess beenden
        5. Prozessverhalten und -mechanismen verwalten
    2. 38. Thread-Programmierung
      1. Starten von Threads
        1. Einfachen Thread starten
        2. Starten von Threads in einer anderen Anwendungsdomäne
        3. Hintergrundthreads
      2. Arbeiten mit Threads
        1. Priorisieren von Threads
        2. Anhalten und Beenden von Threads
      3. Synchronisierung
        1. Monitor
        2. Interlock
        3. Mutex
      4. Pooling
      5. Timer
    3. 39. Parallele Programmierung
      1. Einführung
        1. Anwendungen mit einem einzigen Thread
        2. Anwendungen mit mehreren Threads
        3. Vereinfachte parallele Programmierung
      2. Die Task Parallel Library (TPL)
        1. TPL für optimale Prozessorauslastung durch Parallelisierung
        2. TPL als Threadersatz zur Erhaltung der Reaktionsfähigkeit
        3. Code für die parallele Ausführung vorbereiten
          1. Kein Parameter, kein Rückgabetyp
          2. Parameter, kein Rückgabetyp
          3. Kein Parameter, Rückgabetyp
          4. Parameter und Rückgabetyp
      3. Aufgabenparallelität
        1. Synchronisierte Parallelisierung mit Parallel
        2. Asynchrone Parallelisierung mit TaskFactory und Task
          1. Ausführung von void-Methoden mit Object-Parameter
          2. Synchronisierung zwischen aktuellem Thread und abgesetzten Threads
          3. Konfiguration
        3. Ausnahmenbehandlung
          1. ContinueWith()-Aufgaben für die Ausnahmebehandlung
          2. Ausnahmen mit Wait-Methoden abfangen
        4. Aufgaben vorzeitig abbrechen
      4. Datenparallelität
        1. Parallel.For und Parallel.ForEach
        2. Ausführung mit threadlokalen Variablen
        3. Schleifen abbrechen
        4. Threadsichere Auflistungen
  12. IX. Datenbanken
    1. 40. ADO.NET
      1. Architektur und Technologie
        1. Technologie
        2. Architektur
      2. Klassen in ADO.NET
      3. Connection-Klasse und Pooling
      4. Command-Klasse
        1. Arbeiten mit einer SQL-Abfrage
        2. Arbeiten mit parametrisierten Abfragen
        3. Arbeiten mit gespeicherten Prozeduren
        4. Anlegen einer gespeicherten Prozedur
        5. Schreiben und Testen einer gespeicherten Prozedur
        6. Zugriff auf gespeicherte Prozeduren aus Anwendungen heraus
        7. Methoden zum Ausführen der Befehle
      5. DataReader-Klasse
      6. DataAdapter- und DataSet-Klasse
        1. XML-Daten und XML-Schema
        2. Laden von XML-Daten und XML-Schema-Definition
        3. Manipulieren von Daten im DataSet und der Datenquelle
        4. Relationen zwischen Datentabellen erzeugen
        5. DataTable-Klasse
        6. DataTableReader
        7. DataView-Klasse
        8. Transaktionen
    2. 41. CLR-Programmierung mit dem SQL Server
      1. Die CLR und SQL Server 2012
      2. Anlegen eines SQL Server-Datenbankprojekts
      3. Erstellen einer benutzerdefinierten Funktion
        1. Erstellen einer gespeicherten Prozedur
        2. Erstellen eines Aggregats
        3. Erstellen eines Triggers
        4. Erstellen eines benutzerdefinierten Typs
  13. X. WCF und LINQ
    1. 42. Einführung in die WCF
      1. Konzepte und Grundbegriffe
        1. Client/Server
        2. Endpunkte
          1. Adresse
          2. Bindung
          3. basicHttpBinding
          4. WSHttpBinding
          5. netTcpBinding
          6. netNamedPipeBinding
          7. netPeerTcpBinding
          8. netMsmqBinding
          9. CustomBinding
          10. Die Qual der Wahl
          11. Dienstvertrag (Contract)
        3. Metadaten
        4. Proxyklassen
        5. Channel
        6. Sicherheit
          1. Sicherheit auf der Transportebene
          2. Sicherheit auf der Nachrichtenebene
          3. TransportWithMessageCredential
      2. Erste praktische Schritte zum WCF-Dienst
        1. WCF-Projekt erstellen
          1. WCF-Dienstanwendung
      3. WSDL
      4. Der Client
        1. WCF-Dienstbibliotheken
        2. Dienstanwendung für WCF-Workflows
      5. Entwerfen und Implementieren eines Diensts
        1. Entwerfen von Dienstverträgen
        2. Zusammengesetzte Datentypen
        3. Aufzählungen
        4. Ausnahmen
    2. 43. LINQ
      1. Grundlagen der LINQ-Operatoren
        1. Projektionsoperatoren
          1. Select-Operator
          2. SelectMany-Operator
        2. Restriktionsoperator
        3. Sortierungsoperatoren
          1. OrderBy
          2. ThenBy- und ThenByDescending-Operator
          3. Reverse-Operator
        4. Gruppierungsoperatoren
          1. GroupBy-Operator
        5. Verknüpfungsoperatoren
          1. Join-Operator
          2. GroupJoin-Operator
        6. Set-Operatoren
          1. Distinct-Operator
          2. Union-Operator
          3. Intersect- und Except-Operator
        7. Aggregatoperatoren
          1. Count-Operator
          2. Sum-Operator
          3. Min- und Max-Operator
          4. Average-Operator
        8. Generierungsoperatoren
          1. DefaultIfEmpty- und Empty-Operator
          2. Range-Operator
          3. Repeat-Operator
        9. Quantifizierungsoperatoren
          1. Any-Operator
          2. All-Operator
          3. Contains-Operator
        10. Partitionierungsoperatoren
          1. Take-Operator
          2. TakeWhile-Operator
          3. Skip-Operator
          4. SkipWhile-Operator
        11. Elementoperatoren
          1. ElementAt- und ElementAtOrDefault-Operator
          2. First- und FirstOrDefault-Operator
          3. Last- und LastOrDefault-Operator
          4. Single- und SingleOrDefault-Operator
      2. LINQ to Objects
      3. LINQ to Entities
      4. LINQ to DataSet
      5. LINQ to XML
        1. Erzeugen von XML-Dokumenten über die LINQ to XML-API
        2. Lesen von XML-Dokumenten
        3. Ändern von abgefragten XML-Daten
  14. XI. Anhänge
    1. A. Schlüsselwörter
    2. B. C#-Referenz
      1. Primitive Typen
      2. Strings
        1. Literale
        2. Operatoren
        3. Escapesequenzen
        4. Formatierung mit ToString()
      3. Operatoren
      4. Ablaufsteuerung
        1. Verzweigungen
        2. Schleifen
        3. goto-Sprünge
      5. Exception-Behandlung
      6. Enumerationen
      7. Arrays
        1. Einfache Arrays
        2. Mehrdimensionale Arrays
        3. Arrays von Arrays
        4. Programmierung
      8. Schnittstellen
      9. Delegaten
      10. Ereignisse
      11. Strukturen
      12. Klassen
        1. Definition
        2. Vererbung
        3. Partielle Klassen
      13. Generika
        1. Generische Klassen mit einem Typparameter
        2. Generische Klassen mit zwei Typparametern
        3. Generische Methoden
    3. C. Debuggen mit Visual Studio
      1. Der integrierte Debugger
        1. Vorbereitung für das Debuggen
        2. Anwendungen im Debugger ausführen
          1. An externe oder laufende Anwendungen anhängen
          2. Befehlszeilenargumente
          3. DLLs debuggen
          4. Debug-Sitzung beenden
        3. Haltepunkte und Einzelschrittausführung
          1. Haltepunkte setzen
          2. Haltepunkte deaktivieren oder löschen
          3. Haltepunkte konfigurieren
          4. Schrittweise Programmausführung
        4. Die Debug-Fenster
          1. Ausgabe
          2. Überwachen
          3. Auto und Lokal
          4. Direktfenster
          5. Visual Studio-Befehle
          6. Aufrufliste
          7. Die Fenster Threads, Module und Prozesse
          8. Arbeitsspeicher
          9. Disassembly
          10. Register
      2. Debuggen im Code-Editor
        1. DataTip (DatenInfo)
        2. Schnellüberwachung
        3. Bearbeiten und Fortfahren (Edit & Continue)
      3. Parallele Programme
        1. Das Threads-Fenster
        2. Das Fenster Parallele Aufgaben
        3. Das Fenster Parallele Stapel
      4. Manuelle Debug-Techniken
        1. Meldungsfenster
        2. Bedingte Kompilierung
        3. Assert()-Methode
        4. Conditional-Attribut
          1. Präprozessor-Direktiven
  15. D. Die Autoren
    1. Dirk Louis
    2. Thorsten Kansy
    3. Shinja Strasser
  16. Stichwortverzeichnis
  17. Impressum