Moderne Webanwendungen mit ASP.NET MVC - ASP.NET MVC im Einklang mit ASP.NET Web API, Entity Framework und JavaScript-APIs

Table of contents

1. A Note Regarding Supplemental Files
2. Vorwort
   1. Zielgruppe
   2. Besprochene Version
   3. Zielsetzung des Buchs
   4. Verwendete Programmiersprache
   5. Sprachversion
   6. Danksagungen
   7. Über die Firma www.IT-Visions.de
   8. Über den Autor Manfred Steyer
   9. Über den Autor Dr. Holger Schwichtenberg
   10. Leserservice
       1. Zugang zum Leser-Portal
   11. Unterstützung durch den Verlag
   12. Ihre Entwicklungsumgebung für .NET 4.5
       1. Express-Editionen
       2. Installation der Express-Editionen
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
      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
         3. Validierungsattribute
         4. Validierungsattribute in Metadatenklassen auslagern
         5. Remotevalidierung
         6. Benutzerdefinierte Validierungsattribute
         7. Serverseitige deklarative Validierung
         8. Clientseitige Validierung
         9. Validieren unterbinden
   6. Globalisierung
      1. Sprach- und Ländereinstellungen festlegen
      2. Über Ressourcendateien mehrsprachige Inhalte bereitstellen
      3. Codierung festlegen
   7. Areas
   8. Filter
4. 2. ASP.NET Web API
   1. Einen einfachen REST-Service erstellen
      1. Parameter und Rückgabewerte
      2. REST-Dienste konfigurieren
      3. REST-Dienste mit Fiddler testen
   2. Mehr Kontrolle über HTTP-Nachrichten
   3. REST-Dienste über HttpClient konsumieren
   4. Weiterführende Schritte mit der Web-API
      1. Benutzerdefinierte Routen
      2. Dynamische Parameter
      3. Tracing
      4. Querschnittsfunktionen mit Message-Handlern implementieren
      5. Handler mit HttpClient verwenden
      6. Querschnittsfunktionen mit Filter realisieren
      7. Benutzerdefinierte Formate unterstützen
      8. Formatter mit HttpClient verwenden
      9. Validieren
   5. Serialisierung beeinflussen
      1. JSON-Serializer konfigurieren
      2. XML-Serializer konfigurieren
      3. Eigenschaften von der Serialisierung ausschließen
      4. Zirkuläre Referenzen serialisieren
   6. Web-API und HTML-Formulare
      1. Einfache Formularfelder übermitteln
      2. Dateiupload via HTML-Formular
   7. Fortschritt ermitteln
   8. Feingranulare Konfiguration
      1. Controllerbasierte Konfiguration
      2. Routenbasierte Konfiguration
5. 3. JavaScript-APIs
   1. JavaScript als Multiparadigmen-Sprache
      1. Die prozedurale Seite von JavaScript
      2. Die funktionale Seite von JavaScript
      3. Die objektorientierte Seite von JavaScript
      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. Offlinefähige Webanwendungen mit HTML5
      1. Daten im Browser speichern
      2. Anwendungsdateien im Browser speichern
         1. Aufbau eines Cache-Manifests
         2. Cache-Manifest dynamisch erzeugen
         3. Cache-Manifest über JavaScript aktualisieren
   8. modernizr
   9. knockout.js
      1. View-Models mit knockout.js
      2. Views mit knockout.js
      3. Arrays binden
   10. TypeScript
       1. Typen und Variablen
       2. Funktionen
       3. Klassen
       4. Schnittstellen
       5. Ambiente Deklarationen
       6. Module
       7. Verweise auf andere TypeScript-Dateien
6. 4. 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. SignalR skalieren
7. 5. Datenzugriff mit dem 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
   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
   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. 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
8. 6. Direkt mit HTTP interagieren
   1. HttpContext
   2. Objektmodell
   3. Server (HttpServerUtility)
   4. Request (HttpRequest)
   5. Response (HttpResponse)
9. 7. Zustandsverwaltung
   1. Überblick über die Zustandsverwaltung in ASP.NET MVC
   2. 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
   3. Zustandsverwaltung auf Anwendungsebene
      1. Unbedingter Anwendungszustand
   4. Benutzerzustand mit individuellen Cookies
   5. Grundprinzip der Cookies
      1. Einwertige Cookies
      2. Mehrwertige Cookies
   6. Vergleich der Zustandsverwaltungsmöglichkeiten
