C# 8 mit Visual Studio 2019

Das umfassende C#-Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken. Aktuell zu Visual Studio 2019
8. aktualisierte Auflage 2019
ISBN: 978-3-8362-6458-7
Verlag: Rheinwerk Verlag GmbH

Buch, Deutsch, 1478 Seiten, Format (B × H): 195 mm x 249 mm, Gewicht: 2502 g

Reihe: Rheinwerk Computing

Sie haben Fragen zur C#-Entwicklung? Unser bewährtes Kompendium steht Ihnen mit Rat und Tat zur Seite. Mittlerweile in der 8. Auflage dient es ambitionierten Ein- und Umsteigern durch seine strukturierte Vorgehensweise und die zahlreichen Anwendungsbeispiele als praxisorientierte Einführung. Fortgeschrittene und Profis unterstützt es als Nachschlagewerk optimal bei ihrer täglichen Arbeit.

Nach den Grundlagen von C#,.NET und objektorientierter Programmierung geht es weiter mit Visual Studio 2019, Fehlerbehandlung sowie fortgeschrittenen C#-Themen wie LINQ, Multithreading, Serialisierung u. v. m. Den größten Themenblock bildet die Entwicklung von grafischen Benutzeroberflächen. Neben einer fundierten Einführung in WPF, XAML und MVVM erfahren Sie hier alles Notwendige, um auch komplexe Anwendungen zu gestalten. Anschließend wird die Datenbankprogrammierung mit Entity Framework ausführlich behandelt. Auch das Unit-Testing kommt nicht zu kurz. So sind Sie für Ihren Arbeitsalltag bestens gerüstet!

Aus dem Inhalt:

- C#-Spracheinführung

- Visual Studio 2019

- Objektorientierte Programmierung

- Fehlerbehandlung und Debugging

- Language Integrated Query (LINQ)

- Multithreading und Task Parallel Library

- GUI-Entwicklung mit WPF

- Model View ViewModel (MVVM)

- Datenbankprogrammierung mit Entity Framework

- Unit-Testing

Autoren/Hrsg.

Kühnel, Andreas

Fachgebiete

• Mathematik | Informatik EDV | Informatik Programmierung | Softwareentwicklung Objektorientierte Programmierung
• Mathematik | Informatik EDV | Informatik Programmierung | Softwareentwicklung Microsoft Programmierung .NET Programmierung
• Mathematik | Informatik EDV | Informatik Programmierung | Softwareentwicklung Programmier- und Skriptsprachen

Inhaltsverzeichnis

Materialien zum Buch. 32

  Vorwort zur 8. Auflage. 34

  1.  Allgemeine Einführung in.NET. 37

       1.1. Warum.NET?. 37

       1.2.NET unter die Lupe genommen. 43

       1.3. Assemblies. 53

       1.4. Die Entwicklungsumgebung. 55

  2.  Grundlagen der Sprache C#. 65

       2.1. Konsolenanwendungen. 65

       2.2. Grundlagen der C#-Syntax. 70

       2.3. Variablen und Datentypen. 75

       2.4. Operatoren. 97

       2.5. Datenfelder (Arrays). 110

       2.6. Kontrollstrukturen. 118

       2.7. Programmschleifen. 129

  3.  Das Klassendesign. 145

       3.1. Einführung in die Objektorientierung. 145

       3.2. Die Klassendefinition. 148

       3.3. Referenz- und Wertetypen. 155

       3.4. Die Eigenschaften eines Objekts. 157

       3.5. Methoden eines Objekts. 164

       3.6. Konstruktoren. 191

       3.7. Der Destruktor. 198

       3.8. Konstanten in einer Klasse. 199

       3.9. Statische Klassenkomponenten. 200

       3.10. Namensräume (Namespaces). 207

       3.11. Aktueller Stand der Klasse 'Circle'. 217

  4.  Vererbung, Polymorphie und Interfaces. 221

       4.1. Die Vererbung. 221

       4.2. Der Problemfall geerbter Methoden. 230

       4.3. Typkonvertierung und Typuntersuchung von Objektvariablen. 237

       4.4. Polymorphie. 243

       4.5. Weitere Gesichtspunkte der Vererbung. 250

       4.6. Das Projekt 'GeometricObjectsSolution' ergänzen. 253

       4.7. Eingebettete Klassen. 257

       4.8. Interfaces (Schnittstellen). 258

       4.9. Das Zerstören von Objekten -- der Garbage Collector. 273

       4.10. Die Ergänzungen in den Klassen 'Circle' und 'Rectangle'. 280

  5.  Delegaten, Ereignisse und Lambda-Ausdrücke. 283

       5.1. Delegaten. 283

       5.2. Ereignisse eines Objekts. 293

       5.3. Lambda-Ausdrücke. 310

       5.4. Änderungen im Projekt 'GeometricObjectsSolution'. 314

  6.  Strukturen und Enumerationen. 319

       6.1. Strukturen -- eine Sonderform der Klassen. 319

       6.2. Enumerationen (Aufzählungen). 325

       6.3. Boxing und Unboxing. 328

  7.  Fehlerbehandlung und Debugging. 331

       7.1. Laufzeitfehler erkennen. 332

       7.2. Debuggen mit Programmcode. 355

       7.3. Fehlersuche mit Visual Studio. 363

  8.  Auflistungsklassen (Collections). 371

       8.1. Collections im Namespace 'System.Collections'. 371

       8.2. Die Klasse 'ArrayList'. 375

       8.3. Die Klasse 'Hashtable'. 387

       8.4. Die Klassen 'Queue' und 'Stack'. 393

       8.5. Eigene Auflistungen mit 'yield' durchlaufen. 396

  9.  Generics -- generische Datentypen. 401

       9.1. Bereitstellen einer generischen Klasse. 403

       9.2. Bedingungen (Constraints) festlegen. 406

       9.3. Generische Methoden. 410

       9.4. Generics und Vererbung. 411

       9.5. Typkonvertierung von Generics. 413

       9.6. Generische Delegaten. 414

       9.7. 'Nullable'-Typen. 415

       9.8. Generische Collections. 417

       9.9. Kovarianz und Kontravarianz generischer Typen. 421

       9.10. Ergänzungen im Beispielprojekt 'GeometricObjectsSolution'. 426

10.  Weitere C#-Sprachfeatures. 429

       10.1. Implizit typisierte Variablen. 429

       10.2. Anonyme Typen. 430

       10.3. Erweiterungsmethoden. 431

       10.4. Spezielle Methoden. 435

       10.5. Operatorüberladung. 442

       10.6. 'Nullable'-Referenztypen. 452

       10.7. Indexer. 459

       10.8. Attribute. 466

       10.9. Der bedingte NULL-Operator. 479

       10.10. Der 'nameof'-Operator. 480

       10.11. Dynamisches Binden. 482

       10.12. Tupel. 485

       10.13. Pattern Matching (Musterabgleich). 492

       10.14. Rückgabewerte mit 'ref'. 496

       10.15. Unsicherer (unsafe) Programmcode -- Zeigertechnik in C#. 498

11.  LINQ -- Language Integrated Query. 505

       11.1. Einstieg in LINQ?. 505

       11.2. LINQ to Objects. 511

       11.3. Die Abfrageoperatoren. 515

12.  Arbeiten mit Dateien und Streams. 539

       12.1. Einführung. 539

       12.2. Namespaces der Ein- bzw. Ausgabe. 540

       12.3. Laufwerke, Verzeichnisse und Dateien. 541

       12.4. Die 'Stream'-Klassen. 558

       12.5. Die Klassen 'TextReader' und 'TextWriter'. 569

       12.6. Die Klassen 'BinaryReader' und 'BinaryWriter'. 575

13.  Serialisierung. 585

       13.1. Serialisierungsverfahren. 586

       13.2. Binäre Serialisierung mit 'BinaryFormatter'. 587

       13.3. Serialisierung mit 'XmlSerializer'. 593

14.  Multithreading. 599

       14.1. Einführung in das Multithreading. 600

       14.2. Threads -- allgemein betrachtet. 601

       14.3. Mit der Klasse 'Thread' arbeiten. 603

       14.4. Der Threadpool. 614

       14.5. Synchronisation von Threads. 616

       14.6. Grundlagen asynchroner Methodenaufrufe. 639

15.  Die Task Parallel Library (TPL). 651

       15.1. Die wichtigsten Klassen der TPL. 652

       15.2. Die Klasse 'Task'. 652

       15.3. Die Klasse 'Parallel'. 665

       15.4. Asynchrone Programmierung mit 'async' und 'await'. 671

16.  Grundlegende.NET-Klassen. 679

       16.1. Die Klasse 'Object'. 679

       16.2. Die Klasse 'String'. 685

       16.3. Die Klasse 'StringBuilder'. 699

       16.4. Der Typ 'DateTime'. 705

       16.5. Die Klasse 'TimeSpan'. 709

       16.6. Ausgabeformatierung. 712

17.  Projektmanagement und Visual Studio 2019. 721

       17.1. Der Projekttyp 'Klassenbibliothek'. 721

       17.2. Assemblies. 726

       17.3. Konfigurationsdateien. 738

       17.4. Versionierung einer Assembly. 752

       17.5. XML-Dokumentation. 755

       17.6. Der Klassendesigner (Class Designer). 759

       17.7. Refactoring. 766

       17.8. Code-Snippets (Codeausschnitte). 769

18.  Die Zukunft:.NET Core und.NET Standard. 773

       18.1. Allgemeines. 774

       18.2. Die drei Säulen von.NET. 775

       18.3.NET Standard. 777

       18.4. Portieren von.NET Framework nach.NET Standard. 783

       18.5. C#-Sprachergänzungen für.NET Core. 784

19.  Einführung in das Entity Framework. 789

       19.1. Das Entity Framework im Überblick. 789

       19.2. Erstellen eines Entity Data Models (EDM). 792

       19.3. Die automatisch erzeugten Klassen im EDM. 809

20.  Database First mit dem EDM-Designer. 815

       20.1. Einfache Datenabfragen mit LINQ-to-Entities. 815

       20.2. In Beziehung stehende Daten laden. 825

       20.3. Ändern von Entitäten. 834

       20.4. Das Verfolgen der Änderungen. 841

       20.5. Die Change Tracker API. 854

       20.6. Parallelitätskonflikte behandeln. 865

       20.7. Asynchrone Abfrage- und Speicheroperationen. 879

       20.8. Transaktionen. 881

       20.9. Kontextlose Entitäten ändern. 883

       20.10. Validieren mit dem Entity Framework. 887

21.  Entity Framework -- Code First. 907

       21.1. Erste Schritte. 907

       21.2. Entity Framework 6 Power Tools. 909

       21.3. Das erste Code-First-Modell. 909

       21.4. Einführung in die Konfiguration von Code First. 917

       21.5. Konventionen und Konfiguration im Detail. 922

       21.6. Komplexe Typen. 933

       21.7. Konventionen und Konfiguration von Beziehungen. 937

22.  Einführung in die WPF und XAML. 957

       22.1. Die Merkmale einer WPF-Anwendung. 958

       22.2. XAML (Extended Application Markup Language). 970

23.  Die WPF-Layoutcontainer. 989

       23.1. Allgemeiner Überblick. 989

       23.2. Gemeinsame Eigenschaften der Layoutcontainer. 990

       23.3. Verschachteln von Layoutcontainern. 1005

24.  Fenster in der WPF. 1009

       24.1. Hosts der WPF. 1009

       24.2. Fenster vom Typ 'Window'. 1010

       24.3. Fenster vom Typ 'NavigationWindow'. 1014

       24.4. Hosts vom Typ 'Frame'. 1027

       24.5. Nachrichtenfenster mit 'MessageBox'. 1029

       24.6. Standarddialoge in der WPF. 1032

25.  WPF-Steuerelemente. 1037

       25.1. Die Hierarchie der WPF-Komponenten. 1037

       25.2. Allgemeine Eigenschaften der WPF-Steuerelemente. 1039

       25.3. Die Gruppe der Schaltflächen. 1045

       25.4. Einfache Eingabesteuerelemente. 1050

       25.5. WPF-Listenelemente. 1058

       25.6. Weitere Steuerelemente. 1080

       25.7. Das 'Ribbon'-Steuerelement. 1091

26.  Dependency Properties. 1099

       26.1. Die Charakteristik von Abhängigkeitseigenschaften. 1099

       26.2. Den Wert einer Abhängigkeitseigenschaft bilden. 1100

       26.3. Definition einer Dependency Property. 1101

       26.4. Validieren einer Abhängigkeitseigenschaft. 1109

       26.5. Angehängte Eigenschaften (Attached Properties). 1111

27.  Ereignisse in der WPF. 1115

       27.1. Ereignishandler bereitstellen. 1115

       27.2. Routing-Strategien. 1116

       27.3. Der Ereignishandler. 1122

       27.4. Benutzerdefinierte Routed Events. 1125

       27.5. Mausereignisse in der WPF. 1129

28.  Ressourcen, Styles, Trigger und Templates. 1135

       28.1. Binäre Ressourcen. 1135

       28.2. Logische Ressourcen. 1138

       28.3. Styles. 1150

       28.4. Trigger. 1158

       28.5. Templates. 1169

29.  WPF-Datenbindung. 1177

       29.1. Die Klasse 'Binding'. 1180

       29.2. Konverter mit 'IValueConverter' und 'IMultiValueConverter'. 1192

       29.3. Validieren von Bindungen. 1200

       29.4. Datenbindung mit 'ObjectDataProvider'. 1213

       29.5. Aktualisieren von Datenklassen. 1216

       29.6. Datenbindung von Listen-Steuerelementen. 1223

       29.7. Datenbindung und das Entity Framework. 1237

       29.8. Das Steuerelement 'DataGrid'. 1238

       29.9. Das 'TreeView'-Control. 1250

       29.10. Navigieren, Filtern, Sortieren und Gruppieren. 1259

       29.11. Dynamische Zuweisung von Styles und 'DataTemplate'-Objekten. 1272

30.  WPF -- weitergehende Techniken. 1279

       30.1. WPF und Multithreading. 1279

       30.2. Globalisierung und Lokalisierung. 1286

       30.3. Benutzerdefinierte Controls. 1296

31.  WPF-Commands. 1307

       31.1. Allgemeine Beschreibung. 1308

       31.2. Ein erstes Programmbeispiel. 1308

       31.3. Die Befehlsquelle. 1311

       31.4. WPF-Commands. 1315

       31.5. 'RoutedCommand'-Objekte und 'CommandBindings'. 1320

32.  Das MVVM-Pattern. 1331

       32.1. Die Theorie hinter dem Model-View-ViewModel-Pattern. 1331

       32.2. Allgemeine Beschreibung des Beispielprogramms. 1332

       32.3. Der Ausgangspunkt im Beispiel 'MVVM_Origin'. 1334

       32.4. Das Bereitstellen des Models. 1334

       32.5. Bereitstellen des ViewModels. 1336

       32.6. WPF-Commands und Eigenschaften im ViewModel. 1341

       32.7. 'RoutedCommand'-Objekte im MVVM. 1347

       32.8. Beliebige Ereignisse mit 'EventTrigger'-Objekten behandeln. 1352

       32.9. Die Klasse 'Person' durch ein ViewModel kapseln. 1356

       32.10. Die Schaltflächen 'Rückgängig' und 'Speichern'. 1368

       32.11. Ein Control in der View fokussieren. 1374

       32.12. Die Listenelemente sortieren. 1378

       32.13. Ereignisse im ViewModel auslösen. 1380

33.  2D-Grafik. 1385

       33.1. Shapes. 1385

       33.2. Path-Elemente. 1389

       33.3. 'Brush'-Objekte. 1393

34.  Komponententests (Unit-Tests). 1405

       34.1. Was ist ein Unit-Test?. 1405

       34.2. Ein erster Komponententest. 1408

       34.3. Komponententest schreiben und ausführen. 1415

       34.4. Die Klasse 'TestContext'. 1432

       34.5. Data-Driven Unit Tests (datengetriebene Tests). 1436

       34.6. Lebenszyklus- Attribute. 1449

       34.7. Testen mit 'Assert'. 1453

       34.8. Test-Driven Development -- TDD. 1462

  Index. 1465

Über Autor(innen)

Kühnel, Andreas
Andreas Kühnel wohnt in Aachen und beschäftigt sich seit über 25 Jahren mit der Programmierung. Er ist seit 1995 als Microsoft Certified Trainer (MCT) zertifiziert. Seine „große Liebe“ galt anfangs Visual Basic. Seit der ersten Vorstellung von.NET konzentriert er sich hauptsächlich auf die Sprachen VB.NET und natürlich C#. Zu seinen Schwerpunkten in der.NET-Welt gehören Datenbanken, Windows-Anwendungen mit WPF, ASP.NET und die WCF (Windows Communication Foundation). Wenn es seine Zeit zulässt, frönt er meist seinem größten Steckenpferd: dem Reisen, bevorzugt in den asiatischen Raum oder nach Australien.
Andreas Kühnel ist als freiberuflicher IT-Trainer und Berater deutschlandweit tätig, führt aber auch Schulungen in seinem eigenen Seminarraum in Aachen durch. Kritiken zu diesem Buch sowie Seminaranfragen richten Sie bitte an [e-mail].