Microsoft Visual Basic 2010 - Das Entwicklerbuch

Table of contents

1. A Note Regarding Supplemental Files
2. Vorwort
3. Einleitung
   1. Danksagungen
      1. von Sarika Calla
      2. von Klaus Löffelmann
   2. Support
4. I. Der Einstieg in Sprache und Entwicklungs-Werkzeuge
   1. 1. Einführung
      1. Einführung
         1. Was brauchen Sie, um mit diesem Buch zu arbeiten?
            1. Die preiswerte Alternative: die Express Editions
      2. Die Begleitdateien zum Buch
   2. 2. »Symbolischer Allzweckbefehlscode für Anfänger«
      1. Visual Studio das erste Mal starten
      2. Konsolenanwendungen (Console Applications)
         1. Anwendung starten
      3. Anatomie eines (Visual Basic-)Programms
      4. Programmstart mit der Main-Methode
      5. Methoden mit und ohne Rückgabewerte
         1. Definieren von Methoden ohne Rückgabewerte mit Sub
         2. Definieren von Methoden mit Rückgabewerten mit Function
      6. Deklaration von Variablen
         1. Nullables
      7. Ausdrücke und Variablendefinitionen
         1. Gleichzeitiges Deklarieren und Definieren von Variablen
         2. Komplexe Ausdrücke
         3. Boolesche Ausdrücke
      8. Was sind Objekte im Unterschied zu »normalen« Datentypen?
         1. Ableiten von Objekten und abstrakten Objekten
      9. Eigenschaften
      10. Typliterale zur Typfestlegung von Konstanten
      11. Typsicherheit
          1. Lokaler Typrückschluss
      12. Arrays und Auflistungen
      13. Programmcode bedingt ausführen
          1. If ... Then ... Else ... ElseIf ... End If
          2. Logische Operatoren And, Or, Xor, Not
             1. Beispiele
          3. Vergleichsoperatoren, die boolesche Ergebnisse zurückliefern
             1. Kurzschlussauswertungen mit OrElse und AndAlso
          4. Select ... Case ... End Select
          5. If-Operator und IIf-Funktion
      14. Schleifen
          1. For ... Next-Schleifen
             1. Verschachteln von For-Schleifen
          2. For Each-Schleifen
          3. Do ... Loop- und While ... End While-Schleifen
          4. Exit – Vorzeitiges Verlassen von Schleifen
          5. Continue – Vorzeitige Schleifenwiederholung
      15. Verkürzter Zugriff auf Objekteigenschaften und -methoden mit With ... End With
      16. Gültigkeitsbereiche (Scope) von Variablen
      17. Die Operatoren += und –= und ihre Verwandten
          1. Die Bitverschiebeoperatoren << und >>
      18. Fehlerbehandlung im Code
          1. Achtung! Visual Basic 6.0/VBA-Code!
          2. Elegantes Fehlerabfangen mit Try/Catch/Finally
             1. Das Ausnahmenabfangen ist nicht nur auf einen Ausnahmetyp beschränkt
             2. Und wozu dient Finally?
   3. 3. Einführung in .NET Framework
      1. Was ist .NET und aus was besteht es?
      2. Was ist eine Assembly?
         1. Was ist ein Namespace?
            1. Einbinden von Namespaces und Assemblys in Codedateien und Projekten am Praxisbeispiel
         2. Was versteckt sich hinter CLR (Common Language Runtime) und CLI (Common Language Infrastructure)?
         3. Was ist die FCL (Framework Class Library) und was die BCL (Base Class Library)?
         4. Was ist das CTS (Common Type System)?
         5. Was ist CIL/MSIL (Microsoft Intermediate Language) und wozu dient der JITter?
   4. 4. Rundgang durch Visual Studio
      1. Einführung
      2. Visual Studio das erste Mal starten – das Profil auswählen
      3. Die Startseite – der Ausgangsort für Ihre Entwicklungsaufgaben
         1. Mit der Entwicklung beginnen – neue Projekte erstellen
            1. Vorlagen verwalten
            2. Vorlagen ändern
      4. Aus früheren Visual Studio-Versionen auf Visual Studio 2010 migrieren
         1. Mit Visual Studio 2003-2008 erstellte Projekte aktualisieren
            1. Dinge, die beim Konvertieren von Projekten nach Visual Studio 2010 zu beachten sind
         2. Visual Basic 6.0-Anwendungen auf Visual Studio 2010 aktualisieren
      5. Anwendungen für mehrere .NET Framework-Versionen (Multizielversionen) unter Visual Studio 2010
         1. Die Geschichte der Multizielversionen
            1. Multizielversionen für neue Projekte
         2. Die .NET Framework-Zielversion für Anwendungen ändern
            1. Profile verstehen
            2. Das Clientprofil ist Vorgabe für Clientprojekte
         3. Wissenswertes über Multizielversionen
         4. Grenzen der Multizielversionen
      6. Ein näherer Blick auf die neue und verbesserte WPF-basierte IDE
         1. Bildschirmressourcen verwalten und effizient nutzen
            1. Horizontale und vertikale Registerkartengruppe
            2. Unterstützung mehrerer Bildschirme und abdockbare Fenster
         2. Beständigkeit des Fensterlayouts
      7. Code: navigieren, suchen und nachvollziehen
         1. Navigieren zu
            1. Zwischen Codeblöcken navigieren
            2. Hervorheben und Navigieren zwischen Symbolverweisen
         2. Die Hervorhebungsfarbe ändern
            1. Verweise hervorheben-Funktion abschalten
      8. Regionen und Gliederungen
      9. Architektur-Explorer
         1. Sequenzdiagramme
         2. Klassendiagramme
         3. Bottom-up-Programmierung
            1. Vorschlagsmodus (erst anwenden)
            2. Pascal Case-Filterung in IntelliSense
      10. Generate From Usage
          1. Typen anpassen mit dem Dialog Neuen Typ generieren
      11. Visual Studio erweitern
          1. Visual Studio-Erweiterungen verwalten
          2. Erweiterungsarten
   5. 5. Einführung in Windows Forms – Designer und Code-Editor am Beispiel
      1. Das Fallbeispiel – der DVD-Hüllen-Generator »Covers«
         1. Das »Pflichtenheft« von Covers
         2. Erstellen eines neuen Projekts
      2. Gestalten von Formularen mit dem Windows Forms-Designer
         1. Positionieren von Steuerelementen
            1. Ausrichtungslinien (Guidelines) und die Margin/Padding-Eigenschaften von Steuerelementen
            2. Angleichen von Größe und Position von Steuerelementen
            3. Selektieren mehrerer Steuerelemente und Bestimmen des Referenzsteuerelements
         2. Häufige Arbeiten an Steuerelementen mit Smarttags erledigen
         3. Dynamische Anordnung von Steuerelementen zur Laufzeit
            1. Verankern von Steuerelementen mit der Anchor-Eigenschaft
            2. Proportionales Anpassen von Steuerelementen an Formulargrößenänderungen mit dem TableLayoutPanel
            3. Einstellen der vorhandenen Spalten und Zeilen des TableLayoutPanel
            4. Anordnen von Steuerelementen in den Zellen eines TableLayoutPanel
            5. Verankern von Steuerelementen im TableLayoutPanel
            6. Verbinden von Zeilen oder Spalten des TableLayoutPanel
         4. Automatisches Scrollen von Steuerelementen in Containern
         5. Selektieren von Steuerelementen, die Sie mit der Maus nicht erreichen
            1. Selektieren von Steuerelementen mit dem Eigenschaftenfenster
         6. Festlegen der Tabulatorreihenfolge (Aktivierreihenfolge) von Steuerelementen
         7. Über die Eigenschaften Name, Text und Caption
            1. Schnellzugriffstasten durch die Text-Eigenschaft bestimmen
         8. Einrichten von Bestätigungs- und Abbrechen-Funktionalitäten für Schaltflächen in Formularen
         9. Hinzufügen neuer Formulare zu einem Projekt
         10. Wie geht’s weiter?
         11. Namensgebungskonventionen für Steuerelemente in diesem Buch
         12. Funktionen zum Layouten von Steuerelementen im Designer
         13. Tastaturkürzel für die Platzierung von Steuerelementen
      3. Der Code-Editor
         1. Die Darstellung im Editor auf die richtige Größe einstellen
         2. Viele Wege führen zum Code-Editor
         3. IntelliSense – Ihr stärkstes Zugpferd im Coding-Stall
            1. Filtern von Elementen in der Vervollständigungsliste
            2. Anzeigen der Parameterinfo von Elementen
            3. Mehrzeilige Befehlszeilen, impliziter Zeilenumbruch und die Parameterinfo
         4. Automatische Vervollständigung von Struktur-Schlüsselwörtern und Codeeinrückung
         5. Fehlererkennung im Code-Editor
            1. Einfache Fehlerkennzeichnung im Editor
            2. Editorunterstützung bei Fehlern zur Laufzeit
            3. Fehlerverbesserungsvorschläge des Editors bei Typkonflikten – erzwungene Typsicherheit
         6. XML-Dokumentationskommentare für IntelliSense bei eigenen Objekten und Klassen
         7. Hinzufügen neuer Codedateien zum Projekt
         8. Code umgestalten (Refactoring)
            1. Code umgestalten (Klassennamenanpassung) beim Umbenennen von Projektdateien oder Objekteigenschaften
         9. Die Bibliothek der Codeausschnitte (Code Snippets Library)
            1. Einfügen von Codeausschnitten mithilfe von Verknüpfungen
         10. Speichern von Anwendungseinstellungen mit dem Settings-Designer
             1. Einrichten von Settings-Variablen
             2. Verwenden von Settings-Variablen im Code
             3. Verknüpfen von Settings-Werten mit Formular- oder Steuerelementeigenschaften
             4. Und wo werden die Settings-Daten abgelegt?
             5. Herzlichen Glückwunsch!
   6. 6. Einführung in Windows Presentation Foundation
      1. Was ist Windows Presentation Foundation?
      2. Was ist so neu an WPF?
         1. 25 Jahre Windows, 25 Jahre gemalte Schaltflächen
            1. Spielende Protagonisten
      3. Wie WPF Designer und Entwickler zusammenbringt
         1. XAML: Extensible Application Markup Language
         2. Ereignisbehandlungsroutinen in WPF und Visual Basic
      4. Die XAML-Syntax im Überblick
      5. ImageResizer – das praktische WPF-Beispiel
         1. Definieren von Grid-Spalten und -Zeilen zum Anordnen von Steuerelementen
            1. »Begin at the beginning«, the King said very gravely, »and go on till you come to the end: then stop!«
            2. Nachträgliches Einfügen einer neuen Zeile
            3. Einmal das Hauptmenü, bitte!
            4. Steuerelemente mit Ereignissen verknüpfen
            5. Laden der Standardeinstellungen
            6. Organisation ist alles: den Ausgabepfad frei definierbar machen
            7. Letzte Vorbereitungen treffen: Bilder hinzufügen
            8. Endspurt: das Verkleinern der Bilder
            9. Hinzufügen eines Projekts zu einer bestehenden Projektmappe und Setzen der Verweise
            10. Das Herzstück des Programms: die Funktionalität des Verkleinerns
            11. Von der Holz- zur Businessklasse
   7. 7. Die essenziellen .NET-Datentypen
      1. Numerische Datentypen
         1. Numerische Datentypen deklarieren und definieren
         2. Delegation numerischer Berechnungen an den Prozessor
         3. Hinweis zur CLS-Konformität
         4. Die numerischen Datentypen auf einen Blick
            1. Byte
            2. SByte
            3. Short
            4. UShort
            5. Integer
            6. UInteger
            7. Long
            8. ULong
            9. Single
            10. Double
            11. Decimal
         5. Tabellarische Zusammenfassung der numerischen Datentypen
         6. Rundungsfehler bei der Verwendung von Single und Double
         7. Besondere Funktionen, die für alle numerischen Datentypen gelten
            1. Zeichenketten in Werte wandeln und Vermeiden von kulturabhängigen Fehlern
            2. Performance- und Rundungs-Problematik beim Konvertieren von Fließkomma- zu Integerwerten
            3. Ermitteln von minimal und maximal darstellbarem Wert eines numerischen Typs
         8. Spezielle Funktionen der Fließkommatypen
            1. Unendlich (Infinity)
            2. Keine Zahl (NaN, Not a Number)
            3. Versuchte Umwandlungen mit TryParse
         9. Spezielle Funktionen des Wertetyps Decimal
      2. Der Datentyp Char
      3. Der Datentyp String
         1. Strings – gestern und heute
         2. Strings deklarieren und definieren
         3. Prüfen, ob ein String »leer« ist – String.IsNullOrWhiteSpace
         4. Automatische Zeichenwiederholungen durch den String-Konstruktor (String$-Funktionalität aus VBA)
         5. Einem String Zeichenketten mit Sonderzeichen zuweisen
         6. Speicherbedarf von Strings
         7. Strings sind unveränderlich
         8. Speicheroptimierung von Strings durch .NET Framework
         9. Ermitteln der String-Länge
         10. Ermitteln von Teilen eines Strings oder eines einzelnen Zeichens
         11. Angleichen von String-Längen
         12. Suchen und Ersetzen
             1. Trimmen von Strings
         13. Algorithmisches Auflösen eines Strings in Teile
         14. Iterieren durch einen String
         15. StringBuilder vs. String – wenn es auf Geschwindigkeit ankommt
             1. Performance-Vergleich: String gegen StringBuilder
      4. Der Datentyp Boolean
         1. Konvertieren von und in numerische Datentypen
         2. Konvertierung von und in Strings
      5. Der Datentyp Date
         1. Rechnen mit Zeiten und Datumswerten – TimeSpan
         2. Bibliothek mit brauchbaren Datumsrechenfunktionen
         3. Zeichenketten in Datumswerte wandeln
            1. Umwandlungen mit Parse
            2. Umwandlungen mit ParseExact
      6. .NET-Äquivalente primitiver Datentypen
         1. GUIDs
      7. Konstanten und Nur-Lesen-Felder (Read-only-Feldvariablen)
         1. Konstanten
         2. Nur-Lesen-Felder