10. 8. Caching
    1. Überblick
    2. Pro und Contra Zwischenspeicherung
    3. Zwischenspeicherung ganzer Seiten (Output-Caching)
    4. Zwischenspeicherungsprofile (Caching Profiles)
    5. Caching von Seitenteilen (Fragmentzwischenspeicherung)
    6. Programmatisches Caching
    7. 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
          1. Beispiel:
11. 9. Internet Information Services (IIS)
    1. Installation der IIS
       1. Nötige Schritte für die Installation
       2. Integration zwischen ASP.NET und IIS
       3. Test der Installation
    2. IIS-Administration
       1. IIS-Manager
       2. Automatisierte Administration und APIs
    3. IIS-Websites (Virtuelle Webserver)
       1. Webserver erstellen
       2. Wichtige Einstellungen
       3. Authentifizierung
       4. Secure Socket Layer (SSL)
    4. Virtuelle Verzeichnisse
    5. IIS-Anwendungen
       1. Rahmenbedingungen einer IIS-Anwendung
       2. Anlegen einer IIS-Anwendung
    6. IIS-Anwendungspools
       1. Eigenschaften eines Anwendungspools
       2. Liste der Anwendungspools
       3. Zuordnung von Websites und IIS-Anwendungen zu Anwendungspools
       4. ASP.NET-Version
       5. Erweiterte Einstellungen
       6. Anwendungspoolidentität
       7. Wiederverwendung (Recycling)
       8. Leistungseinstellungen
       9. Zustandsüberwachung
    7. IIS-Autostart
    8. Konfiguration des Webservers in der Entwicklungsumgebung
12. 10. Sicherheit
    1. Verschlüsselung
    2. Zugang zu Action-Methoden beschränken
    3. Zugriff auf Anwendung beschränken
    4. HTTP-basierte Authentifizierung
       1. HTTP-Sicherheit in IIS konfigurieren
       2. HTTP-Sicherheit in ASP.NET konfigurieren
    5. Formularbasierte Authentifizierung
    6. Mitgliedschaftsanbieter
       1. Konfiguration
       2. Mitgelieferte Administrationsoberfläche
       3. Nutzung des Mitgliedschaftsanbieters
    7. Rollenanbieter
       1. Konfiguration
       2. Programmierschnittstelle für Rollen
    8. Benutzerdefinierte Mitgliedschafts- und Rollenanbieter
    9. Single Sign-On mit Google, Facebook, Twitter und Co.
       1. Protokolle und Implementierungen
       2. Anmeldeanbieter registrieren
       3. Authentifizierung über Anmeldeanbieter anfordern
       4. Callback von Anmeldeanbieter entgegennehmen
       5. Authentifizierung mit vorgefertigter Logik aus Vorlage
    10. Erweiterte Sicherheitsszenarien mit OAuth2 und DotNetOpenAuth
        1. Überblick zu OAuth
        2. Zugriff auf geteilte Ressourcen über Webanwendungen
        3. Umsetzung mit ASP.NET MVC, DotNetOpenAuth und OAuth2
        4. Authentifizierung und Autorisierung mit Google
        5. Token validieren um Sicherheitsloch zu schließen
        6. Entwicklung eines Autorisierungsservers
        7. Mit Client auf Autorisierungsserver und Ressourcenserver zugreifen
        8. OAuth2 für den Zugriff auf Dienste über klassische Clients
    11. 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. Claims in Action-Methoden verwenden
        5. Programmatisches Anfordern einer Anmeldung
        6. Sitzungscookie für Claims erstellen
13. 11. 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 Model zugreifen
       7. Basisklasse für Razor-Views ändern
       8. Action-Methoden mit ActionMethodSelectorAttribute auswählen
          1. Benutzerdefinierte ActionMethodSelectorAttribute-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 Assemblys mit AssembliesResolver laden
       4. Service-Operationen über HttpActionSelector auswählen
       5. Controller über HttpControllerSelector auswählen
14. 12. 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
15. Stichwortverzeichnis
16. Copyright