Moderne Web-Anwendungen mit ASP.NET MVC und JavaScript, 2nd Edition

Table of contents

1. Moderne Webanwendungen mit ASP.NET MVC und JavaScript: ASP.NET MVC im Zusammenspiel mit Web APIs und JavaScript-Frameworks
2. Vorwort
   1. Für wen dieses Buch gedacht ist
   2. Zielsetzung des Buchs
   3. Unterschiede zur ersten Auflage
   4. Typografische Konventionen
   5. Behandelte Versionen
   6. Express-Editionen
      1. Verwendete Programmiersprache
   7. Sprachversion
   8. Leserservice
   9. Danksagungen
   10. Über www.IT-Visions.de
   11. Über den Autor Manfred Steyer
   12. Über den Autor Dr. Holger Schwichtenberg
3. 1. ASP.NET MVC
   1. Architektur
      1. Model-View-Controller (MVC)
      2. Überblick über MVVM (Model-View-ViewModel)
   2. Erste Schritte mit ASP.NET MVC
      1. ASP.NET MVC-Projekt anlegen
      2. Modell anlegen
      3. Controller anlegen
      4. View anlegen
      5. Webanwendung testen
      6. Einträge editieren
      7. Vorschlagswerte über Dropdown-Listenfelder anbieten
   3. Controller
      1. Models entgegennehmen
      2. View auswählen
      3. Auf Ausnahmen reagieren
      4. URL-Mapping beeinflussen (Routing)
      5. Asynchrone Controller
      6. Vereinfachte Implementierung asynchroner Controller ab .NET 4.5
   4. Views
      1. Razor
      2. Razor-Helper
      3. Layoutseiten
      4. Partielle Views
      5. Vorlagen für Felder und Models
      6. Views für mobile Anwendungen
      7. Zwischen unterschiedlichen Ansichten wechseln
      8. Minification und Bundling
   5. Models
      1. Metadaten im Model festlegen
      2. HTML-Text übermitteln
      3. Validieren von Benutzereingaben
         1. Manuelles Validieren
         2. Deklaratives Validieren
            1. Validierungsattribute
            2. Validierungsattribute in Metadatenklassen auslagern
            3. Benutzerdefinierte Validierungsattribute
            4. Serverseitige deklarative Validierung
            5. Clientseitige Validierung
            6. Remotevalidierung
            7. Validieren unterbinden
   6. Globalisierung
      1. Sprach- und Ländereinstellungen festlegen
      2. Über Ressourcedateien mehrsprachige Inhalte bereitstellen
      3. Codierung festlegen
   7. Areas
   8. Filter
      1. Überblick
      2. Umsetzung
      3. Filter auf Controller und Action-Methoden anwenden
      4. Globale Filter
      5. Authentifizierungsfilter
4. 2. ASP.NET Web API
   1. REST, WebAPIs und HTTP-Services
   2. Einen einfachen HTTP-Service erstellen
      1. Parameter und Rückgabewerte
      2. HTTP-Services konfigurieren
      3. HTTP-Services mit Fiddler testen
   3. Mehr Kontrolle über HTTP-Nachrichten
      1. Antworten mit HttpResponseMessage beeinflussen
      2. Anfragen als HttpRequestMessage darstellen
      3. HttpRequestMessage und HttpResponseMessage am Beispiel Conditional Get
      4. Antworten über IHttpActionResult zurückgeben
   4. HTTP-Services über HttpClient konsumieren
   5. Routen
      1. Benutzerdefinierte Routen über die Konfiguration festlegen
      2. Attributbasiertes Routing
   6. Weiterführende Schritte mit der Web-API
      1. Dynamische Parameter
      2. Tracing
      3. Request Batching
      4. Cross Origin Resource Sharing (CORS)
      5. Validieren
   7. Querschnittsfunktionen implementieren
      1. Message-Handler
         1. Einen Handler umsetzen
         2. Handler mit HttpClient verwenden
      2. Filter
         1. Überblick
         2. Filter umsetzen
         3. Filter als Attribute einsetzen
         4. Filter über FilterProvider bereitstellen
         5. Filter als globale Filter registrieren
         6. Interfaces für Filter
         7. Authentifizierungsfilter
   8. Filterüberschreibungen
   9. Benutzerdefinierte Formate unterstützen
      1. Formatter implementieren
      2. Formatter mit HttpClient verwenden
   10. Serialisierung beeinflussen
       1. JSON-Serializer konfigurieren
       2. XML-Serializer konfigurieren
       3. Eigenschaften von der Serialisierung ausschließen
       4. Zirkuläre Referenzen serialisieren
       5. Binary JSON (BSON)
   11. Web-API und HTML-Formulare
       1. Einfache Formularfelder übermitteln
       2. Dateiupload via HTML-Formular
   12. Fortschritt ermitteln
   13. Feingranulare Konfiguration
       1. Controllerbasierte Konfiguration
       2. Routenbasierte Konfiguration
