Windows Store Apps entwickeln mit C# und XAML - Crashkurs

Table of contents

1. A Note Regarding Supplemental Files
2. 1. Einführung
   1. Was Sie benötigen, um mit diesem Buch zu arbeiten
   2. Beispieldateien zu diesem Buch
   3. Korrekturen und Kommentare
   4. Willkommen in der neuen Windows-Welt!
   5. Die Microsoft Design-Guidelines für Windows Store-Apps
      1. Nutzen des Microsoft-Designstils
      2. Die Oberfläche sollte schnell und dynamisch sein
      3. Unterstützung mehrerer Darstellungsformen
      4. Verwendung von Contracts
      5. Interaktivität durch Live Tiles
      6. Daten werden mit der Cloud synchronisiert
   6. Die Windows Runtime
      1. Projektion und Metadaten
      2. Projektion von .NET-Sprachen
      3. App-Isolation und Systemzugriff
      4. Das .NET-Profil für Windows Store-Apps
   7. Apps mit Visual Studio entwickeln
      1. Die Visual Studio-Projektvorlagen
      2. Der Aufbau eines App-Projekts
      3. Apps testen
3. 2. Anatomie einer Windows Store-App
   1. Die Rolle der Application-Klasse
   2. Zugriff auf das Fenster
      1. Die Klasse Window
      2. Die Klasse CoreWindow
   3. Navigation mit der Klasse Frame steuern
      1. Übergabeparameter auf der Zielseite auswerten
      2. Navigation abbrechen
      3. Historie ermitteln und zuweisen
      4. Navigation auf Seitenebene
      5. Page Caching
   4. Das Laufzeitverhalten einer App
      1. Auf den Suspension-Modus reagieren
      2. Speichern des aktuellen Zustands
      3. Wiederherstellen des gespeicherten Zustands
   5. Capabilities
      1. Capabilities konfigurieren
      2. Capabilities in einer App verwenden
   6. App Contracts
      1. Die App als Quelle eines Contracts
      2. Die App als Ziel eines Contracts
4. 3. XAML: Die Extensible Application Markup Language
   1. Das XAML-Objektmapping
   2. XAML-Namespaces
   3. Property Elements
   4. Content Properties
   5. Attached Property-Syntax
   6. XAML Markup Extensions
   7. Das Programmiermodell von XAML-basierten Apps
      1. Dependency Properties
      2. Routed Events
      3. Das Klassenmodell von XAML
5. 4. Ressourcen und Styles
   1. Zugriff auf physische Ressourcen
      1. Umgang mit physischen Ressourcen
      2. Ressourcen per XAML referenzieren
      3. Ressourcen per Code referenzieren
      4. Bilder in unterschiedlichen Formaten bereitstellen
      5. Bilder, die jede App enthalten sollte
   2. Logische Ressourcen
      1. Eine Ressource deklarieren
      2. Theme Dictionaries
      3. Eigene Typen als Ressource hinterlegen
      4. Auf Ressourcen per Code zugreifen
   3. Wiederverwendbare Anpassungen mit Styles
      1. Einen Style definieren
      2. Einen impliziten Style anlegen
      3. Einen Style vererben
6. 5. Das Layout der Oberfläche bestimmen
   1. Automatisches Layout mit Layoutcontainern
      1. Elemente stapeln mit dem StackPanel
      2. Tabellenlayout mit dem Grid-Container
         1. Zeilen und Spalten definieren
         2. Zellen verbinden
         3. Größe von Zeilen und Spalten anpassen
      3. Automatisches Layout mit VariableSizedWrapGrid
         1. Anzahl der Zeilen und Spalten festlegen
         2. Orientierung festlegen
         3. Ausrichtung der Elemente anpassen
         4. Feste Breite und Höhe der Zellen einstellen
      4. Pixelbasiertes Layout mit Canvas
         1. Position der Elemente festlegen
         2. Reihenfolge der Elemente bestimmen
      5. Elemente skalieren mit der Viewbox
         1. Skalierungstyp festlegen
         2. Richtung der Skalierung definieren
      6. Automatisches Scrollen mit ScrollViewer
         1. Scrollrichtung festlegen
         2. Touchverhalten bestimmen
         3. Skalierung und Scrolling per Code steuern
   2. Das Layout von Elementen steuern
      1. Die Sichtbarkeit steuern
      2. Höhe und Breite festlegen
      3. Die Ausrichtung festlegen
