Moderne Webanwendungen für .NET-Entwickler: Server-Anwendungen, Web APIs, SPAs & HTML-Cross-Platform-Anwendungen mit ASP.NET, ASP.NET Core, JavaScript, TypeScript & Angular, 3rd Edition

Book description

Das Buch beschreibt alle relevanten Aspekte der Entwicklung moderner Webanwendungen, sowohl für die Server- als auch die Clientseite. Auf der Serverseite deckt es ASP.NET und ASP.NET Core, die Neugestaltung des Web Application Frameworks, ab. ASP.NET Core bietet eine einheitliche Umgebung zum Erstellen von Webbenutzeroberflächen und Web-APIs. Es ermöglicht u.a. die Integration moderner clientseitiger Frameworks und Entwicklungsworkflows und es unterstützt das Hosten in IIS, Nginx, Apache und Docker.Für die Clientseite vermittelt das Praxisbuch Grundkenntnisse von JavaScript und TypeScript. Die Autoren erläutern darüber hinaus den Einsatz häufig genutzter Frameworks wie Bootstrap, Angular und React. Am Beispiel von MiracleList, einer Anwendung zur Aufgabenverwaltung als Beispiel für SPAs und Cross-Platform-Apps, wird der Einsatz des gesamten Technologiestacks durchgespielt.

