Agile Softwareentwicklung mit C#

Table of contents

1. Cover
2. Titel
3. Impressum
4. Einführung
   1. Wer sollte dieses Buch lesen
   2. Aufbau dieses Buchs
   3. Konventionen in diesem Buch
   4. Systemvoraussetzungen
   5. Downloads: Codebeispiele
   6. Danksagungen
   7. Errata und Support
   8. Kostenlose E-Books von Microsoft Press
5. TEIL I Eine agile Grundlage
   1. Kapitel 1 Einführung in Scrum
      1. Scrum und Wasserfall
      2. Rollen und Verantwortungsbereiche
         1. Product Owner
         2. Scrum Master
         3. Entwicklungsteam
         4. Schweine und Hühner
      3. Artefakte
         1. Das Scrum-Board
         2. Diagramme und Kennzahlen
         3. Backlogs
      4. Der Sprint
         1. Releaseplanung
         2. Sprintplanung
         3. Daily Scrum
         4. Sprintvorführung
         5. Sprint-Retrospektive
         6. Scrum-Kalender
      5. Probleme beim Einsatz von Scrum und Agile
         1. Nicht adaptiver Code
      6. Zusammenfassung
   2. Kapitel 2 Abhängigkeiten und Schichten
      1. Die Definition von Abhängigkeit
         1. Ein simples Beispiel
         2. Modellieren von Abhängigkeiten in einem gerichteten Graphen
      2. Verwalten von Abhängigkeiten
         1. Implementierungen und Schnittstellen
         2. Der verdächtige Geruch von new
         3. Alternativen zur Objekterstellung
         4. Das Anti-Pattern Entourage
         5. Das Stairway-Pattern
         6. Auflösen von Abhängigkeiten
         7. Abhängigkeitsverwaltung mit NuGet
      3. Schichten
         1. Wichtige Patterns
         2. Grenzüberschreitende Angelegenheiten
         3. Asymmetrische Schichteinteilung
      4. Zusammenfassung
   3. Kapitel 3 Schnittstellen und Entwurfs-Patterns
      1. Was ist eine Schnittstelle?
         1. Syntax
         2. Explizite Implementierung
         3. Polymorphie
      2. Adaptive Entwurfs-Patterns
         1. Das Null-Object-Pattern
         2. Das Adapter-Pattern
         3. Das Strategy-Pattern
      3. Mehr Vielseitigkeit
         1. Duck-Typing
         2. Mixins
         3. Flüssige Schnittstellen
      4. Zusammenfassung
   4. Kapitel 4 Unit-Tests und Refaktorierung
      1. Unit-Tests
         1. Arrange, Act, Assert
         2. Testorientierte Entwicklung
         3. Komplexere Tests
      2. Refaktorieren
         1. Vorhandenen Code ändern
         2. Ein neuer Kontotyp
      3. Zusammenfassung
6. TEIL II Schreiben von SOLID-Code
   1. Kapitel 5 Das Single-Responsibility-Prinzip
      1. Das Problem
         1. Refaktorieren, um die Übersichtlichkeit zu verbessern
         2. Refaktorieren, um Abstraktion zu erreichen
      2. SRP und das Decorator-Pattern
         1. Das Composite-Pattern
         2. Predicate-Decorator
         3. Branching-Decorator
         4. Lazy-Decorator
         5. Logging-Decorator
         6. Profiling-Decorator
         7. Asynchronous-Decorator
         8. Decorator für Eigenschaften und Ereignisse
      3. Verwenden des Strategy-Patterns statt switch
      4. Zusammenfassung
   2. Kapitel 6 Das Open/Closed-Prinzip
      1. Einführung in das Open/Closed-Prinzip
         1. Die Meyer-Definition
         2. Die Martin-Definition
         3. Fehlerkorrekturen
         4. Lose Kopplung
      2. Erweiterungspunkte
         1. Code ohne Erweiterungspunkte
         2. Virtuelle Methoden
         3. Abstrakte Methoden
         4. Schnittstellenvererbung
         5. Vererbung in den Entwurf einarbeiten
      3. Geschützte Variation
         1. Prognostizierte Variation
         2. Eine stabile Schnittstelle
         3. Gerade genug Anpassungsfähigkeit
      4. Zusammenfassung
   3. Kapitel 7 Das Liskovsche Substitutionsprinzip
      1. Einführung in das Liskovsche Substitutionsprinzip
         1. Formale Definition
         2. LSP-Regeln
      2. Verträge
         1. Vorbedingungen
         2. Nachbedingungen
         3. Dateninvarianten
         4. Liskovsche Vertragsregeln
         5. Codeverträge
      3. Kovarianz und Kontravarianz
         1. Definitionen
         2. Liskovsche Typsystemregeln
      4. Zusammenfassung
   4. Kapitel 8 Interface-Segregation
      1. Ein Beispiel für Interface-Segregation
         1. Eine einfache CRUD-Schnittstelle
         2. Caching
         3. Dekorieren mehrerer Schnittstellen
      2. Verwenden von Schnittstellen in Clients
         1. Mehrere Implementierungen, mehrere Instanzen
         2. Einzelne Implementierung, einzelne Instanz
         3. Das Interface-Soup-Anti-Pattern
      3. Zerlegen von Schnittstellen
         1. Anforderungen des Clients
         2. Anforderungen der Architektur
         3. Schnittstellen mit einer einzigen Methode
      4. Zusammenfassung
   5. Kapitel 9 Dependency-Injection
      1. Bescheidene Anfänge
         1. Die Aufgabenlistenanwendung
         2. Erstellen des Objektgraphen
         3. Inversion of Control
      2. Jenseits der simplen Injection
         1. Das Service-Locator-Anti-Pattern
         2. Das Illegitimate-Injection-Anti-Pattern
         3. Die Composition-Root
         4. Konvention vor Konfiguration
      3. Zusammenfassung
7. TEIL III Entwickeln von adaptivem Code in der Praxis
   1. Kapitel 10 Beispiel für die Entwicklung von adaptivem Code: Einführung
      1. Trey Research
         1. Das Team
         2. Das Produkt
      2. Anfängliches Backlog
         1. User Stories in Prosabeschreibungen finden
         2. Abschätzen der Story-Punkte
      3. Zusammenfassung
   2. Kapitel 11 Beispiel für die Entwicklung von adaptivem Code: Sprint 1
      1. Planung
      2. »Ich will Räume anlegen, um Unterhaltungen thematisch einzugrenzen.«
         1. Der Controller
         2. Das Raum-Repository
      3. »Ich will eine Liste der Räume ansehen, die Unterhaltungen repräsentieren.«
      4. »Ich will die Nachrichten ansehen, die an einen Raum geschickt wurden.«
      5. »Ich will reine Textnachrichten an andere Raummitglieder schicken.«
      6. Sprintvorführung
         1. Erste Vorführung von Proseware
      7. Sprint-Retrospektive
         1. Was lief gut?
         2. Was lief schlecht?
         3. Was sollte sich ändern?
         4. Was sollte beibehalten werden?
         5. Überraschungen?
      8. Zusammenfassung
   3. Kapitel 12 Beispiel für die Entwicklung von adaptivem Code: Sprint 2
      1. Planung
      2. »Ich will Markdown senden, der richtig formatiert ist.«
      3. »Ich will Nachrichteninhalte so filtern, dass sie nicht anstößig sind.«
      4. »Ich will Hunderte von Benutzern gleichzeitig bedienen.«
      5. Sprintvorführung
      6. Sprint-Retrospektive
         1. Was lief gut?
         2. Was lief schlecht?
         3. Was sollte sich ändern?
         4. Was sollte beibehalten werden?
         5. Überraschungen?
      7. Zusammenfassung
8. TEIL IV Anhang
   1. Anhang A Adaptive Tools
      1. Quellcodeverwaltung mit Git
      2. Kontinuierliche Integration
9. Stichwortverzeichnis
10. Fußnoten
11. Cover-Rückseite