5. 3. JavaScript-Frameworks
   1. JavaScript als Multiparadigmen-Sprache
      1. Die prozedurale Seite von JavaScript
      2. Die funktionale Seite von JavaScript
      3. Die objektorientierte Seite von JavaScript
         1. Objekte mit JSON beschreiben
         2. Konstruktorfunktionen
         3. Objekte als Dictionaries
         4. Vererbung
         5. Elemente mit Namespaces organisieren
         6. Ausgewählte vordefinierte Objekte
         7. JSON-basierte Strings
         8. Ausnahmen
      4. Die modulare Seite von JavaScript
   2. JavaScript debuggen
   3. jQuery
      1. Wrapper-Objekte
      2. Selektion von Seitenelementen
      3. Ereignisbehandlung mit jQuery
      4. Modifizieren von Seitenelementen
      5. Animationen
      6. AJAX
   4. ASP.NET MVC-Modelle mit jQuery Validate validieren
   5. jQuery UI
   6. jQuery Mobile
      1. Logische Seiten
      2. Dialogfelder
      3. Navigationsleisten
      4. Formularfelder
      5. Listen
   7. Twitter Bootstrap
      1. Bewertung von Bootstrap
      2. Von Bootstrap unterstützte Browser
      3. Bootstrap-Dateien
      4. Aufbau einer Bootstrap-basierten Webseite
      5. Bootstrap-Grundlayout
      6. Testseite für Bootstrap-Grundlayout
      7. Verschachtelung
      8. Ausblenden von Inhalten
      9. Navigation
      10. Formulare
      11. Symbole
      12. Sprechblasen
      13. Abgerundete Grafiken
      14. Weitere Möglichkeiten
   8. Offlinefähige Webanwendungen mit HTML 5
      1. Daten im Web Storage speichern
      2. Datenbanken im Browser
      3. IndexedDB
         1. Mit IndexedDB arbeiten
         2. Objekte mit IndexedDB speichern
         3. Objekte mit IndexedDB laden
         4. Repository einsetzen
         5. Daten über Index abrufen
         6. IndexedDB nachrüsten
         7. Werkzeuge für IndexedDB
      4. Anwendungsdateien im Browser speichern
         1. Aufbau eines Cache-Manifests
         2. Cache-Manifest dynamisch erzeugen
         3. Cache-Manifest über JavaScript aktualisieren
   9. Asynchronität und Hintergrundprozesse
      1. Mit Promises asynchrone Aufrufe wartbar gestalten
      2. Mit Web-Workern Aufgaben in den Hintergrund auslagern
   10. Internationalisierung mit Globalize
   11. modernizr
   12. TypeScript
       1. Typen und Variablen
       2. Funktionen
       3. Klassen
       4. Strukturelles Sub-Typing
       5. Generics
       6. Module
       7. Ambiente Deklarationen