Table of contents

  1. Cover
  2. Titel
  3. Impressum
  4. Inhalt
  5. Vorwort zur 3. Auflage
    1. Warum dieses Buch?
    2. Was ist der Inhalt dieses Buchs?
    3. Welche Voraussetzungen sollten Sie für dieses Buch mitbringen?
    4. Was ist das Ziel des Buchs?
    5. Welche Versionen werden in diesem Buch behandelt?
    6. Welche Programmiersprache wird in diesem Buch verwendet?
    7. Welche Werkzeuge werden in diesem Buch verwendet?
    8. Welche Sprachversion wird in diesem Buch verwendet?
    9. Woher bekommen Sie die Code-Beispiele und die drei Bonuskapitel zu diesem Buch?
    10. Wem ist zu danken?
    11. Die Autoren
  6. Teil A Web-Basiswissen
    1. 1 Protokolle, Standards und Konzepte
    2. Standardisierung
    3. RFCs
    4. World Wide Web Consortium (W3C)
    5. European Computer Manufacturers Association (ECMA)
    6. Hypertext Transfer Protocol (HTTP)
    7. Protokollaufbau, Header, Body
    8. Kommandoaufbau
    9. Die HTTP-Statuscodes
    10. Ablauf einer HTTP-Kommunikation
    11. Kopffelder
    12. HTTP 2.0
    13. Ergänzende Standards zu HTTP
    14. Web-Sockets
    15. WebDAV
    16. Simple Mail Transfer Protocol (SMTP) oder Extended SMTP (ESMTP)
    17. File Transfer Protocol (FTP)
    18. REpresentational State Transfer (REST)
    19. Webdienste
    20. Merkmale
    21. REST-Beispiel
    22. URI
    23. HTTP-Methoden für REST
    24. Multipurpose Internet Mail Extensions (MIME)
    25. JavaScript Object Notation (JSON)
    26. Atom Syndication Format (ATOM)
    27. Grenzen von REST: GraphQL und OData
    28. Single Page Application (SPA)
    29. Asynchronous JavaScript and XML (AJAX)
    30. Responsive Web Design (RWD)
    31. 2 Hypertext Markup Language (HTML)
    32. Grundlagen HTML
    33. Geschichte
    34. XML – Grundlage für HTML
    35. Markup
    36. XML-Dokumente
    37. Verarbeitung
    38. Der Begriff »Markup«
    39. Seitenaufbau
    40. Document Object Model (DOM)
    41. Der Dokumenttyp (Doctype)
    42. Codierungen
    43. HTML5-Seitenstruktur
    44. Elemente der Seite
    45. Textelemente
    46. Fließtextauszeichnung
    47. Verweise
    48. Tabellen
    49. Multimedia und Grafiken
    50. Formulare
    51. Skripte
    52. Interaktive Elemente
    53. Allgemeine und universelle Attribute
    54. id
    55. class
    56. accesskey
    57. contenteditable
    58. contextmenu
    59. dir
    60. draggable
    61. dropzone
    62. hidden
    63. lang
    64. spellcheck
    65. style
    66. tabindex
    67. title
    68. 3 Cascading Style Sheets (CSS)
    69. Grundlagen
    70. Syntax
    71. Selektor
    72. Elemente (Tags)
    73. ID
    74. Klassen
    75. Attribute
    76. Logische Auswahl
    77. Weitere Selektoren
    78. Das Box-Modell
    79. Bausteine der Box
    80. Zählweise
    81. Ausnahmen
    82. Das Box-Modell in CSS3
    83. Das Flexbox-Modell
    84. Prinzipien
    85. Eigenschaft der Container
    86. Beachtung von Medien
    87. Syntax
    88. Parameter
    89. Der Viewport
    90. Viewport einstellen
    91. Parameter für den Viewport
    92. Einheiten
    93. Absolute Einheiten
    94. Relative Einheiten
    95. 4 Bootstrap
    96. Einführung in Bootstrap
    97. Neuerungen in Bootstrap 4
    98. Installation
    99. Struktur der CSS-Dateien
    100. Seitenaufbau
    101. Browserunterstützung
    102. ARIA
    103. Optimierung
    104. Hilfsklassen
    105. Reboot
    106. Struktur der Seite
    107. Einführung
    108. Das Rastersystem
    109. Das Flex-Raster
    110. Typografie
    111. Überschriften
    112. Text und Textelemente
    113. Listen
    114. Tabellen
    115. Hilfsklassen
    116. Formulare
    117. Struktur eines Formulars
    118. Eingabeelemente
    119. Schaltflächen
    120. Weitere Bausteine
    121. Symbole
    122. Responsive Bilder
    123. Eingebettete Quellen
    124. Farben und Hintergründe
    125. Ausrichtung von Elementen im Fluss
    126. Inhalte anzeigen und verstecken
    127. Komponenten
    128. Klappmenüs (dropdown)
    129. Werkzeugleisten (toolbar)
    130. Schaltfläche mit Menü (button group)
    131. Navigation (nav, navbar)
    132. Pfadnavigation (breadcrumb)
    133. Seitenweises Blättern (pagination)
    134. Kennzeichnungen (tag)
    135. Großbildleinwand (jumbotron)
    136. Seitenüberschriften (page header)
    137. Meldungen (alert)
    138. Fortschrittsbalken (progress)
    139. Medien (media)
    140. Allgemeine Listen (list group)
    141. Karten (cards)
    142. Aktive Komponenten
    143. Einrichtung und Aktivierung
    144. Die Programmierschnittstelle
    145. Übergänge (transition)
    146. Modale Dialoge (modals)
    147. Klappmenü (dropdown)
    148. Scrollbar-Überwachung (scrollspy)
    149. Angeheftete Navigation (affix)
    150. Umschaltbare Tabulatoren (tab)
    151. Tooltips (tooltip)
    152. Inhaltsüberlagerung (popover)
    153. Meldungen (alert)
    154. Interaktive Schaltflächen (button)
    155. Inhaltseinblendung (collapse)
    156. Bilderkreisel (carousel)
  7. Teil B Webserverprogrammierung mit ASP.NET
    1. 5 ASP.NET MVC
    2. Geschichte und Verbreitung von ASP.NET
    3. Architektur von ASP.NET MVC
    4. Erste Schritte mit ASP.NET MVC
    5. ASP.NET-MVC-Projekt anlegen
    6. Projektaufbau
    7. Nuget-Pakete
    8. Controller anlegen
    9. View anlegen
    10. Webanwendung testen
    11. Einträge editieren
    12. Vorschlagswerte über Drop-down-Listenfelder anbieten
    13. Controller
    14. Models entgegennehmen
    15. View auswählen
    16. Auf Ausnahmen reagieren
    17. URL-Mapping beeinflussen (Routing)
    18. Asynchrone Controller
    19. Vereinfachte Implementierung asynchroner Controller seit .NET 4.5
    20. Views
    21. Razor
    22. Razor-Helper
    23. Layoutseiten
    24. Partielle Views
    25. Vorlagen für Felder und Models
    26. Views für mobile Anwendungen
    27. Zwischen unterschiedlichen Ansichten wechseln
    28. Minification und Bundling
    29. Models
    30. Metadaten im Model festlegen
    31. HTML-Text übermitteln
    32. Validieren von Benutzereingaben
    33. Globalisierung
    34. Sprach- und Ländereinstellungen festlegen
    35. Über Ressourcedateien mehrsprachige Inhalte bereitstellen
    36. Codierung festlegen
    37. Areas
    38. Filter
    39. Überblick
    40. Umsetzung
    41. Filter auf Controller und Action-Methoden anwenden
    42. Globale Filter
    43. Authentifizierungsfilter
    44. 6 ASP.NET Web API
    45. Einen einfachen HTTP-Service erstellen
    46. Parameter und Rückgabewerte
    47. HTTP-Services konfigurieren
    48. HTTP-Services mit Fiddler testen
    49. Mehr Kontrolle über HTTP-Nachrichten
    50. Antworten mit HttpResponseMessage beeinflussen
    51. Anfragen als HttpRequestMessage darstellen
    52. HttpRequestMessage und HttpResponseMessage am Beispiel Conditional Get
    53. Antworten über IHttpActionResult zurückgeben
    54. HTTP-Services über HttpClient konsumieren
    55. Routing
    56. Benutzerdefinierte Routen über die Konfiguration festlegen
    57. Attributbasiertes Routing
    58. Weiterführende Schritte mit der Web API
    59. Dynamische Parameter
    60. Tracing
    61. Request Batching
    62. Cross Origin Resource Sharing (CORS)
    63. Validieren
    64. Querschnittsfunktionen implementieren
    65. Message-Handler
    66. Filter
    67. Filterüberschreibungen
    68. Benutzerdefinierte Formate unterstützen
    69. Formatter implementieren
    70. Formatter mit HttpClient verwenden
    71. Serialisierung beeinflussen
    72. JSON-Serializer konfigurieren
    73. XML-Serializer konfigurieren
    74. Eigenschaften von der Serialisierung ausschließen
    75. Zirkuläre Referenzen serialisieren
    76. Binary JSON (BSON)
    77. Web API und HTML-Formulare
    78. Einfache Formularfelder übermitteln
    79. Datei-Upload via HTML-Formular
    80. Fortschritt ermitteln
    81. Feingranulare Konfiguration
    82. Controllerbasierte Konfiguration
    83. Routenbasierte Konfiguration
    84. 7 ASP.NET SignalR
    85. Long-Polling
    86. Web-Sockets
    87. Überblick über ASP.NET SignalR
    88. PersistentConnection
    89. Erste Schritte mit SignalR und PersistentConnection
    90. Lifecycle-Methoden
    91. URL-Mapping für persistente Verbindungen
    92. Einfacher Client für eine persistente Verbindung
    93. Einfacher JavaScript-Client für eine persistente Verbindung
    94. Hubs
    95. Methoden und Callbacks mit SignalR und Hubs
    96. URL-Mapping für Hubs
    97. Lifecycle-Methoden
    98. Hubs konsumieren
    99. Hubs über JavaScript konsumieren
    100. Gruppen
    101. Pipeline-Module für Querschnittsfunktionen
    102. SignalR konfigurieren
    103. Cross Origin Resource Sharing (CORS)
    104. SignalR skalieren
    105. Überlegungen zum Skalieren von SignalR
    106. SignalR mit SQL Server skalieren
    107. Implementierung eines SignalR-Clients
    108. Das Skalierungsszenario testen
    109. Azure Service Bus und Redis als Alternative zu SQL Server
    110. 8 ASP.NET-Programmierschnittstellen
    111. Direkt mit HTTP interagieren
    112. HttpContext
    113. Server (HttpServerUtility)
    114. Request (HttpRequest)
    115. Response (HttpResponse)
    116. Zustandsverwaltung auf Sitzungsebene
    117. Überblick
    118. Weitere Optionen
    119. Programmieren mit dem Sitzungszustand
    120. URL-basierte Sitzungsverwaltung ohne Cookies
    121. Konfiguration des Sitzungszustands
    122. Speicherort der Sitzungstabelle wählen
    123. Komprimierung des Sitzungszustands
    124. Deaktivieren des Sitzungszustands
    125. Caching
    126. Überblick
    127. Pro und Contra der Zwischenspeicherung
    128. Zwischenspeicherung ganzer Seiten (Output-Caching)
    129. Caching von Seitenteilen (Fragmentzwischenspeicherung)
    130. Programmatisches Caching
    131. Cacheinvalidierung
  8. Teil C Webserverprogrammierung mit ASP.NET Core
    1. 9 Einführung in ASP.NET Core
    2. Klassisches ASP.NET oder ASP.NET Core?
    3. Einführung in die Core-Welt
    4. .NET Standard
    5. Windows Compatibility Pack für .NET Core
    6. Open Source
    7. Dokumentation
    8. Werkzeuge
    9. Kommandozeilenwerkzeug dotnet
    10. Editoren
    11. Erste Schritte mit ASP.NET Core (auf .NET Core)
    12. Installation
    13. Projekt anlegen
    14. Projektaufbau
    15. Die Klasse Program
    16. Klasse Startup und Middleware
    17. Referenzen/Pakete
    18. Übersetzen und Debugging
    19. Deployment
    20. ASP.NET Core auf dem klassischen .NET Framework
    21. Einsatzszenarien
    22. Anlegen von ASP.NET-Core-Projekten mit dem klassischen .NET Framework
    23. Projektaufbau
    24. Referenzen/Pakete
    25. Deployment
    26. In ASP.NET Core integrierte Webserver: Kestrel versus HTTP.sys (WebListener)
    27. Kestrel
    28. HTTP.sys
    29. 10 ASP.NET Core MVC und Razor Pages
    30. POCO-Controller
    31. Controller und View
    32. Tag Helper
    33. Wie funktionieren Tag Helper?
    34. Eingebaute Tag Helper
    35. Eigene Tag Helper
    36. Beispiel: Tag <autor>
    37. Beispiel: Tag <row>
    38. Beispiel: Tag <condition>
    39. Beispiel: Tag <repeater>
    40. View Components
    41. Razor Pages
    42. Von Webforms über MVC zu Razor Pages
    43. Razor Pages versus MVC
    44. Page Model als Code-Behind
    45. URL-Parameter
    46. Eingebaute Objekte
    47. Datenbindung
    48. Praxisbeispiel zu Razor Pages
    49. Drittanbieterkomponenten für ASP.NET Core
    50. 11 ASP.NET-Core-Klassenbibliotheken
    51. Dependency Injection in ASP.NET Core
    52. Implementierung eines Diensts
    53. Registrierung von Diensten
    54. Injektion in einen Konstruktor
    55. Manuelle Beschaffung
    56. Injektion in eine View
    57. Vordefinierte Dienste der ASP.NET-Core-Infrastruktur
    58. Konfiguration in ASP.NET Core
    59. Sitzungen in ASP.NET Core
    60. Cookies
    61. URL-Rewriting in ASP.NET Core
    62. Benutzerverwaltung und Authentifizierung
    63. 12 ASP.NET Core Web APIs
    64. Die Grundlagen von ASP.NET Core Web API
    65. Abfragen von Daten
    66. Arbeiten mit Statuscodes
    67. Anlegen, Aktualisieren und Löschen von Daten
    68. Nutzung von Sub-Routen für Teil-Ressourcen
    69. Nutzung weiterer Model-Binding-Funktionen
    70. Anbieten unterschiedlicher Repräsentationen von Ressourcen
    71. Nutzung des PATCH-Verbs mit JSON-Patch
    72. Cross Origin Resource Sharing
    73. Bereitstellung von OpenAPI-Beschreibungen über Swagger
    74. Starten von Hintergrundprozessen über IHostedService
    75. Integrationstests mithilfe des TestHosts
    76. Service-Kommunikation mit HttpClient
    77. Abfragen von Daten
    78. Versenden von Daten und Reaktion auf Statuscodes
    79. Arbeiten mit Headern und HttpRequestMessage
    80. Generieren von Clients für Swagger-Spezifikationen
    81. Ausblick auf Neuerungen durch ASP.NET Core 2.1
    82. Annotation [ApiController]
    83. ActionResult<T>-Rückgabewerte
    84. Optimierte Input-Verarbeitung
    85. 13 Microservices mit ASP.NET Core Web API und RabbitMQ
    86. Grundlagen von Microservices
    87. Mögliche Vorteile von Microservices
    88. Mögliche Nachteile von Microservices
    89. Modellierung von Microservices
    90. Integration und Kommunikation von Microservices
    91. Synchrone und asynchrone Kommunikation
    92. Messaging-basierte versus Request-Response-Kommunikation
    93. Gesteuerte (orchestriert) versus Event-getriebene Kommunikation (choreografiert)
    94. .NET-Core-Technologien zur Umsetzung von Service-Kommunikation
    95. Asynchrone Service-Kommunikation über RabbitMQ
    96. Microservices-Fallstudie
    97. Umgebung und fachlicher Kontext
    98. Der HumanResourcesService
    99. Der ProjectsService
    100. Der ManagementDashboardService
    101. Der InvoicingService
    102. Fazit
    103. Nützliche Patterns und Best-Practices im Bereich Microservices
    104. Resilienz-Patterns
    105. Serviceübergreifender Code und serviceübergreifende Funktionen
    106. 14 ASP.NET Core SignalR
    107. Hub-Klassen
    108. Hub-Client mit .NET Core 2.1
    109. Hub-Client mit Angular
    110. Serverseitig initiierte Benachrichtigungen und Gruppen
  9. Teil D Web-Client-Programmierung
    1. 15 JavaScript-Grundlagen
    2. Grundlagen der Sprache
    3. Sprachmerkmale und Entwurfsmuster
    4. Vergleich mit Programmiersprachen
    5. JavaScript-Syntax
    6. Typen
    7. Objekte
    8. Symbole
    9. Arrays
    10. Operatoren
    11. Anweisungen – Statements
    12. Fehlerbehandlung
    13. Variablen und Scope
    14. Objektorientierung
    15. Erstellen von Objekten
    16. Klassen
    17. Statische Mitglieder
    18. Vererbung
    19. Exkurs Objekthierarchie
    20. Ableiten von internen Typen
    21. Tipps zum Umgang mit objektorientierten Techniken
    22. Globale Standardfunktionen
    23. Timer-Funktionen
    24. Prüffunktionen
    25. Konvertierungsfunktionen
    26. Module
    27. Entwurfsmuster
    28. Module
    29. Funktionen
    30. Pfeilfunktionen (Lambdas)
    31. Erweiterte Objektliterale
    32. Destrukturierung
    33. Umgang mit Argumenten
    34. Generatoren und Iteratoren
    35. Asynchrone Programmierung
    36. Klassische asynchrone Programmierung
    37. Promise
    38. Set und Map
    39. Set
    40. Map
    41. Schlüsselvergleiche
    42. Iteratoren
    43. WeakMap und WeakSet
    44. Reguläre Ausdrücke
    45. Einführung
    46. Kopieren oder Konstruieren?
    47. Und wie funktioniert das?
    48. Gruppierungen
    49. Vorwärtsreferenzen
    50. Die JavaScript-Funktionen
    51. Zusammenfassung
    52. Reflektions-API
    53. Einfache Methoden
    54. Reflect
    55. Erzeugerfunktionen
    56. Operatoren für Schlüsselwörter
    57. Dynamische Argumentlisten
    58. Funktionsaufrufe
    59. Proxy-Fallen
    60. Zusammenfassung der Reflect-Methoden
    61. Stellvertreter: Proxies
    62. Einführung
    63. Proxy-Fallen anwenden
    64. Schemaprüfung mit Proxies
    65. Entfernbare Proxies
    66. Übersicht
    67. 16 TypeScript
    68. Geschichte von TypeScript
    69. Open-Source-Projekt
    70. TypeScript-Compiler
    71. Übersetzung von TypeScript in JavaScript
    72. TypeScript Playground
    73. TypeScript in Visual Studio
    74. TypeScript-Kommandozeilencompiler tsc
    75. TypeScript in Visual Studio Code
    76. TypeScript in Gulp
    77. Datentypen
    78. Arrays und Tupel
    79. Klassen
    80. Generische Klassen
    81. Strukturelle Typäquivalenz (Duck Typing)
    82. Funktionen und Lambda-Ausdrücke
    83. Dekoratoren
    84. Module und Verweise
    85. TypeScript ohne externes Modulsystem (interne Module)
    86. Externe Module
    87. Re-Export
    88. Deklarationsdateien
    89. Einbindung von Deklarationsdateien (altes Verfahren)
    90. Import von Deklarationsdateien
    91. Deklarationsdateien und tsconfig.js
    92. Mixins
    93. Mixin-Konstruktortypen
    94. Deklaratives Mischen
    95. Module mischen
    96. Nicht mögliche Vermischungen
    97. Reflektion: Metadaten per Programmcode
    98. Die Metadaten-API für Reflektion
    99. Ermitteln von Typinformationen
    100. Ermitteln von Parameterinformationen
    101. Ermitteln von Rückgabeinformationen
    102. Asynchrone Programmierung
    103. Generatoren und Iteratoren
    104. Iteratoren
    105. Generatoren
    106. Asynchrone Iteration
    107. Asynchrone Generatoren
    108. 17 Angular
    109. Ziele und Architektur von Angular
    110. Browserunterstützung
    111. Veröffentlichungszyklus von Angular
    112. Dokumentation
    113. Beispielsammlung
    114. Komponenten
    115. Datenbindung und Pipes
    116. Syntaxübersichten
    117. Strukturelle Direktiven
    118. Datenbindungssyntax
    119. Angular-Pipes
    120. Module
    121. Formulare
    122. Routing
    123. Dienste und Dependency Injection
    124. Animationen
    125. Werkzeuge
    126. JiT vs. AOT
    127. Angular Universal
    128. 18 ASP.NET Blazor
    129. Silverlight wurde eingestellt
    130. Web Assembly
    131. Architektur von Blazor
    132. Erste Schritte mit ASP.NET Blazor
    133. Beispielprojekt
    134. Weitere Möglichkeiten
    135. Ausblick
  10. Teil E Hosting von ASP.NET und ASP.NET Core
    1. 19 Internet Information Services (IIS)
    2. Versionsgeschichte
    3. Kernfunktionen des IIS
    4. Installation des IIS
    5. Modularisierung
    6. Skriptbasierte Installation
    7. Integration zwischen ASP.NET und IIS
    8. Test der Installation
    9. IIS Express
    10. IIS-Administration
    11. IIS-Manager
    12. Administration per Kommandozeile und Skript
    13. IIS-Websites (virtuelle Webserver)
    14. Websites erstellen
    15. Websites erstellen per Skript
    16. Wichtige Einstellungen für Websites
    17. Beschränken der möglichen Clients
    18. Authentifizierung
    19. Transport Layer Security (TLS)/Secure Socket Layer (SSL)
    20. Server für Nicht-HTTP-Protokolle
    21. Virtuelle Verzeichnisse im IIS
    22. IIS-Anwendungen
    23. Rahmenbedingungen einer IIS-Anwendung
    24. Anlegen einer IIS-Anwendung
    25. IIS-Anwendungspools
    26. Eigenschaften eines Anwendungspools
    27. Liste der Anwendungspools
    28. Zuordnung von Websites und IIS-Anwendungen zu Anwendungspools
    29. ASP.NET-Version
    30. Erweiterte Einstellungen für Anwendungspools
    31. Anwendungspoolidentität
    32. Wiederverwendung (Recycling)
    33. Leistungseinstellungen
    34. Zustandsüberwachung
    35. Besonderheiten für ASP.NET-Anwendungen
    36. IIS-Autostart
    37. IIS-Verarbeitungspipeline
    38. 20 Microsoft Azure
    39. Azure-Konzepte
    40. Anlegen einer Subscription
    41. Anlegen einer Ressource Group
    42. Anlegen eines App Service Plans
    43. Anlegen eines Azure App Service
    44. Anlegen eines Azure App Service mit der PowerShell
    45. 21 Verteilen von Webanwendungen aus Visual Studio heraus
    46. Web Deploy-Werkzeug
    47. Web Deploy in einen IIS-Webserver
    48. Web Deploy nach Azure
    49. Konfigurationstransformationen
    50. Erstellen der Transformationsdateien
    51. Syntax der Transformationsdateien
    52. Ergebnis der Transformation
    53. Continuous Integration und Continuous Delivery
    54. 22 Webanwendungen in Docker
    55. Docker auf Windows
    56. Installation der Docker-Unterstützung von Microsoft
    57. Installation von Docker for Windows
    58. Ein Image beschaffen
    59. Einen Container starten
    60. Ein Visual-Studio-Container-Projekt erstellen
    61. Debugging eines Containers
    62. Verwendung des Containers
    63. Images aus Containern erstellen
    64. .NET Core-Container
    65. Container in Windows Server 2016 hosten
    66. Images verbreiten
  11. Teil F Fallbeispiel: MiracleList
    1. 23 Das Fallbeispiel »MiracleList«
    2. Das Szenario
    3. Links
    4. 24 Das MiracleList-Backend
    5. Architektur
    6. Entitätsklassen
    7. Entity Framework Core-Kontextklasse
    8. Lebensdauer der Kontextklasse in ASP.NET Core-Anwendungen
    9. Geschäftslogik
    10. Web API
    11. 25 MiracleList-Web-Client
    12. Technikeinsatz im Web-Client
    13. Angular-CLI
    14. Webserver starten
    15. Zusatzkomponenten
    16. Proxy für REST-Dienste
    17. Daten darstellen
    18. Navigation zu den Aufgaben
    19. Datumsanzeigen
    20. Zeilenumbrüche
    21. Aufgabenstatus ändern
    22. Aufgaben anlegen
    23. Suchfunktion
    24. Komponentenbildung
    25. Schritt 1: Routing-Modul
    26. Schritt 2: Kommunikationsdienst
    27. Schritt 3: Teilaufgabenliste in SubTaskList-Komponente
    28. Schritt 4: Auslagerung in TaskView
    29. Schritt 5: Aufgaben bearbeiten
    30. Schritt 6: Integration in AppComponent
    31. Datepicker
    32. Kontextmenü verwenden
    33. Nachfragen beim Löschen
    34. Animationen
    35. Sortieren der Aufgabenliste
    36. Benutzeranmeldung
    37. Hauptmenü
    38. Testen
    39. Auslieferung
    40. 26 MiracleList-Electron-Client
    41. Hybride Apps
    42. Architektur von Electron
    43. Electron-Projekt anlegen
    44. Kommunikation zwischen Main und Renderer
    45. Erweiterungen in der Webanwendung
    46. Start der Electron-Anwendung
    47. Debugging
    48. Deployment
    49. 27 MiracleList-Cordova-Client
    50. Architektur von Cordova
    51. Cordova-Projekt anlegen
    52. Cordova-Anwendung starten
    53. Erweiterungen in der Webanwendung
    54. Cordova-APIs verwenden
    55. Plug-ins verwenden
    56. Responsive Web Design mit Bootstrap
  12. Index

Product information

  • Title: Moderne Webanwendungen für .NET-Entwickler: Server-Anwendungen, Web APIs, SPAs & HTML-Cross-Platform-Anwendungen mit ASP.NET, ASP.NET Core, JavaScript, TypeScript & Angular, 3rd Edition
  • Author(s): Holger Schwichtenberg, Jörg Krause
  • Release date: September 2018
  • Publisher(s): dpunkt
  • ISBN: 9783960090151