Windows Store Apps mit XAML und C# - ReadingSample

133 Pages·2016·1.89 MB·German

Galileo Computing
Windows Store Apps mit XAML und C#
DasumfassendeHandbuch–ProfessionelleAppsfürWindows8entwickeln
Bearbeitetvon
ThomasClaudiusHuber
Neuausgabe2013.Buch.1146S.Gebunden
ISBN9783836219686
Format(BxL):168x24cm
schnell und portofrei erhältlich bei
DieOnline-Fachbuchhandlungbeck-shop.deistspezialisiertaufFachbücher,insbesondereRecht,SteuernundWirtschaft.
ImSortimentfindenSiealleMedien(Bücher,Zeitschriften,CDs,eBooks,etc.)allerVerlage.ErgänztwirddasProgramm
durchServiceswieNeuerscheinungsdienstoderZusammenstellungenvonBüchernzuSonderpreisen.DerShopführtmehr
als8MillionenProdukte.
Thomas Claudius Huber
Windows Store Apps mit
XAML und C#
Das umfassende Handbuch
Inhalt
Inhalt
Vorwort................................................................................................................................................... 25
Hinweise zum Buch ............................................................................................................................ 31
1
Einführung in Windows 8, WinRT und .NET 39
1.1 Die Merkmale einer Windows Store App................................................................. 40
1.1.1 Die Live Tiles .......................................................................................................... 40
1.1.2 Kein Fensterrahmen ........................................................................................... 41
1.1.3 Die Charms Bar..................................................................................................... 42
1.1.4 Die App Bar ............................................................................................................ 44
1.1.5 Snapping von Anwendungen.......................................................................... 45
1.2 Entwickeln für Windows 8 ............................................................................................. 45
1.2.1 Die Architektur unter Windows 8 ................................................................. 46
1.2.2 Windows Store Apps entwickeln ................................................................... 47
1.2.3 Desktop-Anwendungen entwickeln ............................................................. 48
1.3 Die Windows Runtime (WinRT).................................................................................... 48
1.3.1 Die WinRT-Grundlagen...................................................................................... 48
1.3.2 Von »früher« über COM und .NET zur WinRT ............................................ 51
1.3.3 Die Architektur der WinRT................................................................................ 56
1.3.4 Language Support ............................................................................................... 57
1.3.5 Metadaten ............................................................................................................. 58
1.3.6 Language Projection ........................................................................................... 60
1.3.7 Sandbox und Broker ........................................................................................... 62
1.3.8 Übersicht der Namespaces .............................................................................. 64
1.3.9 Die Stärken der UI-Technologie mit XAML.................................................. 66
1.4 .NET für Windows Store Apps ....................................................................................... 68
1.4.1 Die Architektur ..................................................................................................... 69
1.4.2 Übersicht der Namespaces .............................................................................. 70
1.4.3 In die WinRT integrierte Technologien......................................................... 71
1.4.4 Entfernte Technologien..................................................................................... 71
1.4.5 Geänderte Technologien................................................................................... 72
1.4.6 Die WinRT und .NET im Zusammenspiel..................................................... 73
7
Inhalt
1.5 Konzepte von Windows Store Apps mit XAML/C# ............................................. 75
1.5.1 XAML........................................................................................................................ 75
1.5.2 Layout ...................................................................................................................... 78
1.5.3 Dependency Properties...................................................................................... 79
1.5.4 Ressourcen............................................................................................................. 82
1.5.5 Styles........................................................................................................................ 83
1.5.6 Data Binding.......................................................................................................... 84
1.6 Zusammenfassung............................................................................................................. 85
2
Das Programmiermodell 87
2.1 Die erste Windows Store App ....................................................................................... 88
2.1.1 Das Projekt erstellen........................................................................................... 89
2.1.2 Die Entwicklerlizenz............................................................................................ 90
2.1.3 Die Dateien des Projekts ................................................................................... 92
2.1.4 Die MainPage ersetzen...................................................................................... 95
2.1.5 Die Dateien im Common-Ordner................................................................... 97
2.1.6 Die MainPage mit Inhalt und Logik füllen................................................... 98
2.1.7 Debuggen im Simulator .................................................................................... 102
2.1.8 Debuggen auf einem Remote Computer .................................................... 103
2.1.9 Die Datei »Package.appxmanifest«............................................................... 107
2.1.10 Die Funktionen im »Package.appxmanifest« ............................................ 109
2.1.11 Der Start im »App«-Objekt ............................................................................... 110
2.1.12 Die Verbindung zwischen XAML und Codebehind-Datei ...................... 112
2.1.13 Das App-Package (».appx«) .............................................................................. 115
2.2 Die App mit Navigation erweitern.............................................................................. 116
2.2.1 Arten der Navigation.......................................................................................... 116
2.2.2 Der Frame............................................................................................................... 117
2.2.3 Die Page .................................................................................................................. 119
2.2.4 Die »LayoutAwarePage«.................................................................................... 121
2.2.5 Eine Detailseite hinzufügen............................................................................. 126
2.2.6 Die Navigation in FriendStorage .................................................................... 129
2.3 Wichtige Klassen................................................................................................................. 132
2.3.1 UI-Basisklassen..................................................................................................... 132
2.3.2 Die Klasse »Application« ................................................................................... 135
2.3.3 »Window« und »CoreWindow«...................................................................... 137
2.3.4 Der »CoreDispatcher« ........................................................................................ 139
8
Inhalt
2.4 Die Projektvorlagen in Visual Studio 2012 .............................................................. 141
2.4.1 »Leere App« ........................................................................................................... 142
2.4.2 »Raster-App«......................................................................................................... 142
2.4.3 »Geteilte App« ...................................................................................................... 145
2.4.4 »Klassenbibliothek (Windows Store Apps)«............................................... 146
2.4.5 »Komponente für Windows-Runtime«........................................................ 147
2.4.6 »Komponententestbibliothek«....................................................................... 148
2.4.7 Die »Portable Klassenbibliothek« .................................................................. 148
2.5 »Asynchron« verstehen ................................................................................................... 150
2.5.1 Die »Task«-Klasse und »async«/»await«..................................................... 151
2.5.2 Voraussetzungen für asynchrone Methoden ............................................ 155
2.5.3 Asynchrone Methoden der WinRT................................................................. 156
2.5.4 WinRT-Methoden ohne »async«/»await« .................................................. 158
2.5.5 WinRT versus .NET............................................................................................... 160
2.6 Zusammenfassung............................................................................................................. 161
3
XAML 163
3.1 Grundlagen............................................................................................................................ 163
3.2 Elemente und Attribute................................................................................................... 165
3.3 Namespaces .......................................................................................................................... 167
3.3.1 Der XML-Namespace der WinRT .................................................................... 167
3.3.2 Der XML-Namespace für XAML ...................................................................... 169
3.3.3 Der XML-Namespace des Designers ............................................................. 171
3.3.4 XAML mit eigenen Namespaces erweitern ................................................ 172
3.4 Properties in XAML setzen.............................................................................................. 173
3.4.1 Attribut- und Property-Element-Syntax ...................................................... 173
3.4.2 Die »Content«-Property (Default-Property)................................................ 175
3.4.3 Die Attached-Property-Syntax ........................................................................ 177
3.5 Attribut-Konvertierung.................................................................................................... 178
3.6 Markup-Extensions ........................................................................................................... 180
3.6.1 Syntax und Funktionsweise............................................................................. 180
3.6.2 Markup-Extensions der WinRT ....................................................................... 183
3.6.3 Markup-Extensions von XAML........................................................................ 184
9
Inhalt
3.7 Collections in XAML........................................................................................................... 184
3.7.1 Collections vom Typ »ICollection<T>«.......................................................... 185
3.7.2 Collections vom »Typ IDictionary<TKey,TValue>« ................................... 186
3.8 XAML dynamisch laden.................................................................................................... 187
3.9 Object und Visual Tree ..................................................................................................... 189
3.10 Entity-Referenzen von XML ........................................................................................... 192
3.11 Zusammenfassung............................................................................................................. 193
4
Controls 195
4.1 Die Klasse »Control« ......................................................................................................... 197
4.2 ContentControls.................................................................................................................. 200
4.2.1 Buttons und CheckBox ...................................................................................... 202
4.2.2 Die »AppBar«......................................................................................................... 206
4.2.3 Der ToolTip............................................................................................................. 210
4.2.4 Der ScrollViewer................................................................................................... 212
4.2.5 Sonstige .................................................................................................................. 213
4.3 ItemsControls ....................................................................................................................... 214
4.3.1 Die Klasse »Selector«.......................................................................................... 215
4.3.2 Die ComboBox ...................................................................................................... 216
4.3.3 Die ListBox.............................................................................................................. 219
4.3.4 FlipView, ListView, GridView ........................................................................... 220
4.4 Text-Controls........................................................................................................................ 221
4.4.1 Die TextBox............................................................................................................ 221
4.4.2 Die PasswordBox ................................................................................................. 223
4.4.3 Der TextBlock ........................................................................................................ 224
4.4.4 Der RichTextBlock................................................................................................ 225
4.4.5 Die RichEditBox .................................................................................................... 228
4.5 Range-Controls .................................................................................................................... 228
4.5.1 Der Slider ................................................................................................................ 229
4.5.2 ProgressBar und ProgressRing ........................................................................ 230
4.5.3 Die ScrollBar .......................................................................................................... 231
4.6 Popups ..................................................................................................................................... 232
4.6.1 Das Popup .............................................................................................................. 232
4.6.2 Das PopupMenu (Kontextmenü) ................................................................... 235
4.6.3 Der MessageDialog............................................................................................. 238
10
Inhalt
4.7 Sonstige .................................................................................................................................. 240
4.7.1 Der ToggleSwitch................................................................................................. 240
4.7.2 Das Image............................................................................................................... 241
4.7.3 Die Viewbox .......................................................................................................... 242
4.7.4 Die Border............................................................................................................... 243
4.7.5 Die WebView......................................................................................................... 244
4.8 Zusammenfassung............................................................................................................. 245
5
Layout 247
5.1 Der Layoutprozess .............................................................................................................. 248
5.1.1 Die zwei Schritte des Layoutprozesses......................................................... 248
5.1.2 Beim Layoutprozess mitreden......................................................................... 250
5.1.3 Ein eigenes Layout-Panel (»DiagonalPanel«) ............................................. 251
5.2 Layouteigenschaften von Elementen........................................................................ 255
5.2.1 »Width« und »Height« ...................................................................................... 255
5.2.2 »Margin« und »Padding«.................................................................................. 257
5.2.3 Die Ausrichtungen (Alignments).................................................................... 259
5.2.4 Die »Visibility«-Property.................................................................................... 261
5.2.5 Transformationen ............................................................................................... 262
5.2.6 3D-Effekte mit Projektionen ............................................................................ 268
5.3 Panels....................................................................................................................................... 272
5.3.1 Die Klasse »Panel«............................................................................................... 272
5.3.2 Das »Canvas« ........................................................................................................ 273
5.3.3 Das »StackPanel«................................................................................................. 276
5.3.4 Das »Grid«.............................................................................................................. 277
5.3.5 Das »VariableSizedWrapGrid« ........................................................................ 283
5.3.6 Die »VirtualizingPanels« ................................................................................... 285
5.4 Layout der Elemente auf einer Page .......................................................................... 287
5.4.1 Das Ausrichtungsgitter von Visual Studio .................................................. 287
5.4.2 Das Layout einer Page........................................................................................ 288
5.4.3 Schriftgrößen ........................................................................................................ 290
5.5 Die Ansichten einer Windows Store App ................................................................. 291
5.5.1 Die Ansichten »Snapped«, »Filled« und Co. ............................................... 291
5.5.2 Die Ansichten in der eigenen App unterstützen....................................... 293
5.5.3 Die Drehungen Ihrer App.................................................................................. 299
11
Inhalt
5.6 Layout in FriendStorage................................................................................................... 301
5.6.1 Der Header............................................................................................................. 301
5.6.2 Die »Snapped«-Ansicht ..................................................................................... 302
5.7 Zusammenfassung............................................................................................................. 305
6
Dependency Properties 307
6.1 Die Grundlagen.................................................................................................................... 308
6.1.1 Die Klassen »DependencyObject« und »DependencyProperty« ......... 308
6.1.2 Ermittlung des Wertes einer Dependency Property ................................ 310
6.2 Dependency Properties.................................................................................................... 312
6.2.1 Implementieren einer Dependency Property............................................. 313
6.2.2 Metadaten der Klasse »DependencyProperty« ......................................... 316
6.2.3 Lokal gesetzte Werte lesen und löschen...................................................... 318
6.2.4 Blick auf existierende Dependency Properties .......................................... 319
6.3 Attached Properties........................................................................................................... 320
6.3.1 Implementieren einer Attached Property ................................................... 320
6.3.2 Ein einfaches Panel mit Attached Properties ............................................. 324
6.4 Zusammenfassung............................................................................................................. 327
7
Daten 329
7.1 Data Binding ......................................................................................................................... 330
7.1.1 Data Binding in XAML ........................................................................................ 330
7.1.2 Data Binding in C# .............................................................................................. 332
7.1.3 Die »Binding«-Klasse im Detail....................................................................... 333
7.1.4 Die Source-Angabe ............................................................................................. 334
7.1.5 Der »DataContext« ............................................................................................. 334
7.1.6 Die »Path«-Property im Detail......................................................................... 336
7.1.7 Die Richtung des Data Bindings ..................................................................... 338
7.1.8 Debugging von Data Bindings ........................................................................ 339
7.2 Datenquellen eines Data Bindings ............................................................................. 341
7.2.1 Binding an Dependency Properties ............................................................... 341
7.2.2 Binding an .NET-Properties .............................................................................. 341
7.2.3 Binding an logische Ressourcen ..................................................................... 346
12
Inhalt
7.2.4 Binding an Quellen unterschiedlichen Typs............................................... 347
7.2.5 Binding an relative Quellen ............................................................................. 350
7.3 Data Binding an Collections........................................................................................... 352
7.3.1 Benachrichtigung mit »INotifyCollectionChanged«................................ 352
7.3.2 Benachrichtigung mit »IObservableVector« .............................................. 354
7.3.3 Benachrichtigung mit »IObservableMap« .................................................. 355
7.3.4 »IObservableMap« in der »LayoutAwarePage«......................................... 357
7.3.5 CollectionViews.................................................................................................... 359
7.4 Daten mit DataTemplates visualisieren................................................................... 365
7.4.1 Das DataTemplate .............................................................................................. 365
7.4.2 Der DataTemplateSelector............................................................................... 367
7.5 Daten-Controls der WinRT.............................................................................................. 369
7.5.1 Die »FlipView« ...................................................................................................... 371
7.5.2 Die Klasse »ListViewBase«................................................................................ 373
7.5.3 Die »ListView« ...................................................................................................... 373
7.5.4 Die »GridView«..................................................................................................... 375
7.5.5 Daten gruppieren ................................................................................................ 377
7.5.6 Semantisches Zoomen ...................................................................................... 383
7.5.7 Inkrementelles Laden von Daten ................................................................... 386
7.6 Daten in FriendStorage .................................................................................................... 391
7.6.1 Die Model-Klassen von FriendStorage ......................................................... 391
7.6.2 Die »CollectionViewSource«............................................................................ 392
7.6.3 DataTemplates & Converter............................................................................ 393
7.6.4 »ListView«, »GridView« und »SemanticZoom«......................................... 395
7.6.5 Validieren von Daten.......................................................................................... 399
7.7 Zusammenfassung............................................................................................................. 400
8
Commands und MVVM 403
8.1 Commands............................................................................................................................. 403
8.1.1 Das »ICommand«-Interface............................................................................. 404
8.1.2 Objekte zum Ausführen von Commands .................................................... 404
8.1.3 Ein Command-Beispiel....................................................................................... 405
8.2 Das Model-View-ViewModel-Pattern (MVVM) .................................................... 406
8.2.1 Die Idee des Model-View-Controller-Patterns (MVC) ............................. 406
8.2.2 Die Idee des Model-View-ViewModel-Patterns (MVVM)....................... 407
8.2.3 Ein MVVM-Beispiel.............................................................................................. 409
13
Inhalt
8.3 MVVM-Herausforderungen bei Windows Store Apps....................................... 414
8.3.1 Dialoge aus dem ViewModel........................................................................... 415
8.3.2 Event mit »Command« verbinden................................................................. 417
8.3.3 Navigation im ViewModel................................................................................ 421
8.3.4 Sonstige Herausforderungen .......................................................................... 423
8.4 Das »DefaultViewModel« der »LayoutAwarePage« .......................................... 423
8.4.1 Details der »DefaultViewModel«-Property................................................. 424
8.4.2 Die »DefaultViewModel«-Property und MVVM........................................ 425
8.4.3 Die Verwendung in FriendStorage................................................................. 426
8.5 Zusammenfassung............................................................................................................. 428
9
Input-Events 429
9.1 Routed Events ...................................................................................................................... 430
9.1.1 Die Routed Events der WinRT.......................................................................... 430
9.1.2 Sender und Quelle bei Routed Events........................................................... 431
9.1.3 Die »Handled«-Property.................................................................................... 435
9.1.4 Routed Events im Detail.................................................................................... 436
9.2 Touch-, Stift- und Maus-Eingaben .............................................................................. 438
9.2.1 Die Gesten in Windows Store Apps............................................................... 439
9.2.2 Gesten-Events....................................................................................................... 441
9.2.3 Pointer-Events ...................................................................................................... 443
9.2.4 Manipulation-Events.......................................................................................... 457
9.2.5 Touch- und Maus-Events nur bei »IsHitTestVisible«............................... 461
9.2.6 Hit-Testing ............................................................................................................. 462
9.2.7 Touch-/Maus-Verfügbarkeit abfragen......................................................... 468
9.3 Tastatur................................................................................................................................... 471
9.3.1 Events ...................................................................................................................... 471
9.3.2 Der Fokus................................................................................................................ 474
9.3.3 Der Fokus in FriendStorage .............................................................................. 475
9.3.4 Die Tab-Reihenfolge ........................................................................................... 476
9.3.5 Tastatur-Verfügbarkeit abfragen................................................................... 477
9.3.6 Die Soft-Tastatur ................................................................................................. 477
9.4 Drag & Drop und das Clipboard ................................................................................... 480
9.4.1 Die »DataPackage«-Klasse ............................................................................... 480
9.4.2 Drag & Drop in der WinRT................................................................................ 482
14