5. II. Objektorientiertes Programmieren
   1. 8. Einführung in die objektorientierte Programmierung
      1. Einführung in Klassen und Objekte
         1. Miniadresso – die prozedurale Variante
   2. 9. Klassentreffen
      1. Was ist eine Klasse?
      2. Klassen mit New instanziieren
         1. Öffentliche Felder oder Eigenschaften beim Instanziieren initialisieren
      3. New oder nicht New – wieso es sich bei Objekten um Verweistypen handelt
      4. Nothing
         1. Nothing als Null-Referenz-Zeiger
         2. Nothing in Zuweisungen für Standardwerte
      5. Klassen verwenden
      6. Wertetypen
         1. Wertetypen mit Structure erstellen
         2. Wertetypen durch Zuweisung klonen
   3. 10. Klassencode entwickeln
      1. Eigenschaften
         1. Zuweisen von Eigenschaften
         2. Ermitteln von Eigenschaften
         3. Viel Tipparbeit sparen mit automatisch implementierten Eigenschaften
            1. Vorbelegen von Eigenschaftswerten von automatisch implementierten Eigenschaften
         4. Eigenschaften mit Parametern
         5. Default-Eigenschaften (Standardeigenschaften)
         6. Öffentliche Variablen oder Eigenschaften – eine Glaubensfrage?
      2. Der Konstruktor einer Klasse – bestimmen, was bei New passiert
         1. Parametrisierte Konstruktoren
         2. Hat jede Klasse einen Konstruktor?
      3. Klassenmethoden mit Sub und Function
      4. Überladen von Methoden, Konstruktoren und Eigenschaften
         1. Methodenüberladung und optionale Parameter
            1. Anwenden von optionalen Parametern
         2. Gegenseitiges Aufrufen von überladenen Methoden
         3. Gegenseitiges Aufrufen von überladenen Konstruktoren
         4. Überladen von Eigenschaftenprozeduren mit Parametern
      5. Zugriffsmodifizierer für Klassen, Methoden und Eigenschaften – Gültigkeitsbereiche definieren
         1. Zugriffsmodifizierer bei Klassen
         2. Zugriffsmodifizierer bei Prozeduren (Subs, Functions, Properties)
         3. Zugriffsmodifizierer bei Variablen
         4. Unterschiedliche Zugriffsmodifizierer für Eigenschaften-Accessors
      6. Statische Elemente
         1. Statische Methoden
         2. Statische Eigenschaften
      7. Über mehrere Codedateien aufgeteilter Klassencode – das Partial-Schlüsselwort
         1. Partieller Klassencode bei Methoden und Eigenschaften
   4. 11. Vererben von Klassen und Polymorphie
      1. Wiederverwendbarkeit von Klassen durch Vererbung (Inheritance)
         1. Initialisierung von Feldvariablen bei Klassen ohne Standardkonstruktoren
      2. Überschreiben von Methoden und Eigenschaften
         1. Überschreiben vorhandener Methoden und Eigenschaften von .NET Framework-Klassen
      3. Polymorphie
         1. Ein erstes einfaches Beispiel zur Polymorphie
         2. Polymorphie in der Praxis
         3. Polymorphie und der Gebrauch von Me, MyClass und MyBase
      4. Abstrakte Klassen und virtuelle Prozeduren
         1. Eine Klasse mit MustInherit als abstrakt deklarieren
         2. Eine Methode oder Eigenschaft einer abstrakten Klasse mit MustOverride als virtuell deklarieren
      5. Schnittstellen (Interfaces)
         1. Unterstützung bei abstrakten Klassen und Schnittstellen durch den Editor
            1. Die Tücken der automatischen Codeergänzung bei Schnittstellen oder abstrakten Klassen
            2. Editorunterstützung bei abstrakten Klassen
         2. Schnittstellen, die Schnittstellen implementieren
         3. Einbinden mehrerer Schnittstellen in eine Klasse
      6. Die Methoden und Eigenschaften von Object
         1. Ausgeben der String-Repräsentation eines Objekts mit ToString
         2. Prüfen auf Gleichheit von Objekten mit Object.Equals oder dem Is/IsNot-Operator
         3. Equals, Is und IsNot im praktischen Einsatz
         4. Übersicht über die Eigenschaften und Methoden von Object
      7. Shadowing (Überschatten) von Klassenprozeduren
         1. Shadows als Unterbrecher der Klassenhierarchie
      8. Sonderform »Modul« in Visual Basic
      9. Singleton-Klassen und Klassen, die sich selbst instanziieren
   5. 12. Entwickeln von Wertetypen
      1. Erstellen von Wertetypen mit Structure am praktischen Beispiel
         1. Verhalten der Parameterübergabe mit ByVal und ByRef steuern
         2. Konstruktoren und Standardinstanziierungen von Wertetypen
            1. Keine Code für Standardkonstruktoren bei Wertetypen
         3. Wann Werte-, wann Referenztypen verwenden?
         4. Gezieltes Zuweisen von Speicherbereichen für Strukturmember mit den StructLayout- und FieldOffset-Attributen
   6. 13. Typenumwandlung (Type Casting) und Boxing von Wertetypen
      1. Konvertieren von primitiven Typen
      2. Konvertieren von und in Zeichenketten (Strings)
         1. Konvertieren von Strings mit den Parse- und ParseExact-Methoden
         2. Konvertieren in Strings mit der ToString-Methode
         3. Abfangen von fehlschlagenden Typkonvertierungen mit TryParse oder Ausnahmehandlern
      3. Casten von Referenztypen mit DirectCast
         1. TryCast – herausfinden, ob gecastet werden kann
         2. IsAssignableFrom – Test auf erlaubtes Casting ohne zusätzliche Objektvariable
      4. Boxing von Wertetypen und primitiven Typen
         1. Übrigens: Was DirectCast nicht kann
         2. Wann wird und wann wird nicht geboxt?
      5. Wertänderung von durch Schnittstellen geboxten Wertetypen
   7. 14. Beerdigen von Objekten – Dispose, Finalize und der Garbage Collector
      1. Der Garbage Collector – die Müllabfuhr in .NET
         1. Wie der Garbage Collector arbeitet
      2. Die Geschwindigkeit der Objektbereitstellung
      3. Finalize
         1. Wann Finalize nicht stattfindet
      4. Dispose
         1. Implementierung eines hochauflösenden Timers als IDisposable
         2. Unterstützung durch den Visual Basic-Editor beim Einfügen eines Disposable-Patterns
      5. Gezieltes Freigeben von Objekten mit Using
   8. 15. Eigene Operatoren für benutzerdefinierte Typen
      1. Einführung in Operatorenprozeduren
      2. Vorbereitung einer Struktur oder Klasse für Operatorenprozeduren
      3. Implementierung von Operatoren
         1. Überladen von Operatorenprozeduren
      4. Implementierung von Vergleichsoperatoren
      5. Implementierung von Typkonvertierungsoperatoren mit dem Operator CType
      6. Implementieren von Wahr- und Falsch-Auswertungsoperatoren
      7. Problembehandlungen bei Operatorenprozeduren
         1. Aufgepasst bei der Verwendung von Referenztypen
      8. Übersicht der implementierbaren Operatoren
   9. 16. Ereignis, Delegaten und Lambda-Ausdrücke
      1. Konsumieren von Ereignissen mit WithEvents und Handles
      2. Auslösen von Ereignissen
         1. Events können nicht vererbt werden – der Umweg über Onxxx
      3. Ereignisparameter zur Verfügung stellen
         1. Die Quelle des Ereignisses: Sender
         2. Nähere Informationen zum Ereignis: EventArgs
      4. Delegaten
         1. Delegaten an Methoden übergeben
      5. Lambda-Ausdrücke
         1. Einzeilige Ausdrucks- und mehrzeilige Anweisungs-Lambdas
      6. Dynamisches Anbinden von Ereignissen mit AddHandler
      7. Implementieren eigener Event Handler
   10. 17. Enums
       1. Bestimmung der Werte der Aufzählungselemente
          1. Dubletten sind erlaubt!
       2. Bestimmung der Typen der Aufzählungselemente
          1. Ermitteln des Elementtyps zur Laufzeit
       3. Konvertieren von Enums
          1. In Zahlenwerte umwandeln und aus Werten definieren
          2. In Strings umwandeln und aus Strings definieren
       4. Flags-Enums (Flags-Aufzählungen)
          1. Abfrage von Flags-Aufzählungen
   11. 18. Generics (Generika) und generische Auflistungen
       1. Einführung
          1. Generics: Verwenden einer Codebasis für verschiedene Typen
       2. Lösungsansätze
       3. Standardisierung der Codebasis eines Typs durch den Einsatz von Generics
       4. Beschränkungen (Constraints)
          1. Beschränkungen für generische Typen auf eine bestimmte Basisklasse
          2. Beschränkungen auf Klassen, die bestimmte Schnittstellen implementieren
          3. Beschränkungen auf Klassen, die über einen Standardkonstruktor verfügen
          4. Beschränkungen auf Wertetypen
          5. Kombinieren von Beschränkungen und Bestimmen mehrerer Typparameter
   12. 19. Typen für Fortgeschrittene
       1. Nullable Wertetypen
          1. Aufpassen beim Umgang mit booleschen Ausdrücken auf Basis von Nullables!
          2. Besonderheiten bei Nullable beim Boxen
          3. Unterschied zwischen Nothing und Nothing als Standardwert
       2. Generische Delegaten
          1. Action(Of T)
          2. Function(Of T)
       3. Tuple(Of T)
       4. Typvarianz
       5. Erweiterungsmethoden
          1. Das Haupteinsatzgebiet von Erweiterungsmethoden
          2. Erweiterungsmethoden zur Vereinfachung von Auflistungsinitialisieren