7. 6. Präsentation und Interaktion mit Controls
   1. Grundlegende Eigenschaften von Controls
      1. Hintergrund, Vordergrund und Rahmen anpassen
      2. Schriftstil manipulieren
      3. Schaltflächen und Regler
      4. Textanzeigesteuerelemente
         1. Umbruch festlegen
         2. Text auf mehrere Blöcke verteilen
         3. Zeichenbreite verändern
         4. Zeilenhöhe konfigurieren
      5. Texteingaben
         1. Eingabemodus bestimmen
         2. Rechtschreibprüfung aktivieren
         3. Wortvervollständigung unterstützen
      6. Listensteuerelemente
         1. Basisfunktionen von Listen
         2. Umgang mit Listenelementen
         3. Selektion auswerten
         4. Datengebundene Listen
         5. Die Darstellung von Listenelementen anpassen
         6. Daten und Darstellung von Elementen trennen
         7. Das Layout der Liste verändern
         8. ListBox und ComboBox
         9. FlipView
         10. ListView und GridView
         11. Drag & Drop implementieren
         12. Selektion steuern
      7. Multimedia-Controls
         1. Bilder anzeigen
         2. Video- und Audio-Wiedergabe
         3. Webinhalte mit WebView einbinden
         4. Schnappschüsse aus dem Web darstellen mit WebViewBrush
      8. ProgressBar und ProgressRing
      9. Application Bars
         1. Die Application Bar steuern
         2. Tipps zur Usability
8. 7. Control Templates und 2D-Grafik
   1. Ein Control Template erstellen
      1. Template mit Bindungen versehen
      2. Die Rolle der Klasse ContentPresenter
      3. Das Standard-Template extrahieren
   2. Einfache 2D-Objekte zeichnen
      1. Shapes
      2. Brushes
9. 8. Elemente animieren und transformieren
   1. Mehr Interaktivität mit Animationen
      1. Benutzerdefinierte Animationen
         1. Einfache Animationen erstellen
         2. Animationen steuern
         3. Mehrstufige Animationen mit Keyframes erzeugen
         4. Natürlich wirkende Animationen durch Easing-Funktionen
      2. Theme-Animationen
      3. Transition-Animationen
   2. Oberflächenelemente transformieren
      1. Elemente transformieren
         1. Elemente rotieren
         2. Elemente kippen
         3. Elemente verschieben
         4. Elemente skalieren
         5. Multiple Transformation
      2. 3D-Effekte mit Projektionen realisieren
         1. Eine PlaneProjection anwenden
         2. Projektionen mit Animation kombinieren
10. 9. Daten an die Oberfläche binden
    1. Objektbindungen
       1. Eine Bindung in XAML herstellen
       2. XAML-Elemente miteinander verbinden
       3. Bindungspfad definieren
       4. Eine Bindung per Code herstellen und ermitteln
       5. Objektdatenquelle zuweisen
       6. Eine Datenquelle in XAML definieren
       7. Implizite Datenquellen
       8. Synchronisation steuern
       9. Unterstützung für Synchronisation in der Datenquelle bereitstellen
       10. Werte zwischen Quelle und Ziel konvertieren
       11. Enumerationswerte binden
    2. Listenbindungen
       1. Listendarstellung mit Data Templates anpassen
       2. Dynamische Template-Zuweisung
    3. Umgang mit ComboBox-Controls
       1. Hierarchische Objekte binden
       2. Flache Datenquellen binden
       3. Synchronisation von Listenquellen ermöglichen
    4. Listensteuerung mit ICollectionView und CollectionViewSource
       1. Das selektierte Element ermitteln
       2. In Listen navigieren
       3. Auf Änderungen in der Listenselektion reagieren
       4. Gruppierte Listen
       5. Semantic Zoom unterstützen
       6. Semantic Zoom steuern
11. 10. Techniken der App-Entwicklung
    1. Umgang mit Zuständen
       1. Aktuellen Zustand ermitteln
       2. Zustände steuern mit dem VisualStateManager
       3. Zustände per Code steuern
       4. Zustände mit Expression Blend definieren
       5. Visual Studio-Vorlagen verwenden
    2. Oberflächen mit User- und Custom Controls kapseln
       1. Dependency Properties
       2. Eine Dependency Property definieren
       3. Eine Attached Property erstellen
       4. User Controls
    3. Umgang mit Systemdialogen
       1. Nachrichten mit MessageDialog anzeigen
       2. Dateien öffnen mit dem FileOpenPicker
       3. Verzeichnis auswählen mit dem FolderPicker
       4. Dateien speichern mit dem FileSavePicker
       5. Kontakte auswählen mit ContactPicker
    4. Arbeiten mit der Zwischenablage
       1. Inhalte in die Zwischenablage übertragen
       2. Inhalte aus der Zwischenablage ermitteln
       3. Bilder kopieren und einfügen
       4. Umgang mit Dateilisten
       5. Eigene Formate definieren
       6. Verweise in der Zwischenablage hinterlegen
    5. Lokalisierte Apps erstellen
       1. Lokalisierte Zeichenketten bereitstellen und binden
       2. Auf lokalisierte Ressourcen zugreifen
       3. Umgang mit sprachabhängigen Bildern
    6. Das MVVM-Pattern
       1. Technische Umsetzung
       2. Eine Basisklasse für Model und ViewModel erstellen
       3. Interaktionslogik weiterleiten: die Klasse DelegateCommand
       4. Umgang mit Visual States
    7. Eine Windows Runtime-Komponente mit .NET erstellen
       1. Konventionen für das Design
       2. Regeln für den Zertifizierungsprozess