6. 4. AngularJS
   1. AngularJS herunterladen und einbinden
   2. MVC, MVP und MVVM mit AngularJS
   3. Erste Schritte mit AngularJS
      1. Definition eines Moduls und Controllers
      2. Deklaration der View-Models
      3. Datenbindung verwenden
   4. AngularJS näher betrachtet
      1. Direktiven
      2. Datenbindung
      3. Scopes
      4. Dependency-Injection
   5. HTTP-Services via AngularJS konsumieren
   6. Angular-Services bereitstellen und konsumieren
   7. Filter in AngularJS
      1. Filter verwenden
      2. Benutzerdefinierte Filter bereitstellen
   8. Mit Formularen arbeiten
      1. Objekte an Formularfelder binden
      2. Form-Controller
      3. Eingaben validieren
      4. Fehlerhafte Eingaben mit CSS hervorheben
      5. Auf Validierungsergebnisse programmatisch zugreifen
      6. Benutzerdefinierte Validierungslogiken
      7. Steuerelementbibliotheken für AngularJS
   9. Logische Seiten und Routing
      1. Logische Seiten mit ng-switch
      2. Routing mit dem Modul ngRoute
      3. Routing mit dem externen Modul UI-Router
         1. Verschachtelte Views
         2. Mehrere Views pro Vorlage verwenden
         3. Parameter übergeben
         4. Auf Zustände programmatisch zugreifen
   10. AngularJS-Anwendungen testen
       1. Anatomie eines Jasmine-Tests
       2. Der Jasmine-Test-Runner
       3. Ein View-Model testen
       4. Asynchrone Tests
       5. Controller testen
       6. HTTP-Zugriffe für Tests mit angular-mock.js simulieren
       7. Angular-Services für Tests simulieren
       8. Filter testen
       9. Direktiven testen
   11. Benutzerdefinierte Direktiven
       1. Eine erste (zu) einfache Direktive
       2. Eigener Scope für Direktive
       3. Isolierte Scopes
       4. Link-Phase
       5. Compile-Phase
       6. Kommunikation zwischen Direktiven
7. 5. ASP.NET SignalR
   1. Long-Polling
   2. Web-Sockets
   3. Überblick über ASP.NET SignalR
   4. PersistentConnection
      1. Erste Schritte mit SignalR und PersistentConnection
      2. Lifecycle-Methoden
      3. URL-Mapping für persistente Verbindungen
      4. Einfacher Client für eine persistente Verbindung
      5. Einfacher JavaScript-Client für eine persistente Verbindung
   5. Hubs
      1. Methoden und Callbacks mit SignalR und Hubs
      2. URL-Mapping für Hubs
      3. Lifecycle-Methoden
      4. Hubs konsumieren
      5. Hubs über JavaScript konsumieren
      6. Gruppen
   6. Pipeline-Module für Querschnittsfunktionen
   7. SignalR konfigurieren
   8. Cross Origin Resource Sharing (CORS)
   9. SignalR skalieren
      1. Überlegungen zum Skalieren von SignalR
      2. SignalR mit SQL Server skalieren
      3. Implementierung eines SignalR-Clients
      4. Das Skalierungsszenario testen
      5. Azure Service Bus und Redis als Alternative zu SQL Server