6. III. Programmieren von und mit Datenstrukturen aus .NET Framework
   1. 20. Arrays und Auflistungen
      1. Grundsätzliches zu Arrays
      2. Initialisierung von Arrays
         1. Änderung der Array-Dimensionen zur Laufzeit
         2. Die Magie von ReDim
         3. Wertevorbelegung von Array-Elementen im Code
         4. Typrückschluss bei der Verwendung von Array-Initialisierern
            1. Dominierende Typen
         5. Mehrdimensionale und verschachtelte Arrays
            1. Verschachtelte Arrays
         6. Die wichtigsten Eigenschaften und Methoden von Arrays
            1. Anzahl der Elemente eines Arrays ermitteln mit Length
            2. Sortieren von Arrays mit Array.Sort
            3. Umdrehen der Array-Anordnung mit Array.Reverse
            4. Durchsuchen eines sortierten Arrays mit Array.BinarySearch
         7. Implementierung von Sort und BinarySearch für eigene Klassen
            1. Implementieren der Vergleichsfähigkeit einer Klasse durch IComparable
         8. Verwenden von Lambdas mit Arrays-Methoden
      3. Enumeratoren
         1. Benutzerdefinierte Enumeratoren durch Implementieren von IEnumerable
      4. Grundsätzliches zu Auflistungen (Collections)
      5. Initialisierung von Auflistungen
         1. Vereinfachung von Auflistungsinitialisierern durch Erweiterungsmethoden
      6. Wichtige Auflistungen von .NET Framework, die Sie kennen sollten
         1. ArrayList – universelle Ablage für Objekte
         2. Typsichere Auflistungen auf Basis von CollectionBase
         3. Hashtables – für das Nachschlagen von Objekten
         4. Anwenden von Hashtables
            1. Verarbeitungsgeschwindigkeiten von Hashtables
            2. Wieso die Zugriffszeit auf Hashtable-Elemente nahezu konstant ist ...
            3. ... und wieso Sie das wissen sollten!
         5. Verwenden eigener Klassen als Schlüssel (Key)
            1. Schlüssel müssen unveränderlich sein!
         6. Enumerieren von Datenelementen in einer Hashtable
         7. DictionaryBase
         8. Queue – Warteschlangen im FIFO-Prinzip
         9. Stack – Stapelverarbeitung im LIFO-Prinzip
         10. SortedList – Elemente ständig sortiert halten
      7. Generische Auflistungen (Generic Collections)
         1. List(Of )-Auflistungen und Lambda-Ausdrücke
            1. ForEach und der generische Action-Delegat
            2. Sort und der generische Comparison-Delegat
            3. Find und der generische Predicate-Delegat
         2. KeyedCollection – Schlüssel/Wörterbuch-Auflistung mit zusätzlichen Index-Abrufen
         3. Elementverkettungen mit LinkedList(Of )
   2. 21. Serialisierung
      1. Einführung in Serialisierungstechniken
         1. Serialisieren mit SoapFormatter und BinaryFormatter
            1. Universeller SOAP-Datei-De-/Serializer
            2. Universeller Binary-Datei-De-/Serializer
            3. Funktionsweise der Datei-Serializer-Klassen
      2. Flaches und tiefes Klonen von Objekten
         1. Universelle DeepClone-Methode
      3. Serialisieren von Objekten mit Zirkelverweisen
         1. Serialisierung von Objekten unterschiedlicher Versionen beim Einsatz von BinaryFormatter- oder SoapFormatter-Klassen
      4. XML-Serialisierung
         1. Prüfen der Versionsunabhängigkeit der XML-Datei
         2. Serialisierungsfehler bei KeyedCollection
   3. 22. Attribute und Reflection
      1. Genereller Umgang mit Attributen
         1. Einsatz von Attributen am Beispiel von ObsoleteAttribute
         2. Die speziell in Visual Basic verwendeten Attribute
      2. Einführung in Reflection
         1. Die Type-Klasse als Ausgangspunkt für alle Typenuntersuchungen
         2. Klassenanalysefunktionen, die ein Type-Objekt bereitstellt
         3. Objekthierarchie von MemberInfo und Casten in den spezifischen Info-Typ
         4. Ermitteln von Eigenschaftswerten über PropertyInfo zur Laufzeit
      3. Erstellung benutzerdefinierter Attribute und deren Erkennen zur Laufzeit
         1. Ermitteln von benutzerdefinierten Attributen zur Laufzeit