12. 11. Noch mehr Interaktivität mit Kacheln und Benachrichtigungen
    1. Eine Kachel bereitstellen
    2. Die Kachel mit Leben füllen
       1. Eine Vorlage auswählen
       2. Bilder definieren
       3. Aktualisierungen steuern
       4. Einen Zeitplan für Aktualisierungen festlegen
    3. Kacheln über einen Server aktualisieren
       1. Einen Service für Benachrichtigungen bereitstellen
       2. Eine Liste von Benachrichtigungsquellen angeben
    4. Push-Benachrichtigungen vom Server versenden
       1. Zugriff vom Client
       2. Push-Benachrichtigungen vom Server versenden
       3. Regeln für die Nutzung
    5. Statusinformationen über Badges anzeigen
       1. Benachrichtigungen erstellen
       2. Badge auf Kachel platzieren
    6. Secondary Tiles
       1. Nachrichten auf dem Lock Screen anzeigen
       2. Secondary Tiles mit Inhalt füllen
       3. Secondary Tile finden und entfernen
    7. Benachrichtigungen mit Toasts
       1. Toasts erstellen
       2. Anzeigedauer steuern
       3. Auf Ein- und Ausblenden sowie auf Fehler reagieren
       4. Toast mit Sound ausstatten
       5. Startparameter festlegen
       6. Zeitgesteuerte Toasts
13. 12. Zugriff auf das Dateisystem
    1. Anwendungsverzeichnisse
       1. Das Installationsverzeichnis
       2. Das App-Datenverzeichnis
       3. Das Download-Verzeichnis
       4. Zugriff auf zusätzliche Verzeichnisse
    2. Dateiauswahl durch den Anwender
    3. Dateien öffnen
    4. Dateien speichern
    5. Umgang mit Anwendungseinstellungen
       1. Einstellungen laden und speichern
       2. Einstellungen gruppieren
       3. Einstellungen löschen
       4. Umgang mit Roaming-Daten
       5. Zusammenhängende Einstellungen speichern
       6. Auf Änderungen von Einstellungen reagieren
       7. Einstellungen versionieren
       8. Einstellungen visualisieren
14. 13. Kommunikation mit Services
    1. Erforderliche Capabilities prüfen
    2. Netzwerkinformationen analysieren
    3. Daten über HTTP übertragen
    4. Daten im Hintergrund transferieren
       1. Eine Datei im Hintergrund herunterladen
       2. Den Fortschritt überwachen
       3. Download pausieren, fortsetzen und abbrechen
       4. Downloads nach Neustart wiederaufnehmen
       5. Die Kommunikation konfigurieren
    5. Kommunikation mit Webservices
       1. Zugriff auf REST-basierte Services
          1. Clientseitiger Zugriff auf den Service
          2. Daten anlegen, ändern und löschen
       2. Zugriff auf SOAP-basierte Services
          1. Eine Proxyklasse für einen SOAP-Service erstellen
          2. Clientseitiger Zugriff
    6. Weitere Möglichkeiten
15. 14. Apps verteilen und veröffentlichen
    1. Anatomie eines App-Pakets
    2. Ein App-Paket erstellen
    3. Apps manuell auf anderen Geräten installieren
    4. Apps zertifizieren
       1. Nützlichkeit der App prüfen
       2. Umgang mit Werbung
       3. Verhaltensweise der App
       4. Kontrolle des Kunden gewährleisten
       5. Inhalts- oder Altersbeschränkungen beachten
       6. App sinnvoll beschreiben
       7. Tipps für den Zertifizierungsprozess
       8. Apps lokal verifizieren
    5. Apps im Store veröffentlichen
       1. Ein Entwicklerkonto eröffnen
       2. Eine App im Dashboard anlegen
       3. App-Namen mit lokalem Projekt verknüpfen
       4. App-Paket erstellen und hochladen
       5. App-Beschreibung und Screenshots hinterlegen
       6. App zur Zertifizierung einreichen
    6. In-App-Verkäufe
       1. In-App-Verkäufe implementieren
       2. Lizenzinformationen abrufen
       3. Lizenzen für einzelne Features prüfen
       4. Lizenzen erwerben
       5. Belege anfordern und prüfen
       6. Auf Lizenzänderungen reagieren
    7. Trial- und zeitlich limitierte Versionen der App bereitstellen
       1. Auf Trial-Version prüfen
       2. Trial-Version zur Entwicklungszeit testen
       3. Vollversion aus der App heraus erwerben
    8. Mit Werbung Geld verdienen
16. Stichwortverzeichnis
17. Copyright