8. 6. Datenzugriff mit Entity Framework
   1. Überblick
   2. Mit dem Entity Data Model arbeiten
      1. Entity Data Model anlegen
      2. Entity Data Model aus bestehender Datenbank ableiten
      3. Entity Data Model einsehen und bearbeiten
      4. Entity Data Model nach Datenbankänderungen aktualisieren
      5. Datenbank für Database First generieren
   3. Daten abfragen
      1. Auf Entitäten zugreifen
      2. Ergebnismenge einschränken und sortieren
      3. Ladestrategien
         1. Vorzeitiges Laden – Eager Loading
         2. Lazy Loading
         3. Benachbarte Objekte nicht laden
      4. Mit Entity SQL auf Datenbanken zugreifen
      5. Tracing
   4. Entitäten verwalten
      1. Entitäten einfügen
      2. Entitäten aktualisieren
      3. Getrennte Objektgraphen aktualisieren
      4. Entitäten löschen
      5. Konflikte erkennen und auflösen
         1. Optimistische Konflikterkennung
         2. Konflikte bei optimistischer Konflikterkennung auflösen
         3. Pessimistische Konflikterkennung
      6. Mit Transaktionen arbeiten
         1. Transactionen mit TransactionScope
         2. Transaktionen über DbContext steuern
   5. Erweiterte Mapping-Szenarien
      1. Komplexe Typen
      2. Enumerationen
      3. Vererbung
         1. Polymorphe Abfragen
         2. Table per Hierarchy (TPH)
         3. Table per Type (TPT)
         4. Type per concrete Type (TPC)
      4. Tabellen zu einer Klasse zusammenfassen
      5. Klasse auf ausgewählte Datensätze einer Tabelle abbilden
      6. Tabelle auf mehrere Klassen verteilen
   6. Mit gespeicherten Prozeduren arbeiten
      1. Gespeicherte Prozeduren zum Erzeugen, Aktualisieren und Löschen verwenden
      2. Vollständige Parallelität mit gespeicherten Prozeduren
      3. Mit gespeicherten Prozeduren Daten abrufen
   7. Mit nativem SQL arbeiten
   8. Codegenerierung anpassen
   9. Code First
      1. Erste Schritte mit Code Only
      2. Standardkonventionen
      3. Konventionen mit Fluent-API überschreiben
      4. Konventionen mit Attributen übersteuern
      5. Benutzerdefinierte Konventionen bei Code First
         1. Konfigurationskonventionen (Configuration Conventions)
         2. Modellbasierte Konventionen
      6. Code First und Stored Procedures
         1. Konventionen für das Abbilden von Entitäten auf Stored Procedures
         2. Vollständige Parallelität beim Einsatz von Stored Procedures unter Code First
         3. Aus Konventionen ausbrechen
      7. Automatisches Migrieren von Datenbanken
   10. Datenbasierte Dienste mit dem Entity Framework, ASP.NET Web API und OData
       1. Daten mit OData flexibel abfragen
       2. Mögliche OData-Abfragen einschränken
       3. OData-Abfragen global aktivieren
       4. OData-Abfragen manuell auswerten
       5. Daten mit OData verwalten
       6. Batching
9. 7. Basisdienste im ASP.NET-Umfeld
   1. Open Web Interface for .NET (OWIN) und Katana
      1. Ideen hinter OWIN
      2. Katana
      3. Self-Hosting mit Katana
         1. Erste Schritte mit Self-Hosting
         2. Self-Hosting von ASP.NET Web API
         3. Self-Hosting von ASP.NET SignalR
         4. Leichtgewichtiger Webserver für das Self-Hosting
      4. Eigene Middleware-Komponenten implementieren
         1. Eigene Middleware-Komponenten in Form von Klassen bereitstellen
         2. Eigene Middleware-Komponenten in Form von Delegaten bereitstellen
   2. Direkt mit HTTP interagieren
      1. HttpContext
      2. Server (HttpServerUtility)
      3. Request (HttpRequest)
      4. Response (HttpResponse)
   3. Zustandsverwaltung auf Sitzungsebene
      1. Überblick
      2. Weitere Optionen
      3. Programmieren mit dem Sitzungszustand
      4. URL-basierte Sitzungsverwaltung ohne Cookies
      5. Konfiguration des Sitzungszustands
      6. Speicherort der Sitzungstabelle wählen
      7. Komprimierung des Sitzungszustands
      8. Deaktivieren des Sitzungszustands
   4. Caching
      1. Überblick
      2. Pro und Contra Zwischenspeicherung
      3. Zwischenspeicherung ganzer Seiten (Output-Caching)
         1. Zwischenspeicherungsprofile (Caching Profiles)
      4. Caching von Seitenteilen (Fragmentzwischenspeicherung)
      5. Programmatisches Caching
      6. Cacheinvalidierung
         1. Cacheinvalidierung durch die Datenbank
         2. Cache Invalidation bei Microsoft SQL Server 7.0 und 2000
            1. Beispiel auf Ebene von Action-Methoden:
            2. Beispiel für die programmatische Anwendung:
         3. Cacheinvalidierung bei Microsoft SQL Server ab Version 2005