7. IV. Entwicklungsvereinfachungen in Visual Basic 2010
   1. 23. My als Abkürzung zu Framework-Funktionen verwenden
      1. Die Visual Basic 2010-Vereinfachungen am Beispiel DotNetCopy
         1. DotNetCopy mit /Autostart und /Silent-Optionen
      2. Die prinzipielle Funktionsweise von DotNetCopy
      3. Der My-Namespace
      4. Formulare ohne Instanziierung aufrufen
      5. Auslesen der Befehlszeilenargumente mit My.Application.CommandLineArgs
      6. Gezieltes Zugreifen auf Ressourcen mit My.Resources
         1. Anlegen und Verwalten von Ressourcenelementen
         2. Abrufen von Ressourcen mit My.Resources
      7. Internationalisieren von Anwendungen mithilfe von Ressourcendateien und dem My-Namespace
      8. Vereinfachtes Durchführen von Dateioperationen mit My.Computer.FileSystem
      9. Verwenden von Anwendungseinstellungen mit My.Settings
         1. Speichern von Anwendungseinstellungen mit dem Bereich Benutzer
   2. 24. Das Anwendungsframework
      1. Die Optionen des Anwendungsframeworks
         1. Windows XP Look and Feel für eigene Windows-Anwendungen – Visuelle XP-Stile aktivieren
         2. Verhindern, dass Ihre Anwendung mehrfach gestartet wird – Einzelinstanzanwendung erstellen
         3. Eigene Einstellungen beim Herunterfahren automatisch sichern – My.Settings beim Herunterfahren speichern
         4. Bestimmen, welcher Benutzer-Authentifizierungsmodus verwendet wird
         5. Festlegen, wann eine Anwendung »zu Ende« ist – Modus für das Herunterfahren
         6. Einen Splash-Dialog beim Starten von komplexen Anwendungen anzeigen – Begrüßungsbildschirm
      2. Eine Codedatei implementieren, die Anwendungsereignisse (Starten, Beenden, Netzwerkzustand, generelle Fehler) behandelt
8. V. Language Integrated Query – LINQ
   1. 25. Einführung in Language integrated Query (LINQ)
      1. Wie »geht« LINQ prinzipiell
         1. Erweiterungsmethoden als Basis für LINQ
      2. Die Where-Methode
      3. Die Select-Methode
         1. Anonyme Typen
         2. Typrückschluss für generische Typparameter
      4. Kombinieren von LINQ-Erweiterungsmethoden
      5. Vereinfachte Anwendung von LINQ – Erweiterungsmethoden mit der LINQ-Abfragesyntax
   2. 26. LINQ to Objects
      1. Einführung in LINQ to Objects
      2. Der Aufbau einer LINQ-Abfrage
      3. Performance von LINQ-Abfragen
      4. Kombinieren und verzögertes Ausführen von LINQ-Abfragen
         1. Parallelisieren von LINQ-Abfragen mit AsParallel
         2. Faustregeln für das Erstellen von LINQ-Abfragen
         3. Kaskadierte Abfragen
         4. Gezieltes Auslösen von Abfragen mit ToArray oder ToList
      5. Verbinden mehrerer Auflistungen zu einer neuen
         1. Implizite Verknüpfung von Auflistungen
         2. Explizite Auflistungsverknüpfung mit Join
      6. Gruppieren von Auflistungen
         1. Gruppieren von Listen aus mehreren Auflistungen
         2. Group Join
      7. Aggregatfunktionen
         1. Zurückliefern mehrerer verschiedener Aggregierungen
         2. Kombinieren von gruppierten Abfragen und Aggregatfunktionen
   3. 27. LINQ to XML
      1. Einführung in LINQ to XML
      2. XML-Dokumente verarbeiten – damals und heute
      3. XML-Literale – XML direkt im Code ablegen
         1. Einbetten von Ausdrücken in XML-Literalen
      4. Erstellen von XML mithilfe von LINQ
      5. Abfragen von XML-Dokumenten mit LINQ to XML
      6. IntelliSense-Unterstützung für LINQ To XML-Abfragen
         1. Verwendung von Präfixen (fuhrpark und artikel)
   4. 28. LINQ to Entities – Programmieren mit Entity Framework
      1. Voraussetzungen zum Test der Beispiele
         1. Download und Installation von SQL Server 2008 Express Edition with Advanced Services
         2. Installation der AdventureWorks Beispieldatenbanken
         3. Prinzipielle Funktionsweise eines Entity Data Model (EDM)
      2. LINQ to Entities – ein erstes Praxisbeispiel
         1. Nachträgliches Ändern des Entitätscontainernamens
      3. Abfrage von Daten eines Entitätsmodells
         1. Abfrage von Daten mit LINQ to Entities-Abfragen
         2. Wie Abfragen zum Datenprovider gelangen – Entity SQL (eSQL)
         3. Anpassen des Namens der Entitätenmenge
         4. Generierte SQL-Anweisungen unter die Lupe nehmen
         5. Lazy Loading und Eager Loading in Entity Framework
            1. Daten beim Lazy Loading manuell nachladen
            2. Eager Loading für bestimmte Relationen verwenden
         6. Anonymisierungsvermeidung bei Abfragen in verknüpften Tabellen
         7. Kompilierte Abfragen
      4. Daten verändern, speichern, einfügen und löschen
         1. Datenänderungen mit SaveChanges an die Datenbank übermitteln
         2. Einfügen von verknüpften Daten in Datentabellen
         3. Daten aus Tabellen löschen
         4. Concurrency-Checks (Schreibkonfliktprüfungen)
      5. Datenmodell aus Datenbank aktualisieren
      6. Model First-Design
      7. Vererbung im konzeptionellen Datenmodell
      8. T-SQL-Befehle im Objektkontext direkt ausführen
      9. Arbeiten mit gespeicherten Prozeduren
      10. Ausblick
9. VI. Anwendungsausführung parallelisieren
   1. 29. Programmieren mit der Task Parallel Library (TPL)
      1. Einführung in die Technik des Threading
      2. Die verschiedenen Möglichkeiten, Threads zu starten, im Schnelldurchlauf
         1. Verwenden der Thread-Klasse
            1. Hintergrundthreads werden stets mit der Hauptanwendung beendet
            2. Vereinfachung des Startens eines Threads mit mehrzeiligen Anwendungs-Lambdas
         2. Asynchrones Aufrufen von Delegaten
         3. Verwenden der Task-Klasse
         4. Direktes Verwenden eines Thread des Threadpools
      3. Zugriff auf Steuerelemente von Threads
      4. Parallelisierung mit Parallel.For und Parallel.ForEach
         1. Parallel.For
            1. Beispiel: Parallelisieren des Image-Resizers aus Kapitel 6
         2. Parallel.ForEach
         3. CancellationToken – Exit For für Parallel.For und Parallel.ForEach
         4. Vermeiden von Fehlern beim Parallelisieren von Schleifen
      5. Arbeiten mit Tasks
         1. Warten auf das Ende von Tasks – WaitOne, WaitAny und WaitAll
         2. Task mit und ohne Rückgabeparameter
         3. Verhindern, dass die Benutzeroberfläche beim Warten auf Tasks blockiert
         4. Vorzeitiges Abbrechen von Tasks mit CancellationToken
      6. Threads synchronisieren
         1. Synchronisieren von Threads mit SyncLock
         2. Mehr Flexibilität in kritischen Abschnitten mit der Monitor-Klasse
            1. Monitor – Wait – Pulse
         3. Synchronisieren von beschränkten Ressourcen mit Mutex
      7. Wie geht es weiter?
10. Stichwortverzeichnis
11. Copyright