Visual C# 2015 - Grundlagen, Profiwissen und Rezepte

 
 
Hanser (Verlag)
  • 1. Auflage
  • |
  • erschienen am 7. September 2015
  • |
  • 1195 Seiten
 
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-446-44606-9 (ISBN)
 
VISUAL C# 2015 - GRUNDLAGEN, PROFIWISSEN, REZEPTE //
- Für Einsteiger, Fortgeschrittene und Profis
- Übungs- und Nachschlagewerk mit genialen Rezepten zu jedem Thema
- EXTRA: 700 Seiten Bonuskapitel zur GUI-Entwicklung mit WPF und Windows Forms
- Im Internet: Bonuskapitel sowie alle Beispiele aus dem Buch

Dieser Klassiker der C#-/.NET-Programmierung bietet Ihnen Informationen und Rezepte, nach denen Sie anderswo vergeblich suchen. Einsteiger erhalten ein umfangreiches Praktikum zu den Grundlagen der .NET-Programmierung mit Visual C# 2015, dem Profi liefert es fortgeschrittene Programmiertechniken zu allen wesentlichen Einsatzgebieten der Windowsprogrammierung. Zum sofortigen Ausprobieren finden Sie am Ende eines jeden Kapitels hochwertige Lösungen für nahezu jedes Problem.

Mit diesem Buch haben Sie den idealen Begleiter für Ihre tägliche Arbeit und zugleich - dank der erfrischenden und unterhaltsamen Sprache - eine durchaus spannende Lektüre auch für die Zeit nach der Arbeit.

Die Themenkomplexe im Buch:
Teil I: Grundlagen der Programmierung mit Visual C# 2015
Teil II: Technologien
Teil III: Windows Apps

Die Themenkomplexe im Internet:
Teil IV: WPF-Anwendungen
Teil V: Windows Forms

AUS DEM INHALT //
Grundlagen der Sprache // OOP-Konzepte // Einführung in LINQ // Dateien & Dateisystem // XML-Dateien // Asynchrone Programmierung & Task Parallel Library // Fehlersuche und Behandlung // Datenbankzugriff mit ADO.NET // Verteilen von Anwendungen // App-Oberflächen entwerfen // Apps im Detail // GUI-Entwicklung mit WPF und Windows Forms
  • Deutsch
  • München
  • |
  • Deutschland
  • 36,87 MB
978-3-446-44606-9 (9783446446069)
http://dx.doi.org/10.3139/9783446446069
weitere Ausgaben werden ermittelt
Walter Doberenz und Thomas Gewinnus haben sich als Entwickler, Dozenten und Fachbuchautoren für Microsoft- und Borland- Entwicklerwerkzeuge einen Namen gemacht, ihre Fachbücher sind seit Jahren als Standardwerke etabliert.
1 - Inhaltsverzeichnis [Seite 6]
2 - Vorwort [Seite 46]
3 - Teil I: Grundlagen [Seite 50]
3.1 - 1 Einstieg in Visual Studio 2015 [Seite 52]
3.1.1 - 1.1 Die Installation von Visual Studio 2015 [Seite 52]
3.1.1.1 - 1.1.1 Überblick über die Produktpalette [Seite 52]
3.1.1.2 - 1.1.2 Anforderungen an Hard- und Software [Seite 53]
3.1.2 - 1.2 Unser allererstes C#-Programm [Seite 54]
3.1.2.1 - 1.2.1 Vorbereitungen [Seite 54]
3.1.2.2 - 1.2.2 Quellcode schreiben [Seite 56]
3.1.2.3 - 1.2.3 Programm kompilieren und testen [Seite 56]
3.1.2.4 - 1.2.4 Einige Erläuterungen zum Quellcode [Seite 57]
3.1.2.5 - 1.2.5 Konsolenanwendungen sind out [Seite 58]
3.1.3 - 1.3 Die Windows-Philosophie [Seite 58]
3.1.3.1 - 1.3.1 Mensch-Rechner-Dialog [Seite 58]
3.1.3.2 - 1.3.2 Objekt- und ereignisorientierte Programmierung [Seite 59]
3.1.3.3 - 1.3.3 Programmieren mit Visual Studio 2015 [Seite 60]
3.1.4 - 1.4 Die Entwicklungsumgebung Visual Studio 2015 [Seite 61]
3.1.4.1 - 1.4.1 Neues Projekt [Seite 62]
3.1.4.2 - 1.4.2 Die wichtigsten Fenster [Seite 63]
3.1.5 - 1.5 Microsofts .NET-Technologie [Seite 66]
3.1.5.1 - 1.5.1 Zur Geschichte von .NET [Seite 66]
3.1.5.2 - 1.5.2 .NET-Features und Begriffe [Seite 68]
3.1.6 - 1.6 Wichtige Neuigkeiten in Visual Studio 2015 [Seite 75]
3.1.6.1 - 1.6.1 Entwicklungsumgebung [Seite 75]
3.1.6.2 - 1.6.2 Neue C#-Sprachfeatures [Seite 75]
3.1.6.3 - 1.6.3 Code-Editor [Seite 76]
3.1.6.4 - 1.6.4 NET Framework 4.6 [Seite 76]
3.1.7 - 1.7 Praxisbeispiele [Seite 77]
3.1.7.1 - 1.7.1 Unsere erste Windows Forms-Anwendung [Seite 77]
3.1.7.2 - 1.7.2 Umrechnung Euro-Dollar [Seite 81]
3.2 - 2 Grundlagen der Sprache C# [Seite 90]
3.2.1 - 2.1 Grundbegriffe [Seite 90]
3.2.1.1 - 2.1.1 Anweisungen [Seite 90]
3.2.1.2 - 2.1.2 Bezeichner [Seite 91]
3.2.1.3 - 2.1.3 Schlüsselwörter [Seite 92]
3.2.1.4 - 2.1.4 Kommentare [Seite 92]
3.2.2 - 2.2 Datentypen, Variablen und Konstanten [Seite 93]
3.2.2.1 - 2.2.1 Fundamentale Typen [Seite 93]
3.2.2.2 - 2.2.2 Wertetypen versus Verweistypen [Seite 94]
3.2.2.3 - 2.2.3 Benennung von Variablen [Seite 95]
3.2.2.4 - 2.2.4 Deklaration von Variablen [Seite 95]
3.2.2.5 - 2.2.5 Typsuffixe [Seite 97]
3.2.2.6 - 2.2.6 Zeichen und Zeichenketten [Seite 98]
3.2.2.7 - 2.2.7 object-Datentyp [Seite 100]
3.2.2.8 - 2.2.8 Konstanten deklarieren [Seite 100]
3.2.2.9 - 2.2.9 Nullable Types [Seite 101]
3.2.2.10 - 2.2.10 Typinferenz [Seite 102]
3.2.2.11 - 2.2.11 Gültigkeitsbereiche und Sichtbarkeit [Seite 103]
3.2.3 - 2.3 Konvertieren von Datentypen [Seite 103]
3.2.3.1 - 2.3.1 Implizite und explizite Konvertierung [Seite 103]
3.2.3.2 - 2.3.2 Welcher Datentyp passt zu welchem? [Seite 105]
3.2.3.3 - 2.3.3 Konvertieren von string [Seite 106]
3.2.3.4 - 2.3.4 Die Convert-Klasse [Seite 108]
3.2.3.5 - 2.3.5 Die Parse-Methode [Seite 108]
3.2.3.6 - 2.3.6 Boxing und Unboxing [Seite 109]
3.2.4 - 2.4 Operatoren [Seite 110]
3.2.4.1 - 2.4.1 Arithmetische Operatoren [Seite 111]
3.2.4.2 - 2.4.2 Zuweisungsoperatoren [Seite 112]
3.2.4.3 - 2.4.3 Logische Operatoren [Seite 113]
3.2.4.4 - 2.4.4 Rangfolge der Operatoren [Seite 116]
3.2.5 - 2.5 Kontrollstrukturen [Seite 117]
3.2.5.1 - 2.5.1 Verzweigungsbefehle [Seite 117]
3.2.5.2 - 2.5.2 Schleifenanweisungen [Seite 120]
3.2.6 - 2.6 Benutzerdefinierte Datentypen [Seite 123]
3.2.6.1 - 2.6.1 Enumerationen [Seite 123]
3.2.6.2 - 2.6.2 Strukturen [Seite 124]
3.2.7 - 2.7 Nutzerdefinierte Methoden [Seite 126]
3.2.7.1 - 2.7.1 Methoden mit Rückgabewert [Seite 127]
3.2.7.2 - 2.7.2 Methoden ohne Rückgabewert [Seite 128]
3.2.7.3 - 2.7.3 Parameterübergabe mit ref [Seite 129]
3.2.7.4 - 2.7.4 Parameterübergabe mit out [Seite 130]
3.2.7.5 - 2.7.5 Methodenüberladung [Seite 131]
3.2.7.6 - 2.7.6 Optionale Parameter [Seite 132]
3.2.7.7 - 2.7.7 Benannte Parameter [Seite 133]
3.2.8 - 2.8 Praxisbeispiele [Seite 134]
3.2.8.1 - 2.8.1 Vom PAP zur Konsolenanwendung [Seite 134]
3.2.8.2 - 2.8.2 Ein Konsolen- in ein Windows-Programm verwandeln [Seite 136]
3.2.8.3 - 2.8.3 Schleifenanweisungen verstehen [Seite 138]
3.2.8.4 - 2.8.4 Benutzerdefinierte Methoden überladen [Seite 140]
3.2.8.5 - 2.8.5 Anwendungen von Visual Basic nach C# portieren [Seite 143]
3.3 - 3 OOP-Konzepte [Seite 150]
3.3.1 - 3.1 Kleine Einführung in die OOP [Seite 150]
3.3.1.1 - 3.1.1 Historische Entwicklung [Seite 150]
3.3.1.2 - 3.1.2 Grundbegriffe der OOP [Seite 152]
3.3.1.3 - 3.1.3 Sichtbarkeit von Klassen und ihren Mitgliedern [Seite 154]
3.3.1.4 - 3.1.4 Allgemeiner Aufbau einer Klasse [Seite 155]
3.3.1.5 - 3.1.5 Das Erzeugen eines Objekts [Seite 156]
3.3.1.6 - 3.1.6 Einführungsbeispiel [Seite 159]
3.3.2 - 3.2 Eigenschaften [Seite 164]
3.3.2.1 - 3.2.1 Eigenschaften mit Zugriffsmethoden kapseln [Seite 164]
3.3.2.2 - 3.2.2 Berechnete Eigenschaften [Seite 166]
3.3.2.3 - 3.2.3 Lese-/Schreibschutz [Seite 168]
3.3.2.4 - 3.2.4 Property-Accessoren [Seite 169]
3.3.2.5 - 3.2.5 Statische Felder/Eigenschaften [Seite 169]
3.3.2.6 - 3.2.6 Einfache Eigenschaften automatisch implementieren [Seite 172]
3.3.3 - 3.3 Methoden [Seite 173]
3.3.3.1 - 3.3.1 Öffentliche und private Methoden [Seite 173]
3.3.3.2 - 3.3.2 Überladene Methoden [Seite 174]
3.3.3.3 - 3.3.3 Statische Methoden [Seite 175]
3.3.4 - 3.4 Ereignisse [Seite 177]
3.3.4.1 - 3.4.1 Ereignis hinzufügen [Seite 177]
3.3.4.2 - 3.4.2 Ereignis verwenden [Seite 180]
3.3.5 - 3.5 Arbeiten mit Konstruktor und Destruktor [Seite 183]
3.3.5.1 - 3.5.1 Konstruktor und Objektinitialisierer [Seite 183]
3.3.5.2 - 3.5.2 Destruktor und Garbage Collector [Seite 186]
3.3.5.3 - 3.5.3 Mit using den Lebenszyklus des Objekts kapseln [Seite 189]
3.3.5.4 - 3.5.4 Verzögerte Initialisierung [Seite 189]
3.3.6 - 3.6 Vererbung und Polymorphie [Seite 190]
3.3.6.1 - 3.6.1 Klassendiagramm [Seite 190]
3.3.6.2 - 3.6.2 Method-Overriding [Seite 191]
3.3.6.3 - 3.6.3 Klassen implementieren [Seite 192]
3.3.6.4 - 3.6.4 Implementieren der Objekte [Seite 195]
3.3.6.5 - 3.6.5 Ausblenden von Mitgliedern durch Vererbung [Seite 197]
3.3.6.6 - 3.6.6 Allgemeine Hinweise und Regeln zur Vererbung [Seite 198]
3.3.6.7 - 3.6.7 Polymorphes Verhalten [Seite 200]
3.3.6.8 - 3.6.8 Die Rolle von System.Object [Seite 202]
3.3.7 - 3.7 Spezielle Klassen [Seite 203]
3.3.7.1 - 3.7.1 Abstrakte Klassen [Seite 203]
3.3.7.2 - 3.7.2 Versiegelte Klassen [Seite 205]
3.3.7.3 - 3.7.3 Partielle Klassen [Seite 205]
3.3.7.4 - 3.7.4 Statische Klassen [Seite 206]
3.3.8 - 3.8 Schnittstellen (Interfaces) [Seite 207]
3.3.8.1 - 3.8.1 Definition einer Schnittstelle [Seite 208]
3.3.8.2 - 3.8.2 Implementieren einer Schnittstelle [Seite 208]
3.3.8.3 - 3.8.3 Abfragen, ob Schnittstelle vorhanden ist [Seite 209]
3.3.8.4 - 3.8.4 Mehrere Schnittstellen implementieren [Seite 210]
3.3.8.5 - 3.8.5 Schnittstellenprogrammierung ist ein weites Feld [Seite 210]
3.3.9 - 3.9 Praxisbeispiele [Seite 210]
3.3.9.1 - 3.9.1 Eigenschaften sinnvoll kapseln [Seite 210]
3.3.9.2 - 3.9.2 Eine statische Klasse anwenden [Seite 213]
3.3.9.3 - 3.9.3 Vom fetten zum schlanken Client [Seite 215]
3.3.9.4 - 3.9.4 Schnittstellenvererbung verstehen [Seite 227]
3.3.9.5 - 3.9.5 Rechner für komplexe Zahlen [Seite 232]
3.3.9.6 - 3.9.6 Formel-Rechner mit dem CodeDOM [Seite 241]
3.3.9.7 - 3.9.7 Berechnungsergebnisse als Diagramm darstellen [Seite 249]
3.3.9.8 - 3.9.8 Sortieren mit IComparable/IComparer [Seite 253]
3.3.9.9 - 3.9.9 Einen Objektbaum in generischen Listen abspeichern [Seite 258]
3.3.9.10 - 3.9.10 OOP beim Kartenspiel erlernen [Seite 264]
3.3.9.11 - 3.9.11 Eine Klasse zur Matrizenrechnung entwickeln [Seite 268]
3.4 - 4 Arrays, Strings, Funktionen [Seite 274]
3.4.1 - 4.1 Datenfelder (Arrays) [Seite 274]
3.4.1.1 - 4.1.1 Array deklarieren [Seite 274]
3.4.1.2 - 4.1.2 Array instanziieren [Seite 275]
3.4.1.3 - 4.1.3 Array initialisieren [Seite 275]
3.4.1.4 - 4.1.4 Zugriff auf Array-Elemente [Seite 276]
3.4.1.5 - 4.1.5 Zugriff mittels Schleife [Seite 277]
3.4.1.6 - 4.1.6 Mehrdimensionale Arrays [Seite 278]
3.4.1.7 - 4.1.7 Zuweisen von Arrays [Seite 280]
3.4.1.8 - 4.1.8 Arrays aus Strukturvariablen [Seite 281]
3.4.1.9 - 4.1.9 Löschen und Umdimensionieren von Arrays [Seite 282]
3.4.1.10 - 4.1.10 Eigenschaften und Methoden von Arrays [Seite 283]
3.4.1.11 - 4.1.11 Übergabe von Arrays [Seite 285]
3.4.2 - 4.2 Verarbeiten von Zeichenketten [Seite 286]
3.4.2.1 - 4.2.1 Zuweisen von Strings [Seite 286]
3.4.2.2 - 4.2.2 Eigenschaften und Methoden von String-Variablen [Seite 287]
3.4.2.3 - 4.2.3 Wichtige Methoden der String-Klasse [Seite 289]
3.4.2.4 - 4.2.4 Die StringBuilder-Klasse [Seite 291]
3.4.3 - 4.3 Reguläre Ausdrücke [Seite 293]
3.4.3.1 - 4.3.1 Wozu werden reguläre Ausdrücke verwendet? [Seite 294]
3.4.3.2 - 4.3.2 Eine kleine Einführung [Seite 294]
3.4.3.3 - 4.3.3 Wichtige Methoden/Eigenschaften der Klasse Regex [Seite 295]
3.4.3.4 - 4.3.4 Kompilierte reguläre Ausdrücke [Seite 297]
3.4.3.5 - 4.3.5 RegexOptions-Enumeration [Seite 298]
3.4.3.6 - 4.3.6 Metazeichen (Escape-Zeichen) [Seite 298]
3.4.3.7 - 4.3.7 Zeichenmengen (Character Sets) [Seite 299]
3.4.3.8 - 4.3.8 Quantifizierer [Seite 301]
3.4.3.9 - 4.3.9 Zero-Width Assertions [Seite 302]
3.4.3.10 - 4.3.10 Gruppen [Seite 305]
3.4.3.11 - 4.3.11 Text ersetzen [Seite 306]
3.4.3.12 - 4.3.12 Text splitten [Seite 307]
3.4.4 - 4.4 Datums- und Zeitberechnungen [Seite 308]
3.4.4.1 - 4.4.1 Die DateTime-Struktur [Seite 308]
3.4.4.2 - 4.4.2 Wichtige Eigenschaften von DateTime-Variablen [Seite 309]
3.4.4.3 - 4.4.3 Wichtige Methoden von DateTime-Variablen [Seite 310]
3.4.4.4 - 4.4.4 Wichtige Mitglieder der DateTime-Struktur [Seite 310]
3.4.4.5 - 4.4.5 Konvertieren von Datumstrings in DateTime-Werte [Seite 311]
3.4.4.6 - 4.4.6 Die TimeSpan-Struktur [Seite 312]
3.4.5 - 4.5 Mathematische Funktionen [Seite 313]
3.4.5.1 - 4.5.1 Überblick [Seite 313]
3.4.5.2 - 4.5.2 Zahlen runden [Seite 314]
3.4.5.3 - 4.5.3 Winkel umrechnen [Seite 314]
3.4.5.4 - 4.5.4 Potenz- und Wurzeloperationen [Seite 314]
3.4.5.5 - 4.5.5 Logarithmus und Exponentialfunktionen [Seite 315]
3.4.5.6 - 4.5.6 Zufallszahlen erzeugen [Seite 315]
3.4.6 - 4.6 Zahlen- und Datumsformatierungen [Seite 316]
3.4.6.1 - 4.6.1 Anwenden der ToString-Methode [Seite 316]
3.4.6.2 - 4.6.2 Anwenden der Format-Methode [Seite 318]
3.4.6.3 - 4.6.3 Stringinterpolation [Seite 319]
3.4.7 - 4.7 Praxisbeispiele [Seite 320]
3.4.7.1 - 4.7.1 Zeichenketten verarbeiten [Seite 320]
3.4.7.2 - 4.7.2 Zeichenketten mit StringBuilder addieren [Seite 323]
3.4.7.3 - 4.7.3 Reguläre Ausdrücke testen [Seite 326]
3.4.7.4 - 4.7.4 Methodenaufrufe mit Array-Parametern [Seite 328]
3.5 - 5 Weitere Sprachfeatures [Seite 332]
3.5.1 - 5.1 Namespaces (Namensräume) [Seite 332]
3.5.1.1 - 5.1.1 Ein kleiner Überblick [Seite 332]
3.5.1.2 - 5.1.2 Einen eigenen Namespace einrichten [Seite 333]
3.5.1.3 - 5.1.3 Die using-Anweisung [Seite 334]
3.5.1.4 - 5.1.4 Namespace Alias [Seite 335]
3.5.1.5 - 5.1.5 Namespace Alias Qualifizierer [Seite 335]
3.5.2 - 5.2 Operatorenüberladung [Seite 336]
3.5.2.1 - 5.2.1 Syntaxregeln [Seite 336]
3.5.2.2 - 5.2.2 Praktische Anwendung [Seite 337]
3.5.3 - 5.3 Collections (Auflistungen) [Seite 338]
3.5.3.1 - 5.3.1 Die Schnittstelle IEnumerable [Seite 338]
3.5.3.2 - 5.3.2 ArrayList [Seite 340]
3.5.3.3 - 5.3.3 Hashtable [Seite 342]
3.5.3.4 - 5.3.4 Indexer [Seite 342]
3.5.4 - 5.4 Generics [Seite 344]
3.5.4.1 - 5.4.1 Klassische Vorgehensweise [Seite 345]
3.5.4.2 - 5.4.2 Generics bieten Typsicherheit [Seite 346]
3.5.4.3 - 5.4.3 Generische Methoden [Seite 347]
3.5.4.4 - 5.4.4 Iteratoren [Seite 348]
3.5.5 - 5.5 Generische Collections [Seite 349]
3.5.5.1 - 5.5.1 List-Collection statt ArrayList [Seite 349]
3.5.5.2 - 5.5.2 Vorteile generischer Collections [Seite 350]
3.5.5.3 - 5.5.3 Constraints [Seite 350]
3.5.6 - 5.6 Das Prinzip der Delegates [Seite 350]
3.5.6.1 - 5.6.1 Delegates sind Methodenzeiger [Seite 351]
3.5.6.2 - 5.6.2 Einen Delegate-Typ deklarieren [Seite 351]
3.5.6.3 - 5.6.3 Ein Delegate-Objekt erzeugen [Seite 351]
3.5.6.4 - 5.6.4 Delegates vereinfacht instanziieren [Seite 353]
3.5.6.5 - 5.6.5 Anonyme Methoden [Seite 354]
3.5.6.6 - 5.6.6 Lambda-Ausdrücke [Seite 355]
3.5.6.7 - 5.6.7 Lambda-Ausdrücke in der Task Parallel Library [Seite 357]
3.5.7 - 5.7 Dynamische Programmierung [Seite 359]
3.5.7.1 - 5.7.1 Wozu dynamische Programmierung? [Seite 359]
3.5.7.2 - 5.7.2 Das Prinzip der dynamischen Programmierung [Seite 359]
3.5.7.3 - 5.7.3 Optionale Parameter sind hilfreich [Seite 362]
3.5.7.4 - 5.7.4 Kovarianz und Kontravarianz [Seite 363]
3.5.8 - 5.8 Weitere Datentypen [Seite 363]
3.5.8.1 - 5.8.1 BigInteger [Seite 363]
3.5.8.2 - 5.8.2 Complex [Seite 366]
3.5.8.3 - 5.8.3 Tuple<> [Seite 366]
3.5.8.4 - 5.8.4 SortedSet<> [Seite 367]
3.5.9 - 5.9 Praxisbeispiele [Seite 368]
3.5.9.1 - 5.9.1 ArrayList versus generische List [Seite 368]
3.5.9.2 - 5.9.2 Generische IEnumerable-Interfaces implementieren [Seite 372]
3.5.9.3 - 5.9.3 Delegates, anonyme Methoden, Lambda Expressions [Seite 375]
3.5.9.4 - 5.9.4 Dynamischer Zugriff auf COM Interop [Seite 379]
3.6 - 6 Einführung in LINQ [Seite 382]
3.6.1 - 6.1 LINQ-Grundlagen [Seite 382]
3.6.1.1 - 6.1.1 Die LINQ-Architektur [Seite 382]
3.6.1.2 - 6.1.2 Anonyme Typen [Seite 383]
3.6.1.3 - 6.1.3 Erweiterungsmethoden [Seite 385]
3.6.2 - 6.2 Abfragen mit LINQ to Objects [Seite 386]
3.6.2.1 - 6.2.1 Grundlegendes zur LINQ-Syntax [Seite 386]
3.6.2.2 - 6.2.2 Zwei alternative Schreibweisen von LINQ Abfragen [Seite 387]
3.6.2.3 - 6.2.3 Übersicht der wichtigsten Abfrage-Operatoren [Seite 388]
3.6.3 - 6.3 LINQ-Abfragen im Detail [Seite 389]
3.6.3.1 - 6.3.1 Die Projektionsoperatoren Select und SelectMany [Seite 390]
3.6.3.2 - 6.3.2 Der Restriktionsoperator Where [Seite 391]
3.6.3.3 - 6.3.3 Die Sortierungsoperatoren OrderBy und ThenBy [Seite 392]
3.6.3.4 - 6.3.4 Der Gruppierungsoperator GroupBy [Seite 393]
3.6.3.5 - 6.3.5 Verknüpfen mit Join [Seite 396]
3.6.3.6 - 6.3.6 Aggregat-Operatoren [Seite 396]
3.6.3.7 - 6.3.7 Verzögertes Ausführen von LINQ-Abfragen [Seite 398]
3.6.3.8 - 6.3.8 Konvertierungsmethoden [Seite 399]
3.6.3.9 - 6.3.9 Abfragen mit PLINQ [Seite 399]
3.6.4 - 6.4 Praxisbeispiele [Seite 402]
3.6.4.1 - 6.4.1 Die Syntax von LINQ-Abfragen verstehen [Seite 402]
3.6.4.2 - 6.4.2 Aggregat-Abfragen mit LINQ [Seite 405]
3.6.4.3 - 6.4.3 LINQ im Schnelldurchgang erlernen [Seite 408]
3.6.4.4 - 6.4.4 Strings mit LINQ abfragen und filtern [Seite 410]
3.6.4.5 - 6.4.5 Duplikate aus einer Liste oder einem Array entfernen [Seite 411]
3.6.4.6 - 6.4.6 Arrays mit LINQ initialisieren [Seite 414]
3.6.4.7 - 6.4.7 Arrays per LINQ mit Zufallszahlen füllen [Seite 416]
3.6.4.8 - 6.4.8 Einen String mit Wiederholmuster erzeugen [Seite 418]
3.6.4.9 - 6.4.9 Mit LINQ Zahlen und Strings sortieren [Seite 419]
3.6.4.10 - 6.4.10 Mit LINQ Collections von Objekten sortieren [Seite 420]
3.6.4.11 - 6.4.11 Ergebnisse von LINQ-Abfragen in ein Array kopieren [Seite 423]
4 - Teil II: Technologien [Seite 424]
4.1 - 7 Zugriff auf das Dateisystem [Seite 426]
4.1.1 - 7.1 Grundlagen [Seite 426]
4.1.1.1 - 7.1.1 Klassen für den Zugriff auf das Dateisystem [Seite 427]
4.1.1.2 - 7.1.2 Statische versus Instanzen-Klasse [Seite 427]
4.1.2 - 7.2 Übersichten [Seite 428]
4.1.2.1 - 7.2.1 Methoden der Directory-Klasse [Seite 428]
4.1.2.2 - 7.2.2 Methoden eines DirectoryInfo-Objekts [Seite 429]
4.1.2.3 - 7.2.3 Eigenschaften eines DirectoryInfo-Objekts [Seite 429]
4.1.2.4 - 7.2.4 Methoden der File-Klasse [Seite 429]
4.1.2.5 - 7.2.5 Methoden eines FileInfo-Objekts [Seite 430]
4.1.2.6 - 7.2.6 Eigenschaften eines FileInfo-Objekts [Seite 431]
4.1.3 - 7.3 Operationen auf Verzeichnisebene [Seite 431]
4.1.3.1 - 7.3.1 Existenz eines Verzeichnisses/einer Datei feststellen [Seite 431]
4.1.3.2 - 7.3.2 Verzeichnisse erzeugen und löschen [Seite 432]
4.1.3.3 - 7.3.3 Verzeichnisse verschieben und umbenennen [Seite 432]
4.1.3.4 - 7.3.4 Aktuelles Verzeichnis bestimmen [Seite 433]
4.1.3.5 - 7.3.5 Unterverzeichnisse ermitteln [Seite 433]
4.1.3.6 - 7.3.6 Alle Laufwerke ermitteln [Seite 433]
4.1.3.7 - 7.3.7 Dateien kopieren und verschieben [Seite 434]
4.1.3.8 - 7.3.8 Dateien umbenennen [Seite 435]
4.1.3.9 - 7.3.9 Dateiattribute feststellen [Seite 435]
4.1.3.10 - 7.3.10 Verzeichnis einer Datei ermitteln [Seite 437]
4.1.3.11 - 7.3.11 Alle im Verzeichnis enthaltenen Dateien ermitteln [Seite 437]
4.1.3.12 - 7.3.12 Dateien und Unterverzeichnisse ermitteln [Seite 437]
4.1.4 - 7.4 Zugriffsberechtigungen [Seite 438]
4.1.4.1 - 7.4.1 ACL und ACE [Seite 438]
4.1.4.2 - 7.4.2 SetAccessControl-Methode [Seite 439]
4.1.4.3 - 7.4.3 Zugriffsrechte anzeigen [Seite 439]
4.1.5 - 7.5 Weitere wichtige Klassen [Seite 440]
4.1.5.1 - 7.5.1 Die Path-Klasse [Seite 440]
4.1.5.2 - 7.5.2 Die Klasse FileSystemWatcher [Seite 441]
4.1.6 - 7.6 Datei- und Verzeichnisdialoge [Seite 442]
4.1.6.1 - 7.6.1 OpenFileDialog und SaveFileDialog [Seite 443]
4.1.6.2 - 7.6.2 FolderBrowserDialog [Seite 444]
4.1.7 - 7.7 Praxisbeispiele [Seite 445]
4.1.7.1 - 7.7.1 Infos über Verzeichnisse und Dateien gewinnen [Seite 445]
4.1.7.2 - 7.7.2 Eine Verzeichnisstruktur in die TreeView einlesen [Seite 449]
4.1.7.3 - 7.7.3 Mit LINQ und RegEx Verzeichnisbäume durchsuchen [Seite 451]
4.2 - 8 Dateien lesen und schreiben [Seite 456]
4.2.1 - 8.1 Grundprinzip der Datenpersistenz [Seite 456]
4.2.1.1 - 8.1.1 Dateien und Streams [Seite 456]
4.2.1.2 - 8.1.2 Die wichtigsten Klassen [Seite 457]
4.2.1.3 - 8.1.3 Erzeugen eines Streams [Seite 458]
4.2.2 - 8.2 Dateiparameter [Seite 458]
4.2.2.1 - 8.2.1 FileAccess [Seite 458]
4.2.2.2 - 8.2.2 FileMode [Seite 458]
4.2.2.3 - 8.2.3 FileShare [Seite 459]
4.2.3 - 8.3 Textdateien [Seite 459]
4.2.3.1 - 8.3.1 Eine Textdatei beschreiben bzw. neu anlegen [Seite 459]
4.2.3.2 - 8.3.2 Eine Textdatei lesen [Seite 461]
4.2.4 - 8.4 Binärdateien [Seite 462]
4.2.4.1 - 8.4.1 Lese-/Schreibzugriff [Seite 462]
4.2.4.2 - 8.4.2 Die Methoden ReadAllBytes und WriteAllBytes [Seite 463]
4.2.4.3 - 8.4.3 Erzeugen von BinaryReader/BinaryWriter [Seite 463]
4.2.5 - 8.5 Sequenzielle Dateien [Seite 464]
4.2.5.1 - 8.5.1 Lesen und schreiben von strukturierten Daten [Seite 464]
4.2.5.2 - 8.5.2 Serialisieren von Objekten [Seite 465]
4.2.6 - 8.6 Dateien verschlüsseln und komprimieren [Seite 466]
4.2.6.1 - 8.6.1 Das Methodenpärchen Encrypt/Decrypt [Seite 466]
4.2.6.2 - 8.6.2 Verschlüsseln unter Windows Vista/7/8/10 [Seite 466]
4.2.6.3 - 8.6.3 Verschlüsseln mit der CryptoStream-Klasse [Seite 467]
4.2.6.4 - 8.6.4 Dateien komprimieren [Seite 468]
4.2.7 - 8.7 Memory Mapped Files [Seite 469]
4.2.7.1 - 8.7.1 Grundprinzip [Seite 469]
4.2.7.2 - 8.7.2 Erzeugen eines MMF [Seite 470]
4.2.7.3 - 8.7.3 Erstellen eines Map View [Seite 471]
4.2.8 - 8.8 Praxisbeispiele [Seite 472]
4.2.8.1 - 8.8.1 Auf eine Textdatei zugreifen [Seite 472]
4.2.8.2 - 8.8.2 Einen Objektbaum persistent speichern [Seite 475]
4.2.8.3 - 8.8.3 Ein Memory Mapped File (MMF) verwenden [Seite 482]
4.2.8.4 - 8.8.4 Hex-Dezimal-Bytes-Konverter [Seite 484]
4.2.8.5 - 8.8.5 Eine Datei verschlüsseln [Seite 488]
4.2.8.6 - 8.8.6 Eine Datei komprimieren [Seite 491]
4.2.8.7 - 8.8.7 Echte ZIP-Dateien erstellen [Seite 493]
4.2.8.8 - 8.8.8 PDFs erstellen/exportieren [Seite 495]
4.2.8.9 - 8.8.9 Eine CSV-Datei erstellen [Seite 498]
4.2.8.10 - 8.8.10 Eine CSV-Datei mit LINQ lesen und auswerten [Seite 501]
4.2.8.11 - 8.8.11 Einen korrekten Dateinamen erzeugen [Seite 504]
4.3 - 9 Asynchrone Programmierung [Seite 506]
4.3.1 - 9.1 Übersicht [Seite 506]
4.3.1.1 - 9.1.1 Multitasking versus Multithreading [Seite 507]
4.3.1.2 - 9.1.2 Deadlocks [Seite 508]
4.3.1.3 - 9.1.3 Racing [Seite 508]
4.3.2 - 9.2 Programmieren mit Threads [Seite 510]
4.3.2.1 - 9.2.1 Einführungsbeispiel [Seite 510]
4.3.2.2 - 9.2.2 Wichtige Thread-Methoden [Seite 511]
4.3.2.3 - 9.2.3 Wichtige Thread-Eigenschaften [Seite 513]
4.3.2.4 - 9.2.4 Einsatz der ThreadPool-Klasse [Seite 514]
4.3.3 - 9.3 Sperrmechanismen [Seite 516]
4.3.3.1 - 9.3.1 Threading ohne lock [Seite 516]
4.3.3.2 - 9.3.2 Threading mit lock [Seite 518]
4.3.3.3 - 9.3.3 Die Monitor-Klasse [Seite 520]
4.3.3.4 - 9.3.4 Mutex [Seite 523]
4.3.3.5 - 9.3.5 Methoden für die parallele Ausführung sperren [Seite 525]
4.3.3.6 - 9.3.6 Semaphore [Seite 525]
4.3.4 - 9.4 Interaktion mit der Programmoberfläche [Seite 527]
4.3.4.1 - 9.4.1 Die Werkzeuge [Seite 527]
4.3.4.2 - 9.4.2 Einzelne Steuerelemente mit Invoke aktualisieren [Seite 527]
4.3.4.3 - 9.4.3 Mehrere Steuerelemente aktualisieren [Seite 529]
4.3.4.4 - 9.4.4 Ist ein Invoke-Aufruf nötig? [Seite 529]
4.3.4.5 - 9.4.5 Und was ist mit WPF? [Seite 530]
4.3.5 - 9.5 Timer-Threads [Seite 531]
4.3.6 - 9.6 Die BackgroundWorker-Komponente [Seite 532]
4.3.7 - 9.7 Asynchrone Programmier-Entwurfsmuster [Seite 535]
4.3.7.1 - 9.7.1 Kurzübersicht [Seite 535]
4.3.7.2 - 9.7.2 Polling [Seite 536]
4.3.7.3 - 9.7.3 Callback verwenden [Seite 538]
4.3.7.4 - 9.7.4 Callback mit Parameterübergabe verwenden [Seite 539]
4.3.7.5 - 9.7.5 Callback mit Zugriff auf die Programm-Oberfläche [Seite 540]
4.3.8 - 9.8 Asynchroner Aufruf beliebiger Methoden [Seite 541]
4.3.8.1 - 9.8.1 Die Beispielklasse [Seite 541]
4.3.8.2 - 9.8.2 Asynchroner Aufruf ohne Callback [Seite 543]
4.3.8.3 - 9.8.3 Asynchroner Aufruf mit Callback und Anzeigefunktion [Seite 544]
4.3.8.4 - 9.8.4 Aufruf mit Rückgabewerten (per Eigenschaft) [Seite 545]
4.3.8.5 - 9.8.5 Aufruf mit Rückgabewerten (per EndInvoke) [Seite 545]
4.3.9 - 9.9 Es geht auch einfacher - async und await [Seite 546]
4.3.9.1 - 9.9.1 Der Weg von Synchron zu Asynchron [Seite 547]
4.3.9.2 - 9.9.2 Achtung: Fehlerquellen! [Seite 549]
4.3.9.3 - 9.9.3 Eigene asynchrone Methoden entwickeln [Seite 551]
4.3.10 - 9.10 Praxisbeispiele [Seite 553]
4.3.10.1 - 9.10.1 Spieltrieb & Multithreading erleben [Seite 553]
4.3.10.2 - 9.10.2 Prozess- und Thread-Informationen gewinnen [Seite 566]
4.3.10.3 - 9.10.3 Ein externes Programm starten [Seite 571]
4.4 - 10 Die Task Parallel Library [Seite 574]
4.4.1 - 10.1 Überblick [Seite 574]
4.4.1.1 - 10.1.1 Parallel-Programmierung [Seite 574]
4.4.1.2 - 10.1.2 Möglichkeiten der TPL [Seite 577]
4.4.1.3 - 10.1.3 Der CLR-Threadpool [Seite 577]
4.4.2 - 10.2 Parallele Verarbeitung mit Parallel.Invoke [Seite 578]
4.4.2.1 - 10.2.1 Aufrufvarianten [Seite 579]
4.4.2.2 - 10.2.2 Einschränkungen [Seite 580]
4.4.3 - 10.3 Verwendung von Parallel.For [Seite 580]
4.4.3.1 - 10.3.1 Abbrechen der Verarbeitung [Seite 582]
4.4.3.2 - 10.3.2 Auswerten des Verarbeitungsstatus [Seite 583]
4.4.3.3 - 10.3.3 Und was ist mit anderen Iterator-Schrittweiten? [Seite 584]
4.4.4 - 10.4 Collections mit Parallel.ForEach verarbeiten [Seite 584]
4.4.5 - 10.5 Die Task-Klasse [Seite 585]
4.4.5.1 - 10.5.1 Einen Task erzeugen [Seite 585]
4.4.5.2 - 10.5.2 Den Task starten [Seite 586]
4.4.5.3 - 10.5.3 Datenübergabe an den Task [Seite 588]
4.4.5.4 - 10.5.4 Wie warte ich auf das Ende des Task? [Seite 589]
4.4.5.5 - 10.5.5 Tasks mit Rückgabewerten [Seite 591]
4.4.5.6 - 10.5.6 Die Verarbeitung abbrechen [Seite 594]
4.4.5.7 - 10.5.7 Fehlerbehandlung [Seite 597]
4.4.5.8 - 10.5.8 Weitere Eigenschaften [Seite 598]
4.4.6 - 10.6 Zugriff auf das User-Interface [Seite 599]
4.4.6.1 - 10.6.1 Task-Ende und Zugriff auf die Oberfläche [Seite 600]
4.4.6.2 - 10.6.2 Zugriff auf das UI aus dem Task heraus [Seite 601]
4.4.7 - 10.7 Weitere Datenstrukturen im Überblick [Seite 603]
4.4.7.1 - 10.7.1 Threadsichere Collections [Seite 603]
4.4.7.2 - 10.7.2 Primitive für die Threadsynchronisation [Seite 604]
4.4.8 - 10.8 Parallel LINQ (PLINQ) [Seite 604]
4.4.9 - 10.9 Praxisbeispiel: Spieltrieb - Version 2 [Seite 605]
4.4.9.1 - 10.9.1 Aufgabenstellung [Seite 605]
4.4.9.2 - 10.9.2 Global-Klasse [Seite 605]
4.4.9.3 - 10.9.3 Controller-Klasse [Seite 607]
4.4.9.4 - 10.9.4 LKW-Klasse [Seite 608]
4.4.9.5 - 10.9.5 Schiff-Klasse [Seite 610]
4.4.9.6 - 10.9.6 Oberfläche [Seite 612]
4.5 - 11 Fehlersuche und Behandlung [Seite 614]
4.5.1 - 11.1 Der Debugger [Seite 614]
4.5.1.1 - 11.1.1 Allgemeine Beschreibung [Seite 614]
4.5.1.2 - 11.1.2 Die wichtigsten Fenster [Seite 615]
4.5.1.3 - 11.1.3 Debugging-Optionen [Seite 618]
4.5.1.4 - 11.1.4 Praktisches Debugging am Beispiel [Seite 620]
4.5.2 - 11.2 Arbeiten mit Debug und Trace [Seite 624]
4.5.2.1 - 11.2.1 Wichtige Methoden von Debug und Trace [Seite 624]
4.5.2.2 - 11.2.2 Besonderheiten der Trace-Klasse [Seite 628]
4.5.2.3 - 11.2.3 TraceListener-Objekte [Seite 628]
4.5.3 - 11.3 Caller Information [Seite 631]
4.5.3.1 - 11.3.1 Attribute [Seite 631]
4.5.3.2 - 11.3.2 Anwendung [Seite 631]
4.5.4 - 11.4 Fehlerbehandlung [Seite 632]
4.5.4.1 - 11.4.1 Anweisungen zur Fehlerbehandlung [Seite 632]
4.5.4.2 - 11.4.2 try-catch [Seite 633]
4.5.4.3 - 11.4.3 try-finally [Seite 638]
4.5.4.4 - 11.4.4 Das Standardverhalten bei Ausnahmen festlegen [Seite 640]
4.5.4.5 - 11.4.5 Die Exception-Klasse [Seite 641]
4.5.4.6 - 11.4.6 Fehler/Ausnahmen auslösen [Seite 642]
4.5.4.7 - 11.4.7 Eigene Fehlerklassen [Seite 642]
4.5.4.8 - 11.4.8 Exceptionhandling zur Entwurfszeit [Seite 644]
4.5.4.9 - 11.4.9 Code Contracts [Seite 645]
4.6 - 12 XML in Theorie und Praxis [Seite 646]
4.6.1 - 12.1 XML - etwas Theorie [Seite 646]
4.6.1.1 - 12.1.1 Übersicht [Seite 646]
4.6.1.2 - 12.1.2 Der XML-Grundaufbau [Seite 649]
4.6.1.3 - 12.1.3 Wohlgeformte Dokumente [Seite 650]
4.6.1.4 - 12.1.4 Processing Instructions (PI) [Seite 653]
4.6.1.5 - 12.1.5 Elemente und Attribute [Seite 653]
4.6.1.6 - 12.1.6 Verwendbare Zeichensätze [Seite 655]
4.6.2 - 12.2 XSD-Schemas [Seite 657]
4.6.2.1 - 12.2.1 XSD-Schemas und ADO.NET [Seite 657]
4.6.2.2 - 12.2.2 XML-Schemas in Visual Studio analysieren [Seite 659]
4.6.2.3 - 12.2.3 XML-Datei mit XSD-Schema erzeugen [Seite 662]
4.6.2.4 - 12.2.4 XSD-Schema aus einer XML-Datei erzeugen [Seite 663]
4.6.3 - 12.3 Verwendung des DOM unter .NET [Seite 664]
4.6.3.1 - 12.3.1 Übersicht [Seite 664]
4.6.3.2 - 12.3.2 DOM-Integration in C# [Seite 665]
4.6.3.3 - 12.3.3 Laden von Dokumenten [Seite 665]
4.6.3.4 - 12.3.4 Erzeugen von XML-Dokumenten [Seite 666]
4.6.3.5 - 12.3.5 Auslesen von XML-Dateien [Seite 668]
4.6.3.6 - 12.3.6 Direktzugriff auf einzelne Elemente [Seite 670]
4.6.3.7 - 12.3.7 Einfügen von Informationen [Seite 670]
4.6.3.8 - 12.3.8 Suchen in den Baumzweigen [Seite 673]
4.6.4 - 12.4 XML-Verarbeitung mit LINQ to XML [Seite 676]
4.6.4.1 - 12.4.1 Die LINQ to XML-API [Seite 676]
4.6.4.2 - 12.4.2 Neue XML-Dokumente erzeugen [Seite 678]
4.6.4.3 - 12.4.3 Laden und Sichern von XML-Dokumenten [Seite 680]
4.6.4.4 - 12.4.4 Navigieren in XML-Daten [Seite 681]
4.6.4.5 - 12.4.5 Auswählen und Filtern [Seite 683]
4.6.4.6 - 12.4.6 Manipulieren der XML-Daten [Seite 683]
4.6.4.7 - 12.4.7 XML-Dokumente transformieren [Seite 685]
4.6.5 - 12.5 Weitere Möglichkeiten der XML-Verarbeitung [Seite 688]
4.6.5.1 - 12.5.1 Die relationale Sicht mit XmlDataDocument [Seite 688]
4.6.5.2 - 12.5.2 XML-Daten aus Objektstrukturen erzeugen [Seite 691]
4.6.5.3 - 12.5.3 Schnelles Suchen in XML-Daten mit XPathNavigator [Seite 694]
4.6.5.4 - 12.5.4 Schnelles Auslesen von XML-Daten mit XmlReader [Seite 697]
4.6.5.5 - 12.5.5 Erzeugen von XML-Daten mit XmlWriter [Seite 699]
4.6.5.6 - 12.5.6 XML transformieren mit XSLT [Seite 701]
4.6.6 - 12.6 Praxisbeispiele [Seite 703]
4.6.6.1 - 12.6.1 Mit dem DOM in XML-Dokumenten navigieren [Seite 703]
4.6.6.2 - 12.6.2 XML-Daten in eine TreeView einlesen [Seite 706]
4.6.6.3 - 12.6.3 Ein DataSet in einen XML-String konvertieren [Seite 710]
4.6.6.4 - 12.6.4 Ein DataSet in einer XML-Datei speichern [Seite 714]
4.6.6.5 - 12.6.5 In Dokumenten mit dem XPathNavigator navigieren [Seite 717]
4.7 - 13 Einführung in ADO.NET [Seite 722]
4.7.1 - 13.1 Eine kleine Übersicht [Seite 722]
4.7.1.1 - 13.1.1 Die ADO.NET-Klassenhierarchie [Seite 722]
4.7.1.2 - 13.1.2 Die Klassen der Datenprovider [Seite 723]
4.7.1.3 - 13.1.3 Das Zusammenspiel der ADO.NET-Klassen [Seite 726]
4.7.2 - 13.2 Das Connection-Objekt [Seite 727]
4.7.2.1 - 13.2.1 Allgemeiner Aufbau [Seite 727]
4.7.2.2 - 13.2.2 OleDbConnection [Seite 727]
4.7.2.3 - 13.2.3 Schließen einer Verbindung [Seite 729]
4.7.2.4 - 13.2.4 Eigenschaften des Connection-Objekts [Seite 729]
4.7.2.5 - 13.2.5 Methoden des Connection-Objekts [Seite 731]
4.7.2.6 - 13.2.6 Der ConnectionStringBuilder [Seite 732]
4.7.3 - 13.3 Das Command-Objekt [Seite 732]
4.7.3.1 - 13.3.1 Erzeugen und Anwenden eines Command-Objekts [Seite 733]
4.7.3.2 - 13.3.2 Erzeugen mittels CreateCommand-Methode [Seite 733]
4.7.3.3 - 13.3.3 Eigenschaften des Command-Objekts [Seite 734]
4.7.3.4 - 13.3.4 Methoden des Command-Objekts [Seite 736]
4.7.3.5 - 13.3.5 Freigabe von Connection- und Command-Objekten [Seite 737]
4.7.4 - 13.4 Parameter-Objekte [Seite 738]
4.7.4.1 - 13.4.1 Erzeugen und Anwenden eines Parameter-Objekts [Seite 738]
4.7.4.2 - 13.4.2 Eigenschaften des Parameter-Objekts [Seite 739]
4.7.5 - 13.5 Das CommandBuilder-Objekt [Seite 740]
4.7.5.1 - 13.5.1 Erzeugen [Seite 740]
4.7.5.2 - 13.5.2 Anwenden [Seite 740]
4.7.6 - 13.6 Das DataReader-Objekt [Seite 741]
4.7.6.1 - 13.6.1 DataReader erzeugen [Seite 741]
4.7.6.2 - 13.6.2 Daten lesen [Seite 742]
4.7.6.3 - 13.6.3 Eigenschaften des DataReaders [Seite 743]
4.7.6.4 - 13.6.4 Methoden des DataReaders [Seite 743]
4.7.7 - 13.7 Das DataAdapter-Objekt [Seite 744]
4.7.7.1 - 13.7.1 DataAdapter erzeugen [Seite 744]
4.7.7.2 - 13.7.2 Command-Eigenschaften [Seite 745]
4.7.7.3 - 13.7.3 Fill-Methode [Seite 746]
4.7.7.4 - 13.7.4 Update-Methode [Seite 747]
4.7.8 - 13.8 Praxisbeispiele [Seite 748]
4.7.8.1 - 13.8.1 Wichtige ADO.NET-Objekte im Einsatz [Seite 748]
4.7.8.2 - 13.8.2 Eine Aktionsabfrage ausführen [Seite 749]
4.7.8.3 - 13.8.3 Eine Auswahlabfrage aufrufen [Seite 752]
4.7.8.4 - 13.8.4 Die Datenbank aktualisieren [Seite 754]
4.8 - 14 Das DataSet [Seite 758]
4.8.1 - 14.1 Grundlegende Features des DataSets [Seite 758]
4.8.1.1 - 14.1.1 Die Objekthierarchie [Seite 759]
4.8.1.2 - 14.1.2 Die wichtigsten Klassen [Seite 759]
4.8.1.3 - 14.1.3 Erzeugen eines DataSets [Seite 760]
4.8.2 - 14.2 Das DataTable-Objekt [Seite 761]
4.8.2.1 - 14.2.1 DataTable erzeugen [Seite 762]
4.8.2.2 - 14.2.2 Spalten hinzufügen [Seite 762]
4.8.2.3 - 14.2.3 Zeilen zur DataTable hinzufügen [Seite 763]
4.8.2.4 - 14.2.4 Auf den Inhalt einer DataTable zugreifen [Seite 764]
4.8.3 - 14.3 Die DataView [Seite 766]
4.8.3.1 - 14.3.1 Erzeugen einer DataView [Seite 766]
4.8.3.2 - 14.3.2 Sortieren und Filtern von Datensätzen [Seite 766]
4.8.3.3 - 14.3.3 Suchen von Datensätzen [Seite 767]
4.8.4 - 14.4 Typisierte DataSets [Seite 767]
4.8.4.1 - 14.4.1 Ein typisiertes DataSet erzeugen [Seite 768]
4.8.4.2 - 14.4.2 Das Konzept der Datenquellen [Seite 769]
4.8.4.3 - 14.4.3 Typisierte DataSets und TableAdapter [Seite 770]
4.8.5 - 14.5 Die Qual der Wahl [Seite 771]
4.8.5.1 - 14.5.1 DataReader - der schnelle Lesezugriff [Seite 772]
4.8.5.2 - 14.5.2 DataSet - die Datenbank im Hauptspeicher [Seite 772]
4.8.5.3 - 14.5.3 Objektrelationales Mapping - die Zukunft? [Seite 773]
4.8.6 - 14.6 Praxisbeispiele [Seite 774]
4.8.6.1 - 14.6.1 In der DataView sortieren und filtern [Seite 774]
4.8.6.2 - 14.6.2 Suche nach Datensätzen [Seite 776]
4.8.6.3 - 14.6.3 Ein DataSet in einen XML-String serialisieren [Seite 777]
4.8.6.4 - 14.6.4 Untypisiertes in ein typisiertes DataSet konvertieren [Seite 782]
4.8.6.5 - 14.6.5 Eine LINQ to SQL-Abfrage ausführen [Seite 787]
4.9 - 15 Verteilen von Anwendungen [Seite 792]
4.9.1 - 15.1 ClickOnce-Deployment [Seite 793]
4.9.1.1 - 15.1.1 Übersicht/Einschränkungen [Seite 793]
4.9.1.2 - 15.1.2 Die Vorgehensweise [Seite 794]
4.9.1.3 - 15.1.3 Ort der Veröffentlichung [Seite 794]
4.9.1.4 - 15.1.4 Anwendungsdateien [Seite 795]
4.9.1.5 - 15.1.5 Erforderliche Komponenten [Seite 795]
4.9.1.6 - 15.1.6 Aktualisierungen [Seite 796]
4.9.1.7 - 15.1.7 Veröffentlichungsoptionen [Seite 797]
4.9.1.8 - 15.1.8 Veröffentlichen [Seite 798]
4.9.1.9 - 15.1.9 Verzeichnisstruktur [Seite 798]
4.9.1.10 - 15.1.10 Der Webpublishing-Assistent [Seite 800]
4.9.1.11 - 15.1.11 Neue Versionen erstellen [Seite 801]
4.9.2 - 15.2 InstallShield [Seite 801]
4.9.2.1 - 15.2.1 Installation [Seite 801]
4.9.2.2 - 15.2.2 Aktivieren [Seite 802]
4.9.2.3 - 15.2.3 Ein neues Setup-Projekt [Seite 802]
4.9.2.4 - 15.2.4 Finaler Test [Seite 810]
4.9.3 - 15.3 Hilfedateien programmieren [Seite 810]
4.9.3.1 - 15.3.1 Der HTML Help Workshop [Seite 811]
4.9.3.2 - 15.3.2 Bedienung am Beispiel [Seite 812]
4.9.3.3 - 15.3.3 Hilfedateien in die Visual C#-Anwendung einbinden [Seite 814]
4.9.3.4 - 15.3.4 Eine alternative Hilfe-IDE verwenden [Seite 818]
4.10 - 16 Weitere Techniken [Seite 820]
4.10.1 - 16.1 Zugriff auf die Zwischenablage [Seite 820]
4.10.1.1 - 16.1.1 Das Clipboard-Objekt [Seite 820]
4.10.1.2 - 16.1.2 Zwischenablage-Funktionen für Textboxen [Seite 822]
4.10.2 - 16.2 Arbeiten mit der Registry [Seite 822]
4.10.2.1 - 16.2.1 Allgemeines [Seite 823]
4.10.2.2 - 16.2.2 Registry-Unterstützung in .NET [Seite 825]
4.10.3 - 16.3 .NET-Reflection [Seite 826]
4.10.3.1 - 16.3.1 Übersicht [Seite 826]
4.10.3.2 - 16.3.2 Assembly laden [Seite 826]
4.10.3.3 - 16.3.3 Mittels GetType und Type Informationen sammeln [Seite 827]
4.10.3.4 - 16.3.4 Dynamisches Laden von Assemblies [Seite 829]
4.10.4 - 16.4 Praxisbeispiele [Seite 832]
4.10.4.1 - 16.4.1 Zugriff auf die Registry [Seite 832]
4.10.4.2 - 16.4.2 Dateiverknüpfungen erzeugen [Seite 834]
4.10.4.3 - 16.4.3 Betrachter für Manifestressourcen [Seite 836]
4.10.4.4 - 16.4.4 Die Zwischenablage überwachen und anzeigen [Seite 839]
4.10.4.5 - 16.4.5 Die WIA-Library kennenlernen [Seite 842]
4.10.4.6 - 16.4.6 Auf eine Webcam zugreifen [Seite 854]
4.10.4.7 - 16.4.7 Auf den Scanner zugreifen [Seite 856]
4.10.4.8 - 16.4.8 OpenOffice.org Writer per OLE steuern [Seite 861]
4.10.4.9 - 16.4.9 Nutzer und Gruppen des aktuellen Systems ermitteln [Seite 869]
4.10.4.10 - 16.4.10 Testen, ob Nutzer in einer Gruppe enthalten ist [Seite 870]
4.10.4.11 - 16.4.11 Testen, ob der Nutzer ein Administrator ist [Seite 872]
4.10.4.12 - 16.4.12 Die IP-Adressen des Computers bestimmen [Seite 873]
4.10.4.13 - 16.4.13 Die IP-Adresse über den Hostnamen bestimmen [Seite 874]
4.10.4.14 - 16.4.14 Diverse Systeminformationen ermitteln [Seite 875]
4.10.4.15 - 16.4.15 Environment Variablen auslesen [Seite 879]
4.10.4.16 - 16.4.16 Alles über den Bildschirm erfahren [Seite 883]
4.10.4.17 - 16.4.17 Sound per MCI aufnehmen [Seite 884]
4.10.4.18 - 16.4.18 Mikrofonpegel anzeigen [Seite 888]
4.10.4.19 - 16.4.19 Pegeldiagramm aufzeichnen [Seite 889]
4.10.4.20 - 16.4.20 Sound-und Video-Dateien per MCI abspielen [Seite 893]
4.11 - 17 Konsolenanwendungen [Seite 902]
4.11.1 - 17.1 Grundaufbau/Konzepte [Seite 902]
4.11.1.1 - 17.1.1 Unser Hauptprogramm - Program.cs [Seite 903]
4.11.1.2 - 17.1.2 Rückgabe eines Fehlerstatus [Seite 904]
4.11.1.3 - 17.1.3 Parameterübergabe [Seite 905]
4.11.1.4 - 17.1.4 Zugriff auf die Umgebungsvariablen [Seite 906]
4.11.2 - 17.2 Die Kommandozentrale: System.Console [Seite 907]
4.11.2.1 - 17.2.1 Eigenschaften [Seite 908]
4.11.2.2 - 17.2.2 Methoden/Ereignisse [Seite 908]
4.11.2.3 - 17.2.3 Textausgaben [Seite 909]
4.11.2.4 - 17.2.4 Farbangaben [Seite 910]
4.11.2.5 - 17.2.5 Tastaturabfragen [Seite 911]
4.11.2.6 - 17.2.6 Arbeiten mit Streamdaten [Seite 912]
4.11.3 - 17.3 Praxisbeispiel [Seite 914]
4.11.3.1 - 17.3.1 Farbige Konsolenanwendung [Seite 914]
4.11.3.2 - 17.3.2 Weitere Hinweise und Beispiele [Seite 916]
5 - Teil III: Windows Apps [Seite 918]
5.1 - 18 Erste Schritte [Seite 920]
5.1.1 - 18.1 Grundkonzepte und Begriffe [Seite 920]
5.1.1.1 - 18.1.1 Windows Runtime (WinRT) [Seite 920]
5.1.1.2 - 18.1.2 Windows Apps [Seite 921]
5.1.1.3 - 18.1.3 Fast and Fluid [Seite 922]
5.1.1.4 - 18.1.4 Process Sandboxing und Contracts [Seite 923]
5.1.1.5 - 18.1.5 .NET WinRT-Profil [Seite 925]
5.1.1.6 - 18.1.6 Language Projection [Seite 925]
5.1.1.7 - 18.1.7 Vollbildmodus - War da was? [Seite 927]
5.1.1.8 - 18.1.8 Windows Store [Seite 927]
5.1.1.9 - 18.1.9 Zielplattformen [Seite 928]
5.1.2 - 18.2 Entwurfsumgebung [Seite 929]
5.1.2.1 - 18.2.1 Betriebssystem [Seite 929]
5.1.2.2 - 18.2.2 Windows-Simulator [Seite 929]
5.1.2.3 - 18.2.3 Remote-Debugging [Seite 932]
5.1.3 - 18.3 Ein (kleines) Einstiegsbeispiel [Seite 933]
5.1.3.1 - 18.3.1 Aufgabenstellung [Seite 933]
5.1.3.2 - 18.3.2 Quellcode [Seite 933]
5.1.3.3 - 18.3.3 Oberflächenentwurf [Seite 936]
5.1.3.4 - 18.3.4 Installation und Test [Seite 938]
5.1.3.5 - 18.3.5 Touchscreen [Seite 940]
5.1.3.6 - 18.3.6 Fazit [Seite 940]
5.1.4 - 18.4 Weitere Details zu WinRT [Seite 942]
5.1.4.1 - 18.4.1 Wo ist WinRT einzuordnen? [Seite 943]
5.1.4.2 - 18.4.2 Die WinRT-API [Seite 944]
5.1.4.3 - 18.4.3 Wichtige WinRT-Namespaces [Seite 946]
5.1.4.4 - 18.4.4 Der Unterbau [Seite 947]
5.1.5 - 18.5 Praxisbeispiel [Seite 949]
5.1.5.1 - 18.5.1 WinRT in Desktop-Applikationen nutzen [Seite 949]
5.2 - 19 App-Oberflächen entwerfen [Seite 954]
5.2.1 - 19.1 Grundkonzepte [Seite 954]
5.2.1.1 - 19.1.1 XAML (oder HTML 5) für die Oberfläche [Seite 955]
5.2.1.2 - 19.1.2 Die Page, der Frame und das Window [Seite 956]
5.2.1.3 - 19.1.3 Das Befehlsdesign [Seite 958]
5.2.1.4 - 19.1.4 Die Navigationsdesigns [Seite 960]
5.2.1.5 - 19.1.5 Achtung: Fingereingabe! [Seite 961]
5.2.1.6 - 19.1.6 Verwendung von Schriftarten [Seite 961]
5.2.2 - 19.2 Seitenauswahl und -navigation [Seite 962]
5.2.2.1 - 19.2.1 Die Startseite festlegen [Seite 962]
5.2.2.2 - 19.2.2 Navigation und Parameterübergabe [Seite 962]
5.2.2.3 - 19.2.3 Den Seitenstatus erhalten [Seite 963]
5.2.3 - 19.3 App-Darstellung [Seite 964]
5.2.3.1 - 19.3.1 Vollbild quer und hochkant [Seite 964]
5.2.3.2 - 19.3.2 Was ist mit Andocken und Füllmodus? [Seite 965]
5.2.3.3 - 19.3.3 Reagieren auf die Änderung [Seite 965]
5.2.4 - 19.4 Skalieren von Apps [Seite 967]
5.2.5 - 19.5 Praxisbeispiele [Seite 970]
5.2.5.1 - 19.5.1 Seitennavigation und Parameterübergabe [Seite 970]
5.2.5.2 - 19.5.2 Die Fensterkopfzeile anpassen [Seite 972]
5.3 - 20 Die wichtigsten Controls [Seite 974]
5.3.1 - 20.1 Einfache WinRT-Controls [Seite 974]
5.3.1.1 - 20.1.1 TextBlock, RichTextBlock [Seite 974]
5.3.1.2 - 20.1.2 Button, HyperlinkButton, RepeatButton [Seite 977]
5.3.1.3 - 20.1.3 CheckBox, RadioButton, ToggleButton, ToggleSwitch [Seite 979]
5.3.1.4 - 20.1.4 TextBox, PasswordBox, RichEditBox [Seite 980]
5.3.1.5 - 20.1.5 Image [Seite 984]
5.3.1.6 - 20.1.6 ScrollBar, Slider, ProgressBar, ProgressRing [Seite 986]
5.3.1.7 - 20.1.7 Border, Ellipse, Rectangle [Seite 987]
5.3.2 - 20.2 Layout-Controls [Seite 988]
5.3.2.1 - 20.2.1 Canvas [Seite 988]
5.3.2.2 - 20.2.2 StackPanel [Seite 989]
5.3.2.3 - 20.2.3 ScrollViewer [Seite 989]
5.3.2.4 - 20.2.4 Grid [Seite 990]
5.3.2.5 - 20.2.5 VariableSizedWrapGrid [Seite 991]
5.3.2.6 - 20.2.6 SplitView [Seite 992]
5.3.2.7 - 20.2.7 Pivot [Seite 996]
5.3.2.8 - 20.2.8 RelativPanel [Seite 998]
5.3.3 - 20.3 Listendarstellungen [Seite 1000]
5.3.3.1 - 20.3.1 ComboBox, ListBox [Seite 1000]
5.3.3.2 - 20.3.2 ListView [Seite 1004]
5.3.3.3 - 20.3.3 GridView [Seite 1005]
5.3.3.4 - 20.3.4 FlipView [Seite 1007]
5.3.4 - 20.4 Sonstige Controls [Seite 1009]
5.3.4.1 - 20.4.1 CaptureElement [Seite 1009]
5.3.4.2 - 20.4.2 MediaElement [Seite 1011]
5.3.4.3 - 20.4.3 Frame [Seite 1012]
5.3.4.4 - 20.4.4 WebView [Seite 1012]
5.3.4.5 - 20.4.5 ToolTip [Seite 1013]
5.3.4.6 - 20.4.6 CalendarDatePicker [Seite 1015]
5.3.4.7 - 20.4.7 DatePicker/TimePicker [Seite 1016]
5.3.5 - 20.5 Praxisbeispiele [Seite 1016]
5.3.5.1 - 20.5.1 Einen StringFormat-Konverter implementieren [Seite 1016]
5.3.5.2 - 20.5.2 Besonderheiten der TextBox kennen lernen [Seite 1018]
5.3.5.3 - 20.5.3 Daten in der GridView gruppieren [Seite 1022]
5.3.5.4 - 20.5.4 Das SemanticZoom-Control verwenden [Seite 1026]
5.3.5.5 - 20.5.5 Die CollectionViewSource verwenden [Seite 1031]
5.3.5.6 - 20.5.6 Zusammenspiel ListBox/AppBar [Seite 1034]
5.4 - 21 Apps im Detail [Seite 1038]
5.4.1 - 21.1 Ein Windows App-Projekt im Detail [Seite 1038]
5.4.1.1 - 21.1.1 Contracts und Extensions [Seite 1039]
5.4.1.2 - 21.1.2 AssemblyInfo.cs [Seite 1039]
5.4.1.3 - 21.1.3 Verweise [Seite 1041]
5.4.1.4 - 21.1.4 App.xaml und App.xaml.cs [Seite 1041]
5.4.1.5 - 21.1.5 Package.appxmanifest [Seite 1042]
5.4.1.6 - 21.1.6 Application1_TemporaryKey.pfx [Seite 1047]
5.4.1.7 - 21.1.7 MainPage.xaml & MainPage.xaml.cs [Seite 1047]
5.4.1.8 - 21.1.8 Assets/Symbole [Seite 1048]
5.4.1.9 - 21.1.9 Nach dem Kompilieren [Seite 1048]
5.4.2 - 21.2 Der Lebenszyklus einer Windows App [Seite 1048]
5.4.2.1 - 21.2.1 Möglichkeiten der Aktivierung von Apps [Seite 1050]
5.4.2.2 - 21.2.2 Der Splash Screen [Seite 1052]
5.4.2.3 - 21.2.3 Suspending [Seite 1052]
5.4.2.4 - 21.2.4 Resuming [Seite 1054]
5.4.2.5 - 21.2.5 Beenden von Apps [Seite 1054]
5.4.2.6 - 21.2.6 Die Ausnahmen von der Regel [Seite 1055]
5.4.2.7 - 21.2.7 Debuggen [Seite 1055]
5.4.3 - 21.3 Daten speichern und laden [Seite 1059]
5.4.3.1 - 21.3.1 Grundsätzliche Überlegungen [Seite 1059]
5.4.3.2 - 21.3.2 Worauf und wie kann ich zugreifen? [Seite 1059]
5.4.3.3 - 21.3.3 Das AppData-Verzeichnis [Seite 1060]
5.4.3.4 - 21.3.4 Das Anwendungs-Installationsverzeichnis [Seite 1062]
5.4.3.5 - 21.3.5 Das Downloads-Verzeichnis [Seite 1063]
5.4.3.6 - 21.3.6 Sonstige Verzeichnisse [Seite 1064]
5.4.3.7 - 21.3.7 Anwendungsdaten lokal sichern und laden [Seite 1064]
5.4.3.8 - 21.3.8 Daten in der Cloud ablegen/laden (Roaming) [Seite 1066]
5.4.3.9 - 21.3.9 Aufräumen [Seite 1068]
5.4.3.10 - 21.3.10 Sensible Informationen speichern [Seite 1069]
5.4.4 - 21.4 Praxisbeispiele [Seite 1070]
5.4.4.1 - 21.4.1 Die Auto-Play-Funktion unterstützen [Seite 1070]
5.4.4.2 - 21.4.2 Einen zusätzlichen Splash Screen einsetzen [Seite 1074]
5.4.4.3 - 21.4.3 Eine Dateiverknüpfung erstellen [Seite 1076]
5.5 - 22 App-Techniken [Seite 1082]
5.5.1 - 22.1 Arbeiten mit Dateien/Verzeichnissen [Seite 1082]
5.5.1.1 - 22.1.1 Verzeichnisinformationen auflisten [Seite 1082]
5.5.1.2 - 22.1.2 Unterverzeichnisse auflisten [Seite 1085]
5.5.1.3 - 22.1.3 Verzeichnisse erstellen/löschen [Seite 1086]
5.5.1.4 - 22.1.4 Dateien auflisten [Seite 1088]
5.5.1.5 - 22.1.5 Dateien erstellen/schreiben/lesen [Seite 1090]
5.5.1.6 - 22.1.6 Dateien kopieren/umbenennen/löschen [Seite 1094]
5.5.1.7 - 22.1.7 Verwenden der Dateipicker [Seite 1095]
5.5.1.8 - 22.1.8 StorageFile-/StorageFolder-Objekte speichern [Seite 1100]
5.5.1.9 - 22.1.9 Verwenden der Most Recently Used-Liste [Seite 1102]
5.5.2 - 22.2 Datenaustausch zwischen Apps/Programmen [Seite 1103]
5.5.2.1 - 22.2.1 Zwischenablage [Seite 1103]
5.5.2.2 - 22.2.2 Teilen von Inhalten [Seite 1110]
5.5.2.3 - 22.2.3 Eine App als Freigabeziel verwenden [Seite 1114]
5.5.2.4 - 22.2.4 Zugriff auf die Kontaktliste [Seite 1115]
5.5.3 - 22.3 Spezielle Oberflächenelemente [Seite 1116]
5.5.3.1 - 22.3.1 MessageDialog [Seite 1117]
5.5.3.2 - 22.3.2 ContentDialog [Seite 1120]
5.5.3.3 - 22.3.3 Popup-Benachrichtigungen [Seite 1122]
5.5.3.4 - 22.3.4 PopUp/Flyouts [Seite 1130]
5.5.3.5 - 22.3.5 Das PopupMenu einsetzen [Seite 1133]
5.5.3.6 - 22.3.6 Eine AppBar/CommandBar verwenden [Seite 1134]
5.5.4 - 22.4 Datenbanken und Windows Store Apps [Seite 1138]
5.5.4.1 - 22.4.1 Der Retter in der Not: SQLite! [Seite 1138]
5.5.4.2 - 22.4.2 Verwendung/Kurzüberblick [Seite 1139]
5.5.4.3 - 22.4.3 Installation [Seite 1140]
5.5.4.4 - 22.4.4 Wie kommen wir zu einer neuen Datenbank? [Seite 1141]
5.5.4.5 - 22.4.5 Wie werden die Daten manipuliert? [Seite 1145]
5.5.5 - 22.5 Vertrieb der App [Seite 1147]
5.5.5.1 - 22.5.1 Verpacken der App [Seite 1147]
5.5.5.2 - 22.5.2 App-Installation per Skript [Seite 1149]
5.5.6 - 22.6 Ein Blick auf die App-Schwachstellen [Seite 1150]
5.5.6.1 - 22.6.1 Quellcodes im Installationsverzeichnis [Seite 1150]
5.5.6.2 - 22.6.2 Zugriff auf den App-Datenordner [Seite 1152]
5.5.7 - 22.7 Praxisbeispiele [Seite 1153]
5.5.7.1 - 22.7.1 Ein Verzeichnis auf Änderungen überwachen [Seite 1153]
5.5.7.2 - 22.7.2 Eine App als Freigabeziel verwenden [Seite 1155]
5.5.7.3 - 22.7.3 ToastNotifications einfach erzeugen [Seite 1160]
6 - Anhang [Seite 1166]
6.1 - A Glossar [Seite 1168]
6.2 - B Wichtige Dateiextensions [Seite 1174]
7 - Index [Seite 1176]
8 - Download-Kapitel [Seite 30]

Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

39,99 €
inkl. 7% MwSt.
Download / Einzel-Lizenz
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
E-Book bestellen