10. 8. Sicherheit
    1. Gesicherte Übertragung mit SSL/TLS
       1. SSL für ein Webprojekt in IIS konfigurieren
       2. Digitale Zertifikate für Entwicklung ausstellen
       3. SSL für Self-Hosting-Szenarien konfigurieren
       4. SSL und Clients
    2. Zugang zu Action-Methoden beschränken
    3. Windows-Sicherheit unter Verwendung von HTTP-basierter Authentifizierung
       1. HTTP-Sicherheit in IIS konfigurieren
       2. HTTP-Sicherheit in ASP.NET konfigurieren
       3. Windows-Sicherheit bei Self-Hosting
       4. Windows-Sicherheit mit HttpClient
    4. Mit Clientzertifikaten arbeiten
       1. IIS konfigurieren
       2. In Service auf Clientzertifikat zugreifen
       3. Client für Authentifizierung mittels Clientzertifikat vorbereiten
    5. Sicherheitszenarien mit ASP.NET Identity und Katana
       1. Überblick über ASP.NET Identity
          1. ASP.NET Identity verwenden
          2. Überlegungen zur Implementierung eines eigenen UserStores
       2. Formularbasierte Authentifizierung mit Katana
          1. Überblick über die CookieAuthenticationMiddleware vor dem Hintergrund formularbasierter Authentifizierung
          2. CookieAuthenticationMiddleware für formularbasierte Authentifizierung konfigurieren
          3. Benutzer anmelden
          4. Benutzer abmelden
          5. Claims in Action-Methoden verwenden
       3. Authentifzierung mit externen Identitätsanbietern, wie Google oder Facebook mit Katana
          1. Middleware registrieren
          2. Registrierte Login-Provider abrufen
          3. Authentifizierung durch externen Login-Provider veranlassen
          4. Weiterführende Konfigurationsmöglichkeiten
    6. Benutzerdefinierte Authentifizierungs-Middleware-Komponenten mit Katana entwickeln
       1. Überblick über Authentifizierungs-Middleware-Komponenten
       2. Benutzerdefinierte Implementierung von HTTP BASIC
          1. Umsetzung einer Middleware für HTTP BASIC
          2. Einsatz als passive Authentifizierungs-Middleware
       3. Kommunikation zwischen Anwendungscode und Middleware-Komponenten
       4. Kommunikation zwischen Authentifizierungs-Middleware-Komponenten
    7. Single-Sign-On und weiterführende Szenarien mit OAuth 2.0, OpenID Connect und Katana
       1. OAuth 2.0
          1. Rollen
          2. Access- und Refresh-Token
          3. Single-Sign-On mit OAuth 2 und OpenID Connect
          4. JSON-Web-Token
          5. Flows
             1. Authorization Code Grant-Flow
             2. Implicit Grant-Flow
             3. Resource Owner Password Credentials Grant
             4. Client Credentials Grant
       2. Eine OAuth 2.0-Implementierung mit ASP.NET MVC 5 und ASP.NET Web API 2
          1. Katana-Middleware-Komponenten für OAuth 2.0 registrieren
          2. Datenformate
          3. Einen OAuthAuthorizationServerProvider für den Resource Owner Password Credentials Grant implementieren
          4. Den Resource Owner Password Credentials Grant testen
          5. Neues Access-Token mit Refresh-Token anfordern
          6. Via OpenID Connect ein Identitäts-Token ausstellen
          7. Serviceaufrufer mit einem über OpenID Connect ausgestellten JWT authentifizieren
          8. Authorization Code Grant und Implicit Grant implementieren
          9. Weiterführende Überlegungen zur Authentifizierung des Benutzers beim Einsatz des Authorization Code Grants sowie Implicit Grants
          10. Access-Token über Authorization Code Grant anfordern
          11. Access-Token über Implicit Grant anfordern
          12. Katana-Middleware für Single-Sign-On über Authorization Code Grant und OpenID Connect realisieren
          13. Federated Security mit dem JSON Web Token (JWT) Profile for OAuth 2.0 Client Authentication and Authorization Grants
          14. Implementierung des JWT Profile for OAuth 2.0 Client Authentication and Authorization Grants zur Realisierung von Verbundsicherheit
          15. Authentifizieren von JavaScript-Clients mit OAuth 2.0
          16. JavaScript-Client mit Resource Owner Password Credentials Grant authentifizieren
          17. JavaScript-Client mit Implicit Grant authentifizieren
    8. Single-Sign-On mit WIF
       1. Verweis auf STS einrichten
       2. Konfigurieren von ASP.NET-Projekten für den Einsatz mit WIF
       3. Übermittelte Claims prüfen
       4. Programmatisches Anfordern einer Anmeldung
       5. Sitzungscookie für Claims erstellen
11. 9. ASP.NET MVC und ASP.NET Web API erweitern
    1. ASP.NET MVC erweitern
       1. DependencyResolver
       2. ModelBinder
          1. ModelBinder anpassen
          2. Validierende Modellbindung
          3. ModelBinder auf traditionellem Weg registrieren
          4. ModelBinder über DependencyResolver bereitstellen
       3. ValueProvider
          1. Benutzerdefinierter ValueProvider
          2. ValueProvider mit ValueProviderFactories erzeugen
          3. ValueProviderFactory über DependencyResolver bereitstellen
       4. ModelValidatorProvider
          1. Benutzerdefinierter ModelValidatorProvider
          2. ModelValidationProvider auf traditionellem Weg bereitstellen
          3. ModelValidationProvider über DependencyResolver bereitstellen
       5. MetadataProvider
          1. Ein einfacher MetadataProvider
          2. MetadataProvider auf traditionellem Weg registrieren
          3. MetadataProvider über DependencyResolver bereitstellen
          4. Benutzerdefinierte Metadaten
          5. Performanceverbesserung durch das Zwischenspeichern von Metadaten
       6. View-Helper
          1. View-Helper bereitstellen
          2. Benutzerdefinierte View-Helper aufrufen
          3. Mit View-Helper auf Modell zugreifen
       7. Basisklasse für Razor-Views ändern
       8. Action-Methoden mit ActionMethodSelectorAttribut auswählen
          1. Benutzerdefinierte ActionMethodSelectorAttribut-Implementierungen bereitstellen
          2. ActionMethodSelectorAttribute anwenden
       9. ActionNameSelectorAttribute
       10. Controller mit ControllerFactory auswählen
           1. Benutzerdefinierte ControllerFactory
           2. ControllerFactory auf traditionellem Weg registrieren
           3. ControllerFactory und DependencyResolver
       11. View-Engine
           1. Benutzerdefinierte Pfade für Views mit benutzerdefinierter View-Engine
           2. View-Engine auf traditionellem Weg registrieren
           3. View-Engine über DependencyResolver bereitstellen
           4. Benutzerdefiniertes Rendering mit benutzerdefinierter View-Engine
       12. Benutzerdefiniertes ActionResult
    2. ASP.NET Web API erweitern
       1. Abhängigkeiten auflösen mit benutzerdefiniertem DependencyResolver
       2. Methodenparameter auf benutzerdefinierte Weise mit HttpParameterBinding binden
       3. Zusätzliche Assemblies mit AssembliesResolver laden
       4. Service-Operationen über HttpActionSelector auswählen
       5. Controller über HttpControllerSelector auswählen
12. 10. Testbare Systeme mit Dependency-Injection
    1. Fallbeispiel ohne Dependency-Injection
       1. Implementierung mit ASP.NET MVC
       2. Komponententests (engl. Unit Tests)
       3. Diskussion der betrachteten Lösung
    2. Fallbeispiel mit Dependency-Injection
       1. Implementierung der Webanwendung
       2. Brückenschlag zwischen ASP.NET MVC und Unity
       3. Testen
    3. Zusammenfassung und Fazit
13. Stichwortverzeichnis
14. Impressum