Windows Phone 7-Apps entwickeln - Leseprobe

Transcription

60109-2 U1+U4
03.05.2011
10:14 Uhr
Seite 1
Christian Bleske
Christian Bleske
Aus dem Inhalt:
Know-how
ist blau.
• Windows Phone 7 im Detail
• Betriebssystem-Basics
• Das XNA-Framework
Programmierung –Tools – Funktionen
• Die Oberflächenbeschreibungssprache
und Silverlight
• Kurze Einführung in C#
XAML
• Windows Phone Developer Tools
Microsofts Windows Phone 7 ist neben Apple iOS und Google Android das
dritte große Smartphone-Betriebssystem auf dem Markt – was noch fehlt,
sind Apps! Dieses Buch zeigt, wie Sie diese Chance nutzen und Apps für
Windows Phone 7 entwickeln. Anhand einer konkreten Beispielapplikation
lernen Sie alle wichtigen Funktionen und das Oberflächendesign kennen und
programmieren. Zudem zeigt Autor Christian Bleske ausführlich, wie Sie Ihre
App fit für den Windows Phone-Marketplace machen.
씰
씰
씰
Windows Phone 7 macht vieles einfacher
Mit Windows Phone 7 hat Microsoft viel Ballast abgeworfen. So gibt es die
verschachtelten Menüs früherer Windows-Mobile-Versionen nicht mehr.
Auch für Entwickler wurde vieles einfacher: Die Applikationslogik wird nun
einheitlich in .NET-Sprachen wie C# programmiert, die Benutzeroberfläche
in der XML-basierten Sprache XAML gestaltet. Christian Bleske zeigt, wie
das Zusammenspiel zwischen C# und XAML funktioniert und wie die
beiden Ebenen ineinander greifen. Er führt kurz in die Entwicklungswerkzeuge Windows Phone Developer Tools ein und zeigt, wie Sie schnell
überzeugende Bedieneroberflächen für Ihre Apps programmieren.
• Projekte anlegen, kompilieren
und debuggen
• Der Aufbau einer App
• Konzept und Umsetzung der Beispiel-App
• Layout- und Oberflächentypen
• Die Steuerelemente
• Dateien laden und speichern
• Positionsbestimmung mit Geodaten
• Fotos in die App einbinden
• Die Lokalisierung der App
• Push Notifications
• Die App testen
• Veröffentlichung der App im Windows
Marketplace
Von der App-Idee bis zum Marketplace
Dieses Buch zeigt, wie Sie eine App für Windows Phone 7 von der ersten Idee
bis zum Einstellen in den Marketplace realisieren. Christian Bleske hat dafür
eine App entworfen, mit der Sie Daten zu Bauwerken aufnehmen und
verwalten können – komplett mit Fotos und Geo-Informationen.
Der Autor skizziert, wie Sie die App konzipieren und das Projekt in der
Entwicklungsumgebung anlegen. Schritt für Schritt erläutert er Ihnen die
einzelnen Funktionen von der Oberflächengestaltung über die Datenspeicherung bis hin zum Einbinden von Bild- und Positionsdaten. Zuletzt
zeigt er Ihnen, wie Sie die Anwendung testen und hilft Ihnen, den Zertifizierungsprozess beim Einstellen in den Marketplace zu bestehen.
Geld verdienen mit Windows Phone-Apps
Apps zu programmieren macht Spaß – und es kann sich lohnen! Wenn Sie
mit selbstentwickelten Apps für Windows Phone 7 Geld verdienen wollen,
dann müssen Sie sich bei Microsoft registrieren und brauchen eine
US-amerikanische Steuernummer. Klingt kompliziert, ist es aber nicht.
Christian Bleske ist diesen Weg für Sie gegangen und zeigt, wie Sie auf
Anhieb alles richtig machen.
Über den Autor:
Christian Bleske ist Autor,
Trainer und Entwickler.
Sein Arbeitsschwerpunkt
liegt auf MicrosoftTechnologien. Seine Fachaufsätze erscheinen in
vielen namhaften Entwicklerzeitschriften. Er lebt in
Witten im Ruhrgebiet.
Auf www.buch.cd
Der komplette Quellcode der im Buch
beschriebenen Beispiel-Applikation
30,– EUR [D]
ISBN 978-3-645-60109-2
Besuchen Sie unsere Website
www.franzis.de
Windows
Phone 7-Apps entwickeln
Programmierung – Tools – Funktionen
> Programmieren Sie für das neue Smartphone-Betriebssystem von Microsoft!
> So gestalten Sie griffige Benutzeroberflächen
> Das Zusammenspiel von C# und XAML verstehen
> So machen Sie Ihre App fit für den Windows Phone-Marketplace
Bleske
Windows
Windows Phone 7-Apps
• Das .NET Compact Framework
Programmierung
Tools
Funktionen
Vorwort von Dr. Frank Prengel, Technical Evangelist
für Windows Phone bei Microsoft
5
Geleitwort
Sie sind Entwickler und möchten (oder müssen) Ihre erste eigene »App« für Windows
Phone 7 entwickeln? Sie suchen nun jemanden, der Sie bei den ersten Schritten an die
Hand nimmt und Ihnen ganz pragmatisch das »Laufen« beibringt? Dann ist dieses Buch
genau richtig für Sie.
Windows Phone 7 hat seit dem Start im Herbst 2010 in der Entwicklergemeinde einen
riesigen Anklang gefunden – weit über eine Million Downloads der Windows Phone
Developer Tools und Tausende verfügbarer Apps nach kurzer Zeit sprechen hier eine
deutliche Sprache. Willkommen an Bord – hier erfahren Sie, wie auch Sie erfolgreich
dabei sein können.
An Hand einer Beispielanwendung führt Sie der Autor durch den gesamten Entwicklungszyklus einer modernen mobilen Anwendung für Microsofts neue Plattform Windows
Phone 7 – von der Installation der kostenlosen Entwicklungswerkzeuge bis hin zur
Veröffentlichung im Windows Phone Marketplace. Dank einer Kurzeinführung in die
Konzepte der Programmiersprache C# und in die Microsoft-Tools Visual Studio 2010 und
Expression Blend, welche für Entwicklung und UI-Design von Windows Phone-Apps
eingesetzt werden, finden selbst Einsteiger oder Umsteiger von anderen Plattformen den
schnellen Zugang zur praxisorientierten Herangehensweise, in der danach die typischen
Entwicklungsschritte beschrieben werden: Anwendungsarchitektur, Oberflächenentwurf,
Datenspeicherung, Einbindung von Kamera- und ortsbezogenen Daten, Debugging und
Testen. Neben weiteren Themen wie der Nutzung von Gerätesensoren und der Sprachanpassung (für internationale Märkte) wird sogar die Verwendung von Push Notifications, einem speziellen Konzept unter Windows Phone 7, mittels eines cloud-basierten
Dienstes auf Windows Azure diskutiert. Abgerundet wird das Ganze durch eine ausführliche Beschreibung des Registrierungs- und Publikationsprozesses in Microsofts App Hub
(angereichert durch die persönlichen Erfahrungen des Autors), an dessen Ende dann die
Verfügbarkeit der App für die Nutzer im Windows Phone Marketplace steht.
Sie sehen schon: dieses Buch ist kein Tausend-Seiten-Wälzer, der sämtliche Windows
Phone-Aspekte erschöpfend dokumentiert. Es ist vielmehr eine Anleitung aus der Praxis
für die Praxis. Möge es Ihnen helfen, Ihre Ideen schnell und kreativ umzusetzen und
Stolperfallen und Umwege auf dem Weg zur Veröffentlichung Ihrer App(s) zu vermeiden.
Viel Erfolg!
Frank Prengel
Technical Evangelist Windows Phone, Microsoft Deutschland
http://dr-mobile.net
7
Vorwort
Liebe Leserinnen und Leser,
Apps, Apps und nochmals Apps. Apple sei Dank – niemand spricht mehr von
Anwendungen oder gar Applikationen! Jeder, der ein Smartphone hat, will sie haben! Aber
warum sind diese Mini-Anwendungen so faszinierend? Einfach deshalb, weil man sie (in
aller Regel) bedienen kann, ohne eine meterdicke Anleitung zu lesen. Das geht, weil es sich
um Anwendungen handelt, die speziell für die Lösung einer (kleinen) Aufgabe konzipiert
wurden. Außerdem sind sie durch das mobile Telefon überall verfügbar.
Was aber macht Apps so interessant für Entwickler? Sicher, man kann damit auch Geld
verdienen, wenn sich die selbst geschriebene App gut verkauft. Aber das allein erklärt
nicht, warum sich Tausende von Entwicklern auf dieses Thema stürzen. Da muss also
noch etwas anderes sein.
Jahrelang wurde uns Entwicklern eingetrichtert, dass man Software nur in großen
Teams unter Verwendung eines Fünfjahresplans qualitativ hochwertig entwickeln
könne. Vorbei war somit die Zeit, in der ein Mann oder eine Frau eine Anwendung
allein erstellte. Mit den Apps kommt diese Möglichkeit wieder zurück! Sicher, die eine
oder andere App wird im Team entwickelt. Aber der größere Teil wird wohl wieder von
Einmannteams realisiert werden können. Seit Oktober 2010 kann man nun auch für
Microsofts neuestes Smartphone-OS Windows Phone Apps programmieren. Dieses
Buch zeigt Ihnen, wie es geht.
Im Gegensatz zu einer App ist das Schreiben eines Buches Teamarbeit. Sicher, zuerst ist
da der Autor, der allein in einer dunklen Kammer das Manuskript erstellt. Aber damit
aus diesem Manuskript auch ein Buch wird, bedarf es noch einer ganzen Reihe von
Personen, die direkt oder indirekt mit der Entstehung des Buches zu tun haben. Bei
diesen Menschen möchte ich mich bedanken. Zuerst wäre da natürlich Franz Graser,
der Lektor und Programmleiter Professional Series beim Franzis Verlag. Herzlichen
Dank! Ohne ihn wäre dieses Buch gar nicht erst entstanden, da er den Anstoß gegeben
hat. Außerdem hat er das Buch in mühevoller Arbeit korrigieren müssen. Mein Dank
gilt auch den vielen anderen Mitarbeiterinnen und Mitarbeitern des Franzis Verlags, die
ich nicht kenne.
Außerdem geht mein Dank an die Firma HTC, die kurzfristig, im tiefsten Winter, ein
Trophy 7 als Testgerät zur Verfügung stellte. Ferner möchte ich mich auch bei Barbara
Steiger, der Microsoft Pressereferentin, für ihre Unterstützung bedanken.
Zuletzt sind da noch meine Frau Sanela und meine beiden Söhne Benjamin und Florian.
Sie sind die »Leidtragenden«, wenn ich schreibe und für nichts anderes Zeit finde. Vielen
Dank!
Christian Bleske, im März 2011
9
Inhaltsverzeichnis
1
Einleitung .................................................................................................... 17
1.1
Windows Phone 7 – das etwas andere Handy-OS............................. 17
1.2
Für wen ist dieses Buch gedacht?..................................................... 18
1.3
Die Beispielanwendung ................................................................... 18
1.4
Was zum Start benötigt wird … ......................................................... 20
1.4.1 Windows Vista oder Windows 7 ....................................................... 20
1.4.2 Was ist mit Windows XP?.................................................................. 20
1.4.3 Welches Windows Phone 7 zur Entwicklung? ................................... 21
1.4.4 Die Windows Phone Developer Tools ............................................... 21
1.4.5 Registrierung bei Microsoft .............................................................. 26
1.4.6 Das Microsoft Developer Network .................................................... 26
Teil 1 – Der Einstieg ..................................................................................... 29
2
Windows Phone 7 im Detail.......................................................................... 31
2.1
Basics.............................................................................................. 31
2.1.1 Oberfläche & Apps ........................................................................... 32
2.1.2 Windows Phone 7 – Bestandteile..................................................... 35
2.2
Windows Embedded ........................................................................ 36
2.3
.NET Compact Framework................................................................. 36
2.4
Silverlight ........................................................................................ 37
2.5
Das XNA-Framework ......................................................................... 37
2.5.1 XNA-Bibliotheken für die Denkmal-App ............................................ 38
2.6
Windows Mobile .............................................................................. 38
3
C# im Überblick ........................................................................................... 41
3.1
Variablen, Datentypen und Deklaration............................................ 41
3.1.1 Simple Datentypen .......................................................................... 42
3.1.2 Operatoren ...................................................................................... 44
3.2
Kontrollstrukturen ............................................................................ 46
3.2.1 Fallunterscheidung .......................................................................... 46
3.2.2 Mehrfachauswahl ............................................................................ 46
3.2.3 Schleifen.......................................................................................... 47
3.2.4 Arrays .............................................................................................. 49
3.2.5 Strukturen........................................................................................ 49
10
Inhaltsverzeichnis
3.2.6
3.3
3.3.1
3.3.2
3.3.3
3.3.4
3.3.5
3.4
3.5
3.6
3.6.1
3.6.2
Typumwandlung .............................................................................. 51
Klassen............................................................................................ 51
Partielle Klassen .............................................................................. 55
Eigenschaften .................................................................................. 55
Methoden ........................................................................................ 58
Ereignisse ........................................................................................ 62
Konstruktoren und Destruktoren ...................................................... 64
Schnittstellen .................................................................................. 64
Namespaces .................................................................................... 65
Klassendesign der Denkmal-App...................................................... 65
Anlage des Projekts ......................................................................... 67
Hinzufügen der Klasse ..................................................................... 67
4
XAML im Blick .............................................................................................. 73
4.1
Steuerelemente in XAML .................................................................. 73
4.2
Page ................................................................................................ 74
4.3
Application ...................................................................................... 75
5
Entwicklungswerkzeuge .............................................................................. 77
5.1
Microsoft Visual Studio 2010 ........................................................... 77
5.1.1 Visual Studio Express for Windows Phone........................................ 78
5.1.2 Die IDE ............................................................................................. 78
5.1.3 Projektvorlagen für Windows Phone ................................................. 81
5.1.4 Solution Explorer ............................................................................. 83
5.1.5 Properties-Fenster............................................................................ 84
5.1.6 Der Page-Designer............................................................................ 85
5.1.7 XAML-Editor ..................................................................................... 86
5.1.8 Toolbox............................................................................................ 88
5.1.9 C#-Quellcode-Editor......................................................................... 89
5.1.10 Die Eigenschaften eines Projekts ..................................................... 92
5.2
Expression Blend for Windows Phone .............................................. 94
5.2.1 Überblick ......................................................................................... 95
5.2.2 Neues Projekt erstellen .................................................................... 97
5.2.3 Projects-Panel.................................................................................. 98
5.2.4 Assets-Panel .................................................................................... 99
5.2.5 States-Panel .................................................................................. 101
5.2.6 Device-Panel .................................................................................. 102
5.2.7 Objects and Timeline-Panel............................................................ 102
5.2.8 Das Tools-Panel ............................................................................. 106
5.2.9 Properties-Panel ............................................................................ 108
5.2.10 Resources-Panel ............................................................................ 109
5.2.11 Data-Panel ..................................................................................... 110
Inhaltsverzeichnis
5.2.12
5.2.13
5.3
5.3.1
5.3.2
5.3.3
5.3.4
5.3.5
6
11
Effektives Arbeiten mit Expression Blend ....................................... 110
Action, Bild und Sound .................................................................. 112
Windows Phone Developer Tools ................................................... 114
Application Deployment................................................................. 114
Der Windows Phone Emulator ........................................................ 115
Windows Phone Developer Registration ......................................... 115
Windows Phone Developer Tools – October 2010 Update .............. 115
Das January-Update 2011 .............................................................. 116
Debugging ................................................................................................. 117
6.1
Breakpoints ................................................................................... 117
6.1.1 Breakpoints und schrittweise Ausführung der App ......................... 117
6.2
Fenster und Debug-Optionen ......................................................... 120
6.3
Remote Debugging auf dem Gerät .................................................. 122
Teil 2 – Apps entwickeln ............................................................................ 125
7
Entwicklung einer App ............................................................................... 127
7.1
Aufbau einer App ........................................................................... 127
7.1.1 Der Properties-Ordner .................................................................... 128
7.1.2 Der Ordner References ................................................................... 129
7.1.3 Die Ordner bin und obj................................................................... 130
7.1.4 Lebenszyklus einer App ................................................................. 131
7.1.5 Die Klasse Page ............................................................................. 134
7.1.6 Die Application Bar ........................................................................ 137
7.1.7 Pages und Navigation .................................................................... 142
7.1.8 Daten als Parameter übergeben ..................................................... 143
7.1.9 Daten übergeben via Application-Objekt ........................................ 145
7.1.10 Page-Layout ................................................................................... 148
7.1.11 Portrait- & Landscape-Ansicht ........................................................ 149
7.1.12 Automatische Umschaltung (Portrait / Landscape)......................... 150
7.1.13 Pivot-Ansicht.................................................................................. 153
7.1.14 Panorama-Ansicht.......................................................................... 154
7.1.15 Das Grid-Steuerelement ................................................................. 155
7.1.16 Das StackPanel-Steuerelement ...................................................... 158
7.1.17 Steuerelemente positionieren ........................................................ 158
7.2
MessageBox .................................................................................. 163
7.3
LinearGradientBrush ...................................................................... 165
7.4
Touch-Ereignisse verarbeiten ......................................................... 166
7.5
Pages und Layout der Denkmal-App............................................... 167
12
Inhaltsverzeichnis
8
Die Steuerelemente im Detail..................................................................... 171
8.1
Die Steuerelemente von Silverlight ................................................ 171
8.1.1 Border............................................................................................ 171
8.1.2 Button............................................................................................ 172
8.1.3 Canvas........................................................................................... 173
8.1.4 CheckBox....................................................................................... 174
8.1.5 Ellipse............................................................................................ 175
8.1.6 Grid................................................................................................ 176
8.1.7 HyperlinkButton............................................................................. 179
8.1.8 Image............................................................................................. 179
8.1.9 ListBox........................................................................................... 181
8.1.10 Map ............................................................................................... 182
8.1.11 MediaElement................................................................................ 188
8.1.12 PasswordBox ................................................................................. 190
8.1.13 ProgressBar ................................................................................... 192
8.1.14 RadioButton................................................................................... 193
8.1.15 Rectangle....................................................................................... 194
8.1.16 ScrollViewer................................................................................... 196
8.1.17 Slider ............................................................................................. 196
8.1.18 StackPanel..................................................................................... 197
8.1.19 TextBlock ....................................................................................... 198
8.1.20 TextBox.......................................................................................... 200
8.1.21 WebBrowser................................................................................... 202
8.2
Weiterentwicklung der Denkmal-App ............................................. 204
9
Dateizugriff................................................................................................ 213
9.1
Keine Datenbank – was nun? ......................................................... 213
9.2
Isolierte Speicherung ..................................................................... 214
9.2.1 Die Klasse IsolatedStorageSettings................................................ 215
9.2.2 Die Klasse IsolatedStorageFile ....................................................... 217
9.3
Die Klasse XmlSerializer................................................................. 220
9.4
DataBinding................................................................................... 223
9.5
Lokale Speicherung der Denkmal-App: Daten und
DataBinding................................................................................... 225
9.5.1 Die Klasse DataStorage .................................................................. 225
9.5.2 Erweiterung der Klasse MainPage................................................... 229
9.5.3 Erweiterung der Klassen OptionPage, GebaeudePage und
AdressePage .................................................................................. 233
Inhaltsverzeichnis
13
Teil 3 – Dienste und Services ..................................................................... 237
10 Positionsbestimmung mit Geodaten .......................................................... 239
10.1
Windows Phone 7 Location Services .............................................. 239
10.2
Anpassungen für die Denkmal-App ................................................ 241
11 Die Vibrationsfunktion nutzen ................................................................... 245
11.1
Die Klasse VibrateController........................................................... 245
12 Kamera und Bild ........................................................................................ 249
12.1
Die Klasse CameraCaptureTask ...................................................... 249
12.2
Die Klasse PhotoChooserTask ........................................................ 250
12.3
13 Microsoft.Phone.Task ................................................................................ 255
13.1
Die Klasse EmailComposeTask....................................................... 255
13.2
Marketplace-Tasks......................................................................... 256
13.2.1 MarketplaceHubTask ..................................................................... 256
13.2.2 MarketplaceSearchTask ................................................................. 257
13.2.3 MarketplaceDetailTask................................................................... 257
13.2.4 MarketplaceReviewTask................................................................. 257
13.3
PhoneCallTask ............................................................................... 258
13.4
SearchTask .................................................................................... 258
13.5
SmsComposeTask.......................................................................... 259
13.6
WebBrowserTask ........................................................................... 259
14 Die Klassen Accelerometer und Microphone .............................................. 261
14.1
Der Accelerometer.......................................................................... 261
14.2
Das Mikrofon ................................................................................. 263
15 Lokalisierung............................................................................................. 265
15.1
Ressourcen (Texte) auslagern ........................................................ 265
15.1.1 Ressource für Strings ..................................................................... 266
15.1.2 Ressourcenklasse .......................................................................... 268
15.2
Sprachdateien hinzufügen ............................................................. 270
15.3
Globalisierung ............................................................................... 272
15.4
15.4.1 Ressourcen (Texte) im C#-Quellcode .............................................. 275
14
Inhaltsverzeichnis
16 Push Notifications ..................................................................................... 277
16.1
Push-Notification-Typen................................................................. 277
16.2
Infrastruktur benötigt – die Windows Azure Cloud
Services ......................................................................................... 279
16.3
Das Windows Azure SDK ................................................................ 279
16.4
Azure-Service erstellen................................................................... 281
16.4.1 Testlauf des Services ..................................................................... 286
16.5
Die Datenquelle (WPF-Client) ......................................................... 287
16.6
Push Notifications empfangen und verarbeiten.............................. 289
16.6.1 Probelauf ....................................................................................... 291
Teil 4 – Registrierung, Test und Deployment .............................................. 293
17 Registrierung............................................................................................. 295
17.1
Registrierung als Entwickler im App Hub ........................................ 295
17.1.1 Überprüfung durch GeoTrust .......................................................... 299
17.1.2 Bankverbindung und Steuernummer.............................................. 302
17.1.3 Status der Anmeldung.................................................................... 303
17.2
Installation der Zune-Software und Einrichtung eines
WP-Handys .................................................................................... 304
17.3
Registrierung des Geräts mit dem Windows Phone
Developer Registration Tool ........................................................... 306
17.4
IRS und die Formulare W-7 und W-8-BEN........................................ 308
17.4.1 IRS Form W-7.................................................................................. 310
18 Testen der App........................................................................................... 315
18.1
Unit-Tests ...................................................................................... 315
18.2
NUnit for Windows Phone............................................................... 316
18.3
Erweiterung mit Assertions............................................................. 321
18.3.1 Vergleichstests .............................................................................. 321
18.3.2 Statustests .................................................................................... 322
18.3.3 Utility-Methoden ............................................................................ 323
18.4
Überwachung mit Debug & Trace ................................................... 323
18.5
Performance-Informationen ........................................................... 324
18.6
Verteilung testen mit App Deployment ........................................... 325
19 Die App im Marketplace veröffentlichen..................................................... 327
19.1
Vorbereitungen .............................................................................. 327
19.1.1 Capability Detection....................................................................... 327
19.1.2 Dokumentation und Grafiken zusammenstellen............................. 328
19.1.3 Anforderungen an die App ............................................................. 330
19.2
Zertifizierungsrichtlinien ................................................................ 331
Inhaltsverzeichnis
19.3
19.3.1
19.3.2
19.3.3
19.3.4
19.3.5
19.4
19.5
15
Einstellen der App.......................................................................... 334
Hochladen der App ........................................................................ 335
Dokumentation bereitstellen.......................................................... 336
Hochladen des App-Artworks ......................................................... 337
Festlegen des Preises..................................................................... 338
Freigabe zur Zertifizierung.............................................................. 339
Checkliste ...................................................................................... 342
App-Marketing ............................................................................... 343
20 Nachwort ................................................................................................... 345
Stichwortverzeichnis ................................................................................. 347
17
1
Einleitung
Sie möchten Apps für Windows Phone 7 entwickeln? Und das möglichst schnell und
ohne großen Lernaufwand? Dann sind Sie hier richtig. An dieser Stelle möchte ich Ihnen
keine Anleitung geben, wie dieses Buch zu lesen ist. Lesen Sie es doch einfach. Die einzige Bitte, die ich habe, ist: Beginnen Sie (sofern Sie Ihre Neugierde bändigen können)
mit dem ersten Kapitel (was Sie durch das Lesen dieser Einleitung ja bereits tun) und
hören Sie erst beim letzten Kapitel auf.
1.1
Windows Phone 7 – das etwas andere Handy-OS
Wenn Sie bereits ein iPhone oder ein Android-Smartphone ausprobiert haben, dann
wird Ihnen sicherlich aufgefallen sein, dass die Benutzerführung von Windows Phone
anders ist. Angenehm anders. Endlich einmal ein Betriebssystem von Microsoft, das sich
intuitiv bedienen lässt. Das ist doch mal eine gute Nachricht, oder?
Wie hat Microsoft diese bessere Bedienbarkeit erreicht? Das ist die schlechte Nachricht:
Durch selektives Entfernen bestimmter, in den Augen von Microsoft nicht benötigter
Funktionen. Sie werden an der einen oder anderen Stelle Funktionen schmerzlich vermissen. Leider gilt diese Aussage nicht nur für Anwender, sondern auch für Entwickler!
Ein Stichwort zu dieser Thematik lautet »Datenbank«. Dazu aber später mehr.
Aber grundsätzlich ist Windows Phone 7 nicht nur für den Anwender einfacher. Auch
wir Entwickler profitieren von dem neuen Ökosystem um Windows Phone 7 herum –
durch neue Entwicklungswerkzeuge, mit denen es sich fast so einfach und angenehm
arbeiten lässt wie mit Windows Phone 7 selbst. Gerade wir Entwickler werden ja, was die
Usability angeht, nicht besonders verwöhnt. Mit den Windows Phone Developer Tools
ändert sich hier aber etwas. Diese Werkzeuge schreien geradezu danach, mit ihnen
Software zu entwickeln.
Microsoft hat erkannt, dass ein Betriebssystem ohne Software bald vom Markt
verschwindet. Also haben die Redmonder es für Entwickler so einfach wie möglich
gemacht, neue Anwendungen – pardon, man sagt ja jetzt Apps – dafür zu entwickeln.
Wenn Sie bereits mit Visual Studio programmiert haben – vielleicht haben Sie ja
Anwendungen für das »alte« Windows Mobile entwickelt –, dann kann ich Ihnen
versprechen, dass es mit den Windows Phone Developer Tools noch einfacher geht.
Gerade was die Anbindung des Emulators an die Entwicklungsumgebung Visual Studio
angeht, hat sich doch einiges getan. Wenn Sie vielleicht schon Apps für das iPhone
geschrieben haben, so werden Sie feststellen, dass die Entwicklung für Windows Phone 7
im direkten Vergleich simpler ist, Stichwort »Speicherverwaltung«. Unter Windows
Phone müssen Sie sich damit nicht beschäftigen! Denn der Garbage Collector, also die
18
Kapitel 1: Einleitung
automatische Speicherbereinigung, wurde vom großen Bruder, dem .NET-Framework,
übernommen.
Was macht das Entwickeln von Apps für Entwickler eigentlich so interessant? Die Antwort lautet: Das geschlossene System. Es gibt keine Möglichkeit, eine Anwendung einfach zu kopieren. Alles läuft über Microsofts App Hub, das Gegenstück zum Apple App
Store. Nur über den Shop können Anwendungen auf ein Windows Phone übertragen
werden. So kann man sicher sein, dass die Investition in die Arbeit sich auszahlt – allerdings nur, sofern sich die App auch verkauft.
1.2
Für wen ist dieses Buch gedacht?
Dieses Buch richtet sich an Leser, die über gute bis sehr gute Kenntnisse in der Programmierung mit mindestens einer Sprache wie beispielsweise C, Pascal (Delphi) oder
auch Visual Basic verfügen. Sollten Sie mit Begriffen wie Klasse, Objekt, Instanz, Eigenschaft oder Methode noch nicht viel anfangen können, dann lege ich Ihnen Kapitel 3 ans
Herz. Dort wird etwas Basiswissen zu diesem Thema vermittelt. Einsteiger in die Programmierung sollten aber noch zusätzliches Material heranziehen, um sich zurechtzufinden. Außerdem gehe ich davon aus, dass Ihnen Grundbegriffe in Bezug auf grafische Benutzeroberflächen bekannt sind. Das bedeutet: Sie sollten wissen, was ein Button,
eine TextBox oder eine ComboBox sind. Zwar geht Kapitel 8 intensiv auf diese Steuerelemente (Controls) ein, aber an der einen oder anderen Stelle werden diese Begriffe
schon vorher verwendet, ohne sie explizit zu erläutern.
1.3
Die Beispielanwendung
Jedes Buch sollte einen »roten Faden« enthalten, der die einzelnen Teile zusammenbindet. In diesem Fall ist das eine App für Windows Phone 7, die sukzessiv entwickelt wird.
Die einzelnen Kapitel schließen, soweit es sinnvoll ist, immer mit einer Erweiterung
dieser Anwendung ab. Das in einem Kapitel vermittelte Wissen kann somit gleich
sinnvoll an einem Beispiel aus der realen Welt getestet werden. Trotzdem finden Sie in
den Kapiteln auch kurze Quick & Dirty-Beispiele, die Sie direkt ausprobieren können
und sollen.
Der Bogen zieht sich von der Planung der App bis zum Einstellen der Anwendung in
den App Hub von Microsoft. Es werden in den einzelnen Kapiteln nur die Punkte erläutert, die für das Entwickeln der Anwendung unmittelbar oder mittelbar interessant sind.
Das bedeutet aber auch, dass einige Bereiche der Programmierung von Windows Phone
7 nicht angesprochen werden. Davon ist unter anderem das XNA-Framework betroffen,
das sich hauptsächlich an Entwickler richtet, die ein Spiel für das Smartphone schreiben
möchten. Betrachten Sie das Buch also bitte nicht als komplette Referenz zur Windows
Phone-Entwicklung, sondern mehr als praxisorientierte Anleitung.
An dieser Stelle soll kurz die Beispielanwendung vorgestellt werden. Die Denkmal-App,
so der Name der Anwendung, richtet sich an Anwender, die für die Instandhaltung von
1.3 Die Beispielanwendung
19
historischen Bauwerken zuständig sind. Solche Leute gibt es tatsächlich. Man findet sie
in der Regel in Kommunen, die ja ein Auge auf diese Gebäude haben müssen.
Bild 1.1: Die Beispiel-App Denkmal
Der Sourcecode der Anwendung ist unter folgender URL verfügbar:
Lesezeichen
www.buch.cd
Download-Adresse für den Quellcode der Beispielanwendung
Sie sollten ihn auch herunterladen, da dies das Nachvollziehen des Projekts doch sehr
vereinfacht. Bewusst ist das Beispielprojekt nicht allzu komplex gehalten, damit Ihnen
die Einarbeitung leichter fällt. Bei einigen Beispielen von Microsoft beschleicht einen
nämlich manchmal das Gefühl, dass sich hier jemand ausgetobt hat.
20
1.4
Was zum Start benötigt wird …
Neben Geduld benötigen Sie natürlich auch etwas Hard- und Software. Der PC, der zur
Entwicklung verwendet wird, sollte über eine Dual-Core-CPU mit mindestens 2 Gigahertz Taktfrequenz verfügen. 2 Gigabyte Hauptspeicher sind unter Windows Vista oder
Windows 7 zu empfehlen. Gehen Sie davon aus, dass die Installation aller Entwicklungswerkzeuge auf der Festplatte einen Umfang von ca. 3 Gigabyte in Anspruch nimmt.
Außerdem benötigen Sie zwingend eine Grafikkarte, die DirectX 10 unterstützt. Sie ist
deshalb notwendig, weil der Windows Phone 7-Emulator zwingend eine Grafikkarte
voraussetzt, für die es einen WDDM-1.1-Treiber gibt. Dies ist auch der Grund, weshalb
Windows XP offiziell zur Entwicklung von Apps nicht geeignet ist.
Auch ein Gerät mit Windows Phone 7 wäre natürlich nicht schlecht, um die Applikation
zu testen, obwohl die ersten Schritte auch ohne Smartphone zu bewältigen sind. Spätestens jedoch wenn die Anwendung getestet und verteilt werden soll, kommen Sie nicht
um diese Investition herum.
1.4.1
Windows Vista oder Windows 7
Ob Sie Windows Vista oder Windows 7 als Plattform für die Entwicklung nutzen, spielt
eigentlich keine Rolle. Wenn Sie Vista einsetzen, beachten Sie bitte nur, dass Windows
Vista mit dem Service Pack 2 ausgerüstet ist. Natürlich werden auch die 64-Bit-Varianten beider Betriebssysteme unterstützt.
1.4.2
Was ist mit Windows XP?
Windows XP wird offiziell nicht unterstützt. Sobald Sie versuchen, die Windows Phone
Developer Tools unter Windows XP zu installieren, werden Sie während des Setup-Vorgangs darauf hingewiesen. Muss man jetzt direkt zu Windows Vista oder Windows 7
wechseln? Nicht unbedingt! Es gibt eine Möglichkeit – mit Einschränkungen –, die
Windows Phone Developer Tools auch unter Windows XP zu installieren. Hierzu
müssen Sie zuerst das komplette ISO-Image der Installationsdateien herunterladen und
anschließend in einem Verzeichnis entpacken.
Alternativ können Sie auch das Web-Setup-Paket herunterladen und mit dem Befehl
vm_web.exe /x entpacken.
Egal für welche Variante Sie sich entschieden haben, im nächsten Schritt müssen Sie die
Textdatei baseline.dat in einem Editor (z.B. Notepad) öffnen.
Suchen Sie im Editor nun nach dem Abschnitt mit der Kennzeichnung [gencomp7788].
Haben Sie den entsprechenden Abschnitt gefunden, so suchen Sie nun nach dem Eintrag InstallOnLHS und ändern Sie diesen Wert von 1 auf 0. Anschließend muss noch ein
Wert angepasst werden. Es handelt sich um InstallOnWinXP. Auch der Wert dieses Eintrags muss von 1 auf 0 angepasst werden. Zuletzt muss die Datei baseline.dat gespeichert
werden. Anschließend kann das Setup »normal« aufgerufen werden, und nun gelingt die
Installation auch unter Windows XP.
1.4 Was zum Start benötigt wird …
21
Der Windows Phone 7-Emulator läuft trotz dieser Änderung natürlich nicht. Er benötigt nach wie vor eine DirectX 10-Installation. Aber die Tools lassen sich so zumindest
unter Windows XP benutzen. Microsoft leistet allerdings keinen Support für die Lösung
mit Windows XP.
Lesezeichen
http://bit.ly/8YxX8H
http://www.microsoft.com/downloads/en/details.aspx?FamilyID=04704acf-a63a-4f97952c-8b51b34b00ce
Download aller WPDT-Versionen (Windows Phone Developer Tools)
1.4.3
Welches Windows Phone 7 zur Entwicklung?
Muss das Testhandy mit Windows Phone von einem bestimmten Hersteller stammen?
Die eindeutige Antwort ist nein! Microsoft hat die Vorgaben, was die Hardwarevoraussetzungen eines Smartphones mit Windows Phone 7 betrifft, sehr eng gesetzt. Sie
können also davon ausgehen, dass jedes Telefon z. B. über eine Kamera und einen GPSSensor verfügt. Es ist lediglich nicht festgelegt, ob ein Gerät über eine echte Tastatur
verfügt oder die Tastatur softwaremäßig zur Verfügung stellt. Das bedeutet: Sie können
die Auswahl des Geräts Ihrem persönlichen Geschmack überlassen.
1.4.4
Die Windows Phone Developer Tools
Im vorherigen Abschnitt wurden die Windows Phone Developer Tools (WPDT) schon
kurz angeschnitten. Alles, was Sie zur Entwicklung einer App für Windows Phone 7
benötigen, steckt in den Windows Phone Developer Tools. Das Beste daran ist: Die
Entwicklungsumgebung kostet nicht einen Euro. Aber auch wenn Sie Microsofts
Entwicklungsumgebung Visual Studio 2010 bereits installiert haben, beispielsweise die
Professional-Variante, können Sie die WPDT bedenkenlos installieren. Die Tools zur
App-Entwicklung integrieren sich dann in die vorhandene Version.
Installation der WPDT
Bevor Sie die Tools nutzen können, müssen sie von der entsprechenden Microsoft-Webseite heruntergeladen werden. Es gibt zwei Wege zur Installation. Der erste führt über
den Download eines sogenannten Web-Installers. Wählen Sie diesen Weg, so wird
zuerst nur eine knapp 3 Megabyte große Setup-Datei aus dem Internet heruntergeladen.
Diese führen Sie aus. Anschließend prüft der Installer, welche weiteren Komponenten
für die Installation benötigt werden. Sie werden automatisch heruntergeladen, und die
Installation startet. Dieser Weg empfiehlt sich unter zwei Gesichtspunkten. Der erste ist,
dass bereits einige .NET-Komponenten auf dem Rechner installiert sind, beispielsweise
wenn eine Installation von Visual Studio 2010 Express bereits vorhanden ist. Der
notwendige Zeitraum zur Installation verkürzt sich so zum Teil drastisch. Der Nachteil
an dieser Variante ist: Auf jedem Computer, auf dem die IDE (Integrated Development
22
Environment = integrierte Entwicklungsumgebung) installiert werden soll, muss der
Download erneut gestartet werden.
Wenn Sie also vorhaben, die WPDT auf mehr als nur einem Computer zu installieren,
dann empfiehlt es sich, das komplette ISO-Image herunterzuladen.
Welche Sprachversion?
Eigentlich spielt es keine Rolle mehr, ob Sie die deutsche Variante oder eine andere
Sprache bevorzugen. Die WPDT gibt es neben Englisch zurzeit auch in Deutsch, Französisch, Italienisch oder Spanisch. Ein Vorteil der englischen Version ist, dass Updates
oder Patches etwas früher zur Verfügung stehen als für die lokalisierten Versionen.
Deswegen wird hier die englische Sprachversion beschrieben.
Nach dem Aufruf der Setup-Datei beginnt die Installation. Es wird zuerst der obligatorische Dialog zur Akzeptierung der Lizenzbedingungen angezeigt. Im nächsten Schritt
kann man sich entscheiden, ob die Entwicklungsumgebung direkt installiert oder das
Setup vorher noch konfiguriert werden soll. Die Möglichkeiten zur Anpassung sind
allerdings stark beschränkt. Man kann sich lediglich den Ordner aussuchen, in dem die
WPDT installiert werden.
Bild 1.2: Installation
der WPDT
Je nach Umfang der zu installierenden Komponenten kann die Installation schon einige
Minuten in Anspruch nehmen. Nach der Installation finden Sie einige neue Punkte im
Startmenü von Windows. Neben Visual Studio Express 2010 for Windows Phone gibt es
noch Einträge für das XNA Game Studio 4.0, Microsoft Expression Blend 4 sowie die
Developer Tools mit dem Emulator.
23
Nach einigen Starts von Visual Studio Express 2010 werden Sie aufgefordert, einen
Registrierungscode einzugeben. Sie erhalten ihn, wenn die Schaltfläche Obtain a registration key online im Dialog betätigt wird.
Bild 1.3:
Dialog zur Registrierung
von Visual Studio
Hinweis zu Visual Studio 2010 Professional
Sollte bereits Visual Studio 2010 Professional auf dem Computer installiert sein, so wird
Visual Studio Express 2010 for Windows Phone nicht separat installiert, sondern in die
vorhandene Visual-Studio-Installation integriert, allerdings nur dann, wenn beide IDEs
dieselbe Sprache unterstützen. In Visual Studio Professional findet man anschließend im
Projektvorlagen-Dialog einen neuen Eintrag Silverlight for Windows Phone.
Bild 1.4: Der erweiterte ProjektvorlagenDialog von VS 2010 Professional
24
Tipp: Den folgenden Abschnitt können Sie überspringen, wenn Sie sich bereits mit
Visual Studio auskennen.
Schnellstart mit HalloWelt
Nach der Installation möchte man sich zuerst einmal in der Entwicklungsumgebung
umsehen. Dieser Tatsache soll an dieser Stelle mit einem Quick & Dirty-Projekt Rechnung getragen werden. In der weiteren Beschreibung wird davon ausgegangen, dass
Visual Studio 2010 in der Express Phone Edition verwendet wird. Deshalb wird Visual
Studio 2010 Professional nicht separat beschrieben.
Die Entwicklungsumgebung ist unter dem Punkt Microsoft Visual Studio 2010 Express
im Startmenü zu finden. Nach dem Start der IDE kann ein neues Projekt entweder über
das File-Menü (Datei-Menü) oder aber über den entsprechenden Punkt auf der StartPage von Visual Studio erstellt werden:
Bild 1.5: Neues Projekt in Visual Studio anlegen
Nach einem Mausklick wird der Dialog (New Project / Neues Projekt) mit den zur Verfügung stehenden Projektvorlagen angezeigt. Hier muss jetzt der Eintrag Windows Phone
Application (Windows Phone Anwendung) aus den vorhandenen Templates ausgewählt
werden. Im unteren Bereich des Dialogs befindet sich ein Eingabefeld für den Projektnamen. Dort kann auch der Speicherort des Projekts festgelegt werden. Als Projektnamen geben Sie bitte HalloWelt ein. Anschließend muss die OK-Schaltfläche betätigt
werden. Es dauert einen kleinen Moment, in dem Visual Studio aus der Projektvorlage
das Anwendungsgerüst generiert.
25
Bild 1.6: Das geöffnete Projekt in Visual Studio
In diesem Einführungsbeispiel werde ich nur die Punkte von Visual Studio erläutern, die
zur Umsetzung notwendig sind. Alles andere folgt später. Sobald das Projekt in Visual
Studio komplett geladen wurde, sehen Sie im linken Bereich die Toolbox mit den verfügbaren Steuerelementen. Schließen Sie diesen Bereich. Der Bereich für den PhoneDesigner wird nun größer angezeigt. Markieren Sie den Bereich im Phone-Designer, in
dem in großen Buchstaben page name steht. Die Markierung wird durch vier Punkte an
den Ecken und eine farbliche Änderung des Rahmens angezeigt.
Im rechten unteren Bereich der Entwicklungsumgebung befindet sich das PropertiesFenster (Eigenschaften-Fenster). Hier werden die Eigenschaften eines Steuerelements
zur Bearbeitung angezeigt. Suchen Sie in den vorhandenen Eigenschaften nun nach der
Text-Eigenschaft. In der Eigenschaft steht noch der Default-String page name. Löschen
Sie ihn und schreiben stattdessen die Zeichenkette Hallo Welt hinein.
Bild 1.7: Der neu eingefügte String
»Hallo Welt« im Designer
26
Nach Abschluss der Eingabe mit Enter wird umgehend die Änderung auch im PhoneDesigner sichtbar, siehe Bild 1.7. Damit sind bereits alle Arbeiten für das HalloWeltBeispiel erledigt. Die Anwendung kann jetzt gestartet werden. Mit einem Mausklick auf
oder alternativ mit Betätigung der Taste F5 wird die App kompiliert und automatisch im Emulator gestartet.
1.4.5
Registrierung bei Microsoft
Eine App können Sie natürlich jederzeit im Emulator testen. Das ist allerdings nur die
halbe Miete. Erst wenn sich die App auf einem »echten« Windows Phone befindet, kann
man testen, ob sich die Anwendung wirklich so verhält wie gewünscht. Außerdem
möchte man ja wahrscheinlich früher oder später Geld mit der App verdienen. In beiden
Fällen müssen Sie sich im Microsoft App Hub anmelden. Der App Hub ist das
Entwicklerportal für Windows Phone. Hier finden Sie Tools und Ressourcen zur Erstellung von Apps. Außerdem ist der App Hub das Tor zum Windows Phone Marketplace.
Das ist für Windows Phone das Pendant zum App Store für das iPhone: eine Plattform,
um die geschriebenen Applikationen an den Mann bzw. die Frau zu bringen. Den App
Hub erreichen Sie über folgende Adresse:
Lesezeichen
http://create.msdn.com/en-US/
MSDN App Hub
Sobald Sie sich bei Microsoft registriert haben, bekommen Sie eine Möglichkeit, die
geschriebene Anwendung direkt auf ein registriertes Gerät zu laden. Die Registrierung
kostet für ein Jahr 75 Euro. Sofern Sie Student sind, können Sie sich sogar kostenfrei
anmelden. Was erhalten Sie außerdem, wenn Sie sich dort registrieren?
•
Sie können eine unbegrenzte Anzahl von Anwendungen in den Microsoft App Hub
hochladen, sofern sie kostenpflichtig sind.
•
Sie können bis zu 100 kostenfreie Apps zum Testen einreichen. Jede weitere kostenfreie App schlägt mit 19,99 US-Dollar zu Buche.
•
Die Apps, die Sie hochladen, werden inhaltlich und codeseitig geprüft.
Für die Registrierung benötigen Sie eine Windows-Live-ID. Neben dem Individual- und
Studentenprogramm gibt es auch eine Möglichkeit, sich im Company-Programm zu
registrieren. Das Company-Programm ist für Unternehmen gedacht,
1.4.6
Das Microsoft Developer Network
Das Microsoft Developer Network, kurz MSDN, ist die Informationsressource für Programmierer, die mit Entwicklungswerkzeugen von Microsoft arbeiten. Natürlich gibt es
eine Homepage innerhalb des MSDN, die speziell für das Thema Windows Phone 7
27
geschaffen wurde. Im Developer Center für Windows Phone finden Sie neben Tipps &
Tricks und FAQs auch App-Beispiele und Foren, in denen Sie recherchieren und Fragen
stellen können. Die Homepage erreichen Sie über folgende Adresse:
Lesezeichen
http://bit.ly/90hwKk
Developer Center für Windows Phone
41
3
C# im Überblick
In diesem Kapitel dreht sich alles um die Sprache C#. Neben Visual Basic ist sie zurzeit
die einzige Möglichkeit, Anwendungen für Windows Phone zu programmieren. Hier
wird gezeigt, wie man in C# Klassen erstellt und wie Eigenschaften, Methoden und
Ereignisse mit C# realisiert werden. Dieses Kapitel soll nicht direkt als Einführung in die
objektorientierte Programmierung mit C# dienen. Es richtet sich in erster Linie an Entwickler, die bereits mit einer objektorientierten Sprache wie Java gearbeitet haben, und
soll ihnen einen Eindruck von der Arbeit mit C# vermitteln. Wenn Sie aber bisher
zumindest prozedural programmiert haben, so finden Sie mit den Grundlagen zur
Objektorientierung in diesem Kapitel einen Einstieg in die OOP.
3.1
Variablen, Datentypen und Deklaration
Variablen können in C# (so wie auch in C oder C++) an einer beliebigen Stelle im Programm deklariert werden. Einzige Bedingung: Dies muss innerhalb einer Klasse oder
Methode geschehen.
class eineKlasse
{
public eineKlasse()
{
int zahl;
}
}
Zuerst wird in C# der Datentyp der Variablen mit dem entsprechenden Schlüsselwort
festgelegt, anschließend folgt der Name der Variablen.
Die Zuweisung eines Wertes geschieht in C# wie folgt:
zahl = 10;
Zuerst wird in einer neuen Zeile die Variable bzw. deren Name geschrieben. Es folgen
der Zuweisungsoperator – ein Gleichheitszeichen – und dann der Wert, z. B. eine Zahl,
deren Wert die Variable speichern soll. Zuletzt folgt nach der Ziffer noch ein abschließendes Semikolon.
C# ist case-sensitiv, es wird also zwischen Groß- und Kleinschreibung unterschieden.
Ein Beispiel:
int zahl = 5;
int ZAHL = 10;
42
Kapitel 3: C# im Überblick
Die Variablen zahl und ZAHL sind somit nicht (wie z. B. in Visual Basic oder Pascal)
identisch! Im Beispiel wurden also zwei Variablen deklariert und mit unterschiedlichen
Werten initialisiert.
3.1.1
Simple Datentypen
Im vorherigen Abschnitt wurde die Deklaration und Initialisierung von Variablen
beschrieben. Eigentlich gibt es in C# keine simplen Datentypen, da alles ein Objekt ist
bzw. sich auch hinter diesen Typen eine Klasse verbirgt. Da aber in vielen Sprachen wie
z. B. Java diese Trennung vorhanden ist, wird auch in dieser Erläuterung eine Trennung
zwischen komplexen Typen (z. B. Klassen) und simplen Typen (z. B. Integer-Zahlen)
vorgenommen.
String und Character
Für die Speicherung von einzelnen Zeichen und Zeichenketten gibt es in C# die Datentypen Character (char) und String (string). Um ein Zeichen zu speichern, wird der
Datentyp char verwendet. Muss eine Zeichenkette, also z. B. ein ganzes Wort, gespeichert werden, so wird der Datentyp string verwendet. Für die Deklaration von Strings
und Characters gibt es eine unterschiedliche Syntax:
char EinZeichen;
string MehrereZeichen;
EinZeichen = 'A';
MehrereZeichen = "Eine Zeichenkette";
Auffällig sind hier die Verwendung des Hochkommas bei der Character- und die
Verwendung des Anführungszeichens bei der String-Zuweisung.
Obwohl es sich bei dem Typen String streng genommen um eine Klasse handelt, muss
eine Variable dieses Typs nicht explizit mit dem new-Schlüsselwort erzeugt werden!
Ganz- und Fließkommazahlen
Zur Speicherung von Zahlen in Variablen werden in C# zwei Typengruppen unterschieden. Einmal sind da die Datentypen für die ganzen Zahlen und zum anderen gibt es zur
Speicherung von Fließkommawerten auch entsprechende Datentypen. Ähnlich wie bei
den Zeichenketten gibt es auch hier unterschiedliche Typen. Die Tabellen 3.1 und 3.2
enthalten eine Übersicht.
Bezeichnung/Typ
Wertebereich
Byte
0 – 255
Int16
-32768 bis 32767
Int32
-2147483648 bis 2147483647
Int64
-9223372036854775808 bis 9223372036854775807
3.1 Variablen, Datentypen und Deklaration
Bezeichnung/Typ
Wertebereich
Sbyte
-128 bis 127
UInt16
0 bis 65535
UInt32
0 bis 4294967295
UInt64
0 bis 18446744073709551615
43
Tabelle 3.1: Datentypen für die Speicherung ganzer Zahlen
Bezeichnung/Typ
Wertebereich
float
1.5 x 10-45 bis 3.4 x 1038
double
5.0 x 10-324 bis 1.7 x 10308
decimal
1.0 x 10-28 bis 7.9 x 1028
Tabelle 3.2: Datentypen für die Speicherung von Fließkommazahlen
Die Deklarierung und Initialisierung kann zusammen oder getrennt erfolgen:
double TypDouble;
TypDouble = 1234.50;
int TypInt = 10;
Wahrheitswerte
C# kennt natürlich auch den Typ Boolean zur Bezeichnung von Wahrheitswerten. Eine
Variable von diesem Typ kann nur zwei Zustände (wahr oder falsch) annehmen.
bool wahrOderfalsch;
wahrOderfalsch = true;
Aufzählungen
Aufzählungstypen definieren einen begrenzten Wertebereich. Es wird also eine Variable
deklariert, deren mögliche Inhalte bereits bei der Deklaration festgelegt werden. Denken
Sie hierbei an ein Kinderspielzeug, in das nur bestimmte geometrische Figuren gesteckt
werden können. Generell kann man festhalten, dass ein Aufzählungstyp innerhalb eines
definierten Blocks (z. B. Klammern) angelegt wird.
enum aufzaehlung { Gestern, Heute, Morgen };
Konstanten
In C# werden Konstanten mit dem Schlüsselwort const deklariert:
const double EuroDmWechselkurs = 1.95583;
44
3.1.2
Operatoren
Neben Variablen und Datentypen benötigt man zur Programmierung natürlich noch
etwas mehr. C# kennt Operatoren zur Zuweisung von Werten, zum Vergleich, zur
Berechnung.
Der Zuweisungsoperator = wird benutzt, um einer Variablen einen Wert – dies kann
eine Zeichenkette oder Zahl sein – zuzuweisen:
string Variable = "Hallo Welt";
Als Vergleichsoperator wird in C# das doppelte Gleichheitszeichen == verwendet:
Zahl == 5
Darüber hinaus kann auch wie in Java eine spezielle Methode namens equals zum Vergleich einer Instanz verwendet werden:
Zahl.equals(5)
Das Gegenstück zum Vergleichsoperator in C# ist der Ungleichheitsoperator <>, mit
ihm kann geprüft werden, ob zwei Werte ungleich sind:
6 <> 5
Mit logischen Operatoren können in C# Verknüpfungen von Aussagen getroffen
werden:
(A==1) && (B==2)
(A<1) || (B>2)
(A==1) && (!(B==1))
Im Beispiel sind der UND-Operator (&&), der ODER-Operator (||) und der NOT- oder
Negationsoperator (!) zu sehen. Durch die Verwendung von Klammern können die
Operatoren beliebig kombiniert werden. So geschehen im letzten Beispiel, in dem der
UND-Operator in Kombination mit dem NOT-Operator zu sehen ist.
Neben den bis jetzt aufgeführten Operatoren können für Vergleiche auch die Operatoren in Tabelle 3.3 eingesetzt werden.
Operator
Beschreibung
<
Kleiner als
>
Größer als
<=
Kleiner oder gleich
>=
Größer oder gleich
Tabelle 3.3: Vergleichsoperatoren
3.1 Variablen, Datentypen und Deklaration
45
Zur Berechnung können die Operatoren in Tabelle 3.4 benutzt werden.
Operator
Beschreibung
+
Additionsoperator
-
Subtraktionsoperator
*
Multiplikationsoperator
/
Divisionsoperator
\
Operator für die Division von Integerwerten.
mod
Divisionsrest-Operator (Modulo)
Tabelle 3.4: Arithmetische Operatoren
Tabelle 3.5 enthält eine Übersicht der wichtigsten Operatoren in C#.
Operator
Beschreibung
=
Zuweisungsoperator
==
Vergleichsoperator
!=
Ungleichheitsoperator
&&
UND-Operator
||
ODER-Operator
!
Negationsoperator (NOT-Operator)
^
Logischer Oder-Operator
Tabelle 3.5: C#-Operatoren
Variablen deklarieren mit var
Sind Sie es leid, für jede Variable den korrekten Datentyp herauszusuchen? Seit C# 3.0
ist auch das kein Problem mehr. Mit dem Schlüsselwort var lassen sich Variablen (und
somit auch Objekte) innerhalb einer Methode deklarieren, ohne einen Typ angeben zu
müssen. Vielleicht kennen Sie noch aus Delphi- oder Visual-Basic-Zeiten den VariantDatentyp. In einer solchen Variablen ließ sich wirklich alles unterbringen, angefangen
vom Character bis hin zu einem Bild.
Hat man zuvor eine Integer-Variable wie folgt deklariert:
int zahl = 5;
so ist es mit var möglich, das Ganze auch wie folgt zu schreiben:
var zahl = 5;
Natürlich ist somit auch die folgende Deklarierung und anschließende Zuweisung
korrekt:
var zeichenkette = "Eine Zeichenkette";
46
Allerdings bedeutet die Verwendung von var nicht, dass ein Variant-Datentyp benutzt
wird! Es ist vielmehr so, dass trotz der Verwendung von var zuletzt der korrekte Datentyp eingesetzt wird. Der Compiler analysiert die entsprechenden Codeabschnitte und
wählt anschließend den passenden Datentyp aus. Er ersetzt also quasi das var-Schlüsselwort durch den passenden Datentyp. Somit wird die Anwendung auch nicht langsamer, und es wird auch nicht mehr Speicher benötigt!
Um es noch einmal deutlich zu sagen: Mit var ist kein neuer Datentyp eingeführt
worden, sondern es wird dem Entwickler lediglich etwas Arbeit abgenommen. So führen
beispielsweise die folgenden Zeilen zu einer Fehlermeldung in Visual Studio:
var zahl = 3;
zahl += 1;
zahl = "Hallo";
Der Compiler erkennt zahl durch die Zuweisung des Wertes als Variable vom Typ Integer. Einer Integer-Variablen kann man keinen String zuordnen! Wenn man das im Auge
behält, spricht eigentlich nichts gegen dieses Schlüsselwort. Allerdings kann die Verwendung von var die Lesbarkeit des Codes beeinträchtigen. Nicht mehr, nicht weniger.
3.2
Kontrollstrukturen
Es folgt eine Übersicht der Befehle und Anweisungen zur Steuerung des Programmflusses in C#.
3.2.1
Fallunterscheidung
Basierend auf einer Boole’schen Auswertung kann auch in C# mit der If-else-Anweisung eine Verzweigung innerhalb des Programmflusses ausgeführt werden:
int a = 5;
int b = 10;
if (a>b) {
MessageBox.Show("Der Wert in a ist größer als in b");
}
else {
MessageBox.Show("Der Wert in b ist größer als in a");
}
3.2.2
Mehrfachauswahl
Neben der einfachen Fallunterscheidung kennt C# natürlich die Mehrfachauswahl, die
auch als case-Anweisung bekannt ist. Eine Mehrfachauswahl wird in C# mit dem Befehl
switch eingeleitet. Nach jedem case-Zweig muss in C# zusätzlich eine break-Anwei-
3.2 Kontrollstrukturen
47
sung eingefügt werden. Folgt keine break-Anweisung, so wird auch der nachfolgende
Zweig durchlaufen.
int auswahl;
auswahl = 22;
switch (auswahl)
{
case 5:
MessageBoc.Show("Die
break;
case 10:
break;
case 20:
break;
default:
break;
}
Variable enthält den Wert 5");
Variable enthält weder 5, 10 noch 20!");
Listing 3.1
Der letzte Zweig default wird durchlaufen, sofern kein vorheriger case-Fall zutreffend
war.
3.2.3
Schleifen
In C# gibt es vier unterschiedliche Schleifentypen. Da sind zuerst die sogenannten kopfund fußgesteuerten Varianten. Neben diesen beiden Typen gibt es in C# auch noch eine
Zählschleife. Darüber hinaus ist es auch in C# möglich, mit einer sogenannten foreachSchleife Listen von Objekten zu durchlaufen.
Schleife kopfgesteuert
Das folgende Beispiel demonstriert den Einsatz einer kopfgesteuerten Schleife in C#. In
C# werden diese auch als while-Schleifen bezeichnet:
int a = 0;
int b = 10;
while (a<=b) {
a = a + 1;
}
48
Schleife fußgesteuert
Eine fußgesteuerte Schleife wird in C# mit dem do while-Konstrukt gebildet:
int a = 5;
int b = 10;
do
{
a = a + 1;
} while (a > b);
Zählschleife
Es folgt die Syntax einer Zählschleife in C#.
for (int i = 1; i <= 10; i++)
{
a = a + i;
MessageBox.Show(a.toString());
}
Das Listing zeigt die aufsteigende Variante, möglich wäre aber auch, die Schleife absteigend laufen zu lassen:
int i = 10; i > 1; i--
foreach-Schleife
Erst in den letzten Jahren kam zu den klassischen Schleifen die foreach-Schleife hinzu.
Sie ist unter anderem in PHP verbreitet und wurde in C# übernommen. Eine foreachSchleife wird immer dann benutzt, wenn eine unbestimmte Anzahl an Elementen vom
Anfang bis zum Ende durchlaufen werden soll.
int[]sammlung = new int[] {0, 1, 2, 3, 4, 5};
foreach (int i in sammlung)
{
System.Console.WriteLine(i);
}
Im Beispiel wird ein Integer-Array (siehe folgenden Abschnitt) erzeugt und mit Werten
initialisiert. Anschließend wird mittels der foreach-Schleife jedes einzelne Element
ausgegeben.
Die foreach-Schleife wird hauptsächlich in Verbindung mit Sammlungstypen (Collections) oder Arrays benutzt.
3.2 Kontrollstrukturen
3.2.4
49
Arrays
Arrays werden in C# analog zu den Variablen zuerst mit dem verwendeten Datentyp
deklariert:
int[] zahlenArray = new int[10];
Durch die Angabe von [10] wird die Dimension des Arrays festgelegt. Im Beispiel sind
es zehn Stellen. Jede Stelle kann durch Angabe des Arraynamens in Kombination mit
dem entsprechenden Index angesprochen werden:
zahlenArray[5] = 5;
Sollen alle zehn Stellen des Arrays beispielsweise mit einem Integer-Wert initialisiert
werden, so wird dies am besten mit einer for-Schleife erledigt:
int[] zahlenArray = new int[10];
for (int i = 1; i <= 10; i++)
{
zahlenArray[i] = i;
}
Ein Array kann auch in C# mehr als nur eine Dimension haben. Dann wird es wie folgt
deklariert:
int[,] matrix = new int[10,10];
Im Beispiel ergibt sich ein zweidimensionales Array mit 10 x 10 Feldern. Die einzelnen
Zellen können wie bisher über einen Index angesprochen werden. Allerdings besteht
dieser Index jetzt aus zwei Angaben. Um beispielsweise die dritte Zelle in der dritten
Reihe ansprechen zu können, muss sowohl der Index für die Reihe als auch für die
Spalte angegeben werden:
matrix[3,3] = 11;
3.2.5
Strukturen
Eine Struktur ermöglicht die Zusammenfassung unterschiedlicher Variablen zu einer
Struktur, die dann über einen Namen angesprochen werden kann. Die einzelnen
Variablen dieser Struktur können gezielt aufgerufen und es können Werte zugewiesen
werden. Für eine Person könnte dies wie folgt aussehen:
Person
•
Nachname
•
Vorname
•
Personalnummer
In C# werden Strukturen mithilfe des Schlüsselwortes struct umgesetzt. Um bei dem
Beispiel Person zu bleiben, würde für den Vor- und Nachnamen je eine Variable vom
50
Typ String innerhalb der Struktur angelegt. Um die Personalnummer zu speichern, wird
eine Variable vom Typ Integer definiert. In C# ergibt sich somit folgende Struktur:
public struct Person
{
public string Nachname;
public string Vorname;
public int Personalnummer;
}
Die einzelnen Variablen sind somit Bestandteil der Struktur und können mittels einer
Variablen des Typs angesprochen werden. Die Struktur kann so noch nicht genutzt,
sondern muss erst erzeugt werden:
class Program
{
public struct Person
{
public string Nachname;
public string Vorname;
public int Personalnummer;
}
static void Main(string [] args)
{
Person person;
person.Nachname = "Bleske";
person.Vorname = "Christian";
person.Personalnummer = 123456;
}
}
Listing 3.2
Im Beispiel ist zu sehen, wie die einzelnen Variablen der Struktur angesprochen werden
können, nämlich mittels des Punktoperators. Die Kennzeichnung der Variablen mit
dem Schlüsselwort public bewirkt, dass die Variablen angesprochen werden können.
Das Gegenstück wäre die Kennzeichnung private. Eine mit private gekennzeichnete
Variable kann außerhalb der Struktur nicht angesprochen werden. Mehr hierzu im
Abschnitt 3.3 über Klassen.
3.3 Klassen
3.2.6
51
Typumwandlung
C# unterstützt natürlich die Umwandlung von einem Typ in einen anderen:
int i = 20;
double d = 0;
d = i;
i = (int)d;
Bei der Umwandlung des Integer-Werts in den Double-Typ handelt es sich um eine
implizite Konvertierung. Daten können an dieser Stelle nicht verloren gehen, da ein
kleiner in einen größeren Typ umgewandelt wird. Bei der folgenden expliziten
Umwandlung wird hingegen zumindest der Nachkommaanteil des Double-Wertes
abgeschnitten. Daten gehen also verloren. Da alle Typen, auch die simplen, in C# von
einer gemeinsamen Basisklasse abgeleitet sind, besitzen die Objekte auch eine abgeleitete
Methode zur Umwandlung in eine Zeichenkette, die mit Objektname.ToString() aufgerufen wird. Außerdem gibt es noch eine spezialisierte Klasse namens Convert zur
Typumwandlung:
string zeichen = Convert.ToString(i);
Die Klasse Convert ist mehrfach überladen, das heißt, es werden alle möglichen Umwandlungsfunktionen (ToByte, ToInt, ToString …) bereitgestellt.
3.3
Klassen
Der folgende Abschnitt gibt eine kurze Einführung in die objektorientierte Programmierung mit C#. Der Schwerpunkt liegt dabei auf den Möglichkeiten, die die Sprache im
Rahmen der objektorientierten Programmierung bietet.
Was sind Objekte?
Die objektorientierte Programmierung galt bei ihrer Einführung als die Lösung für die
immer komplexer werdenden Programme und Problemstellungen. Statt die reale Welt
in Prozeduren und Funktionen zu transformieren, war es mit der objektorientierten
Programmierung erstmals möglich, eine reale Struktur in Form eines Programms
nachzubilden. Statt also eine Person nur mit Funktionen und Prozeduren zu beschreiben bzw. die einzelnen Daten, wie z. B. Nachname, Vorname usw., zu verarbeiten, ist es
mit der objektorientierten Programmierung möglich, ein reales Objekt in Form eines
Programms nachzubilden. Diese Art der Programmierung kommt dem menschlichen
Denken näher als die prozedurale Programmierung. So verfügt ein Objekt, z. B. eine
Person, über Eigenschaften (Name, Größe oder auch Personalnummer), und eben diese
Eigenschaften lassen sich mit der objektorientierten Programmierung in Form von Programmcode nachbilden.
Ein Objekt ist dabei der zentrale Dreh- und Angelpunkt während der Entwicklung. So
kann ein Objekt nicht nur Daten enthalten, sondern es stehen auch Methoden innerhalb
des Objektes bereit, um diese Daten zu manipulieren. Ein Beispiel für ein Objekt ist ein
125
Teil 2 – Apps entwickeln
Der erste Teils des Buches befasste sich hauptsächlich mit den Werkzeugen zum Entwickeln von Apps. Im zweiten Teil des Buches geht es um das Detailwissen, das zur
Entwicklung von Apps benötigt wird.
127
7
Entwicklung einer App
Eine App ist mehr als nur eine Seite, auf der sich ein paar Steuerelemente befinden. Eine
App besteht vielmehr aus kleinen Bausteinen, die später, wenn das Projekt kompiliert
wird, zusammen eine Anwendung ergeben.
7.1
Aufbau einer App
Legen Sie in Visual Studio ein neues Projekt an. Wählen Sie als Vorlage die Windows
Phone Application aus. Es dauert einen Moment, dann ist in der Entwicklungsumgebung
auf der linken Seite der Phone-Designer und auf der rechten der XAML-Editor zu sehen.
Richten Sie Ihren Blick nun auf den Solution-Explorer von Visual Studio. Erweitern Sie
alle Ordner und betätigen Sie anschließend die Schaltfläche Show All Files.
Bild 7.1: Eine Windows Phone
App im Solution-Explorer
In dieser Ansicht sind fast alle Elemente des Projekts sichtbar. Es fehlen lediglich die
Dateien, die im Anschluss an die Kompilierung eines Projekts in den Ordnern Debug
und Release vorhanden sind.
128
7.1.1
Kapitel 7: Entwicklung einer App
Der Properties-Ordner
Geht man von oben nach unten, so ist da zuerst der Ordner Properties. Dieser enthält
drei Dateien: AppManifest.xml, AssemblyInfo.cs und WMAppManifest.xml.
Die Datei AppManifest.xml enthält Informationen über die von der App benötigten/verwendeten Bibliotheken (DLL). In dieser Datei ist zumindest ein Verweis auf die
Projektdatei enthalten. Im Beispiel ist dies WindowsPhoneApplication.dll. In der Datei
könnten aber noch weitere Bibliotheken aufgeführt sein.
<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
EntryPointAssembly="WindowsPhoneApplication"
EntryPointType="WindowsPhoneApplication.App" RuntimeVersion="3.0.40624.0">
<Deployment.Parts>
<AssemblyPart x:Name="WindowsPhoneApplication"
Source="WindowsPhoneApplication.dll" />
</Deployment.Parts>
</Deployment>
Ferner kann der Datei AppManifest.xml auch der Einstiegspunkt (EntryPointType) in die
Anwendung entnommen werden. Im Beispiel ist dies WindowsPhoneApplication.App.
Genau dieser Punkt ist direkt zu Beginn innerhalb der Datei App.xaml zu finden:
<Application
x:Class="WindowsPhoneApplication.App"
//Quellcode entfernt…
In der Datei AppManifest.xml sind also wie gesagt alle vom Projekt verwendeten Bibliotheken zu finden. Sie wird nicht in das Projekt kompiliert, sondern ist immer separat
verfügbar. Wenn das Projekt später in den Marketplace geladen wird, muss diese Datei
mit übertragen werden.
Als Nächstes folgt im Properties-Ordner die Datei AssemblyInfo.cs. In dieser Datei werden die Eigenschaften der App definiert. Beispielsweise die Versionsnummer, der Name
oder ein Copyright-Vermerk.
Zuletzt findet man im Properties-Ordner die Datei WMAppManifest.xml. Diese Datei
enthält detaillierte Informationen über die Anwendung. So ist hier unter anderem der
Titel der App hinterlegt. Außerdem ist hier der Name der Icon-Datei gespeichert und
das Page-Objekt, mit dem die Anwendung gestartet wird, ist hinterlegt. Darüber hinaus
enthält die Datei Informationen über von der App verwendete Funktionen. Also zum
Beispiel, ob die App das Mikrofon verwendet oder Netzwerkdienste in Anspruch nimmt.
Das folgende Listing zeigt den Inhalt einer WMAppManifest.xml.
<Deployment
xmlns="http://schemas.microsoft.com/windowsphone/2009/deployment"
AppPlatformVersion="7.0">
7.1 Aufbau einer App
129
<App xmlns="" ProductID="{cfacaa54-5055-4461-9168-551c61c827c7}"
Title="WindowsPhoneApplication" RuntimeType="Silverlight" Version="1.0.0.0"
Genre="apps.normal" Author="WindowsPhoneApplication author"
Description="Sample description" Publisher="WindowsPhoneApplication">
<IconPath IsRelative="true"
IsResource="false">ApplicationIcon.png</IconPath>
<Capabilities>
<Capability Name="ID_CAP_MICROPHONE"/>
<Capability Name="ID_CAP_NETWORKING"/>
<Capability Name="ID_CAP_PHONEDIALER"/>
<Capability Name="ID_CAP_PUSH_NOTIFICATION"/>
<Capability Name="ID_CAP_SENSORS"/>
<Capability Name="ID_CAP_WEBBROWSERCOMPONENT"/>
</Capabilities>
<Tasks>
<DefaultTask Name ="_default" NavigationPage="MainPage.xaml"/>
</Tasks>
<Tokens>
<PrimaryToken TokenID="WindowsPhoneApplicationToken"
TaskName="_default">
<TemplateType5>
<BackgroundImageURI IsRelative="true"
IsResource="false">Background.png</BackgroundImageURI>
<Count>0</Count>
<Title>WindowsPhoneApplication</Title>
</TemplateType5>
</PrimaryToken>
</Tokens>
</App>
</Deployment>
Listing 7.1: WMAppManifest.xml
Auch diese Datei muss mit in den Marketplace übertragen werden.
7.1.2
Der Ordner References
Innerhalb des Projektmappen-Explorers folgt als Nächstes der Ordner References. In
diesem Ordner werden alle Silverlight-Bibliotheken aufgeführt, die im Projekt verwendet werden. In der Regel sind dies: Microsoft.Phone, Microsoft.Phone.Interop, mscorelib,
system, System.core, System.Net, System.Windows sowie System.xml.
130
7.1.3
Die Ordner bin und obj
Es folgen die Ordner bin (das Kürzel steht für »Binary«) mit den Unterverzeichnissen
Debug und Release sowie obj, das ebenfalls je einen Ordner mit der Bezeichnung Debug
und Release enthält. In den Ordnern Debug und Release, welche in bin enthalten sind,
befinden sich die folgenden Dateien: AppManifest.xml, ApplicationIcon.png, Background.png, WindowsPhoneApplication.dll, WindowsPhoneApplication.pdb und WindowsPhoneApplication.xap.
Während die Funktion der Konfigurationsdatei und der Bilddateien bekannt ist, stellt
sich die Frage, wofür die anderen drei Dateien benötigt werden. Die DLL enthält die
eigentliche Anwendung, und die Datei von Typ .pdb (das Kürzel steht für »Program
Debug Database«) ist eine Symboldatei und wird zum Debuggen der App benötigt.
Es bleibt die Datei mit der Kennung .xap. Hierbei handelt es sich um die Zusammenfassung aller Dateien im Verzeichnis in einem Archiv. Vergleichbar ist dieses Prinzip mit
den JAR-Archiven von Java-Projekten. Es handelt sich also um eine komprimierte
Zusammenfassung. Diese wird später auch auf das Windows Phone übertragen. Schauen
Sie sich das Ganze doch einmal in einem Komprimierungsprogramm wie z. B. 7z an. In
dieser Anwendung lässt sich die Datei nämlich öffnen und einsehen.
Bild 7.2: Eine dekomprimierte XAP-Datei
Wenn Sie die Dateikennung in .zip ändern, so können Sie die darin enthaltenen Dateien
auch dekomprimieren. Bei einer XAP-Datei handelt es sich also um eine kompilierte
Silverlight-Datei, die so für die Auslieferung benutzt werden kann.
Im bin-Ordner und seinen Unterverzeichnissen ist alles enthalten, was zur Verteilung
der App benötigt wird. In den obj-Ordner und die zugehörigen Unterverzeichnisse wird
alles kopiert, was zum Kompilieren der App benötigt wird. Das bedeutet: Nur im binOrdner wird man ggf. zusätzlich benötigte Assemblies (DLLs) wie zum Beispiel ThirdParty-Controls finden, die nicht in die fertige Datei kompiliert werden, nicht aber im
obj-Ordner.
131
Zuletzt bleiben im Projekt noch die Dateien App.xaml und App.xaml.cs sowie eine oder
auch mehrere Page-Dateien (zumindest MainPage.xaml und MainPage.xaml.cs) übrig.
In Kapitel 4 wurden die Bedeutung dieser Dateien und ihre Beziehung untereinander
erläutert.
Verpackt als XAP-Datei kommt die App dann über den Microsoft Marketplace auf ein
Windows Phone.
7.1.4
Lebenszyklus einer App
Sobald die App im Marketplace ausgewählt wurde und man sich für die Installation
entschieden hat, wird die XAP-Datei auf das Handy übertragen.
Bild 7.3: Das Marketplace-Symbol
Dort angelangt, wird die App automatisch erkannt und installiert. Dies geschieht ohne
Interaktion mit dem Anwender. Die App wird allerdings nicht automatisch auf dem
Startbildschirm abgelegt. Es ist erforderlich, durch einen Klick auf das Symbol in die
Programmübersicht des Handys zu wechseln.
Bild 7.4: Übersicht über die installierten Apps
Berührt man den Programmnamen und hält den Eintrag gedrückt, wird anschließend
ein Menü geöffnet, siehe Bild 7.5, in dem zwei Menüpunkte vorhanden sind. Mit dem
einen lässt sich die App wieder deinstallieren, mit dem anderen kann ein App-Symbol
als Live Tile in die Startseite des Handys eingefügt werden.
Bild 7.5: Das App Live Tile auf der Startseite
Das Live Tile kann von der Startseite wieder entfernt werden, indem es gedrückt und
einen Moment lang »gehalten« wird. Anschließend öffnet sich ein Symbol, das nach
132
Betätigung das Live Tile wieder entfernt. Ein kurzes Antippen startet die App. Der sogenannte Lebenszyklus der Anwendung beginnt.
Starten, Ausführen und Beenden einer App
Einstiegspunkt in die Anwendung ist die Klasse App, die aus den zwei Dateien App.xaml
und App.xaml.cs besteht. Der XAML-Teil, der für die GUI zuständig ist, wurde in Kapitel 4 bereits vorgestellt. Jetzt geht es um die Ausführung der App, und dort rückt der in
C# generierte Quellcode in den Fokus.
public partial class App : Application
{
public App()
{
//Quellcode entfernt
}
private void Application_Launching(object sender,
LaunchingEventArgs e)
{
}
private void Application_Activated(object sender,
ActivatedEventArgs e)
{
}
private void Application_Deactivated(object sender,
DeactivatedEventArgs e)
{
}
private void Application_Closing(object sender,
ClosingEventArgs e)
{
}
//Quellcode entfernt
}
Listing 7.2: Die Datei App.xaml.cs
Starten und Beenden
Die vier Methoden Application_Launching, Application_Closing, Application_
Activated und Application_Deactivated in der Datei App.xaml.cs spielen eine zentrale
Rolle im Lebenszyklus der App. Beim Start werden zunächst der Inhalt des Konstruktors
abgearbeitet und dann das Ereignis Application_Launching ausgeführt. Im Anschluss
läuft die Anwendung. Um die Anwendung zu beenden, muss der Back-Button des
133
Handys auf der Startseite der App betätigt werden. Sobald der Back-Button betätigt
wurde, wird im Code die Methode Application_Closing ausgeführt. Nach Abarbeitung
des in dieser Methode enthaltenen Codes ist die Anwendung beendet. Wenn Sie
entsprechende Breakpoints setzen, dann können Sie dieses Verhalten nachvollziehen.
Aktivieren und Deaktivieren
Jetzt gibt es aber noch die beiden Ereignisse Application_Activated und Application_
Deactivated. Sie werden offensichtlich zu einem anderen Zeitpunkt aufgerufen.
Letztere Ereignisse werden in einem Kontext ausgeführt, der erst einmal nichts mit dem
Starten oder Beenden der App zu tun hat. Startet man eine App und betätigt anschließend den Windows-Button, werden Sie feststellen, dass – wie erwartet – wieder der
Startbildschirm angezeigt wird. Setzt man im Quelltext jetzt aber zwei Breakpoints,
einen bei Application_Deactivated und den anderen im Ereignis Application_
Closing, und wiederholt den Versuch, so stellt man fest, dass das Ereignis Application_
Deactivated ausgeführt wird und nicht – wie erwartet – Application_Closing. Warum
dieser Unterschied? In beiden Fällen wird die Anwendung offensichtlich geschlossen,
denn selbst geschriebene Apps können nicht im Hintergrund ausgeführt werden.
Sie erinnern sich sicher noch an den Back-Button. Mit ihm kann man durch die App
navigieren und sich die bereits einmal aufgerufenen Pages wieder anzeigen lassen. Das
Ganze funktioniert auch anwendungsübergreifend. Wird nun eine andere Anwendung
gestartet oder der Windows-Button betätigt, so merkt sich Windows Phone im Gegensatz zum Schließen der App den aktuellen Zustand, damit der Anwender zu ihm
zurückkehren kann. Deshalb wird auch nicht das Application_Closing-Ereignis ausgeführt, sondern Application_Deactivated. Sobald also eine App deaktiviert wird,
versieht Windows Phone sie mit einem sogenannten Tombstone (zu Deutsch: Grabstein) und merkt sich den Status der App. Über den Back-Button besteht dann die Möglichkeit, zur App inklusive des aktuellen Status zurückzukehren. Trotzdem wird auch
nach Ausführung von Application_Deactivated die App beendet.
Es gibt mehrere Situationen, in denen eine App deaktiviert wird. Dies sind: Betätigung
des Windows-Buttons, Timeout und Aufruf des Lock-Fensters sowie wenn eine andere
App im Vordergrund ausgeführt wird. In allen genannten Fällen wird die zuvor ausgeführte App nicht beendet, sondern »nur« deaktiviert.
Wenn die App deaktiviert und mit einem Tombstone versehen wurde, können zu ihrer
erneuten Aktivierung unterschiedliche Dinge passieren. Entweder der Anwender betätigt
den Back-Button so lange, bis er zur App zurückkehrt, oder eine andere Anwendung
(z. B. die zum Telefonieren) gibt den Screen wieder frei, und die App wird wieder
aktiviert. Das wird durch Auslösen des Ereignisses Application_Activated eingeleitet.
Anschließend wird die zuletzt angezeigte Seite der App wieder aufgerufen, und man
kann dort weiterarbeiten, wo man zuletzt aufgehört hat.
134
Die vier Ereignisse in der Klasse App beschreiben den Lebenszyklus einer App also sehr
gut. Dieser besteht aus:
•
dem Start der App (Application_Launching)
•
der Deaktivierung (Application_Deactivated)
•
der erneuten Aktivierung (Application_Activated)
•
der endgültigen Beendigung der App (Application_Closing)
Praktisch können Sie diesen Lebenszyklus auch bei der Denkmal-App beobachten.
Durch die Verwendung der Kamerafunktion innerhalb der App wird auch diese deaktiviert, um ein Foto erstellen zu können. Anschließend wird die App wieder aktiviert,
damit mit ihr weitergearbeitet werden kann.
Hinweis: In Abschnitt 7.1.9, »Speichern und Wiederherstellen des Anwendungsstatus«, wird ein Beispiel vorgestellt, wie der Status einer Anwendung gespeichert
(Application_Activated) und wiederhergestellt (Application_Deactivated) werden
kann.
7.1.5
Die Klasse Page
Zentrales Element jeder App ist eine Page-Instanz. Mindestens eine Page gibt es in jeder
App, die MainPage. Diese Seite wird bereits in der Datei WMAppManifest.xml referenziert und dort als Startseite festgelegt. Was für die Klasse App gilt, gilt auch für die PageKlasse. Sie besteht aus zwei Teilen. Der Code-Teil basiert auf C#, der GUI-Teil auf
XAML. Eine Page-Instanz wird immer von der Klasse PhoneApplicationPage abgeleitet.
Wird ein neues Projekt über eine Vorlage erstellt, so ist zumindest immer eine Page
Bestandteil des Projekts. Neue Page-Objekte können über das Kontextmenü des Solution-Explorers über die Menüpunkte Add -> New Item in das Projekt eingefügt werden.
Sobald eine Page im Solution-Explorer von Visual Studio markiert wurde, wird der
Page-Designer zusammen mit dem zugehörigen XAML-Code angezeigt.
135
Bild 7.6: Eine Page im Designer
Eine neu eingefügte Page enthält allerdings immer zusätzliche Steuerelemente. Dies sind
zwei TextBlock-Controls, die den Page- und den Application-Titel enthalten, sowie zwei
Grid-Steuerelemente für das Basislayout.
Der XAML-Teil
Entfernt man diese Steuerelemente aus der Page, so bleibt ein Container zurück, der nur
noch wenig Code enthält:
<phone:PhoneApplicationPage
x:Class="WindowsPhoneApplication.MainPage"
<! -- Quellcode entfernt -->
FontFamily="{StaticResource PhoneFontFamilyNormal}"
FontSize="{StaticResource PhoneFontSizeNormal}"
Foreground="{StaticResource PhoneForegroundBrush}"
SupportedOrientations="Portrait" Orientation="Portrait"
mc:Ignorable="d" d:DesignHeight="768" d:DesignWidth="480"
shell:SystemTray.IsVisible="True">
</phone:PhoneApplicationPage>
Enthalten sind dann nur noch einige Namespaces und einige gesetzte Eigenschaften.
Der C#-Teil
Der C#-Teil der Page wird sichtbar, wenn man entweder über das Properties-Fenster
einen Ereignis-Handler in der Page-Instanz erzeugt oder aber über den Solution-Explorer die Page-Ansicht dort erweitert.
136
Bild 7.7: Erweiterte Ansicht im Solution-Explorer
Ein Doppelklick auf das Icon öffnet die Codeansicht der Klasse in Visual Studio.
using
using
using
using
using
using
using
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Net;
System.Windows;
System.Windows.Controls;
System.Windows.Documents;
System.Windows.Input;
System.Windows.Media;
System.Windows.Media.Animation;
System.Windows.Shapes;
Microsoft.Phone.Controls;
namespace WindowsPhoneApplication
{
public partial class MainPage : PhoneApplicationPage
{
// Constructor
public MainPage()
{
InitializeComponent();
}
}
}
Neben den standardmäßig hinzugefügten Bibliotheken, welche via Using-Klausel eingebunden wurden, ist natürlich die Page-Klasse selbst Bestandteil der Datei. Eine einzelne
Methode (InitializeComponent) wird im Konstruktor der Page vordefiniert aufgerufen. Positioniert man den Cursor auf dem Methodennamen und betätigt die Taste F12,
so wird man automatisch zur Definition der Methode geführt.
public void InitializeComponent() {
if (_contentLoaded) {
return;
}
_contentLoaded = true;
System.Windows.Application.LoadComponent(this, new
System.Uri("/WindowsPhoneApplication;component/MainPage.xaml",
System.UriKind.Relative));
this.LayoutRoot =
((System.Windows.Controls.Grid)(this.FindName("LayoutRoot")));
137
this.TitlePanel =
((System.Windows.Controls.StackPanel)(this.FindName("TitlePanel")));
this.ApplicationTitle =
((System.Windows.Controls.TextBlock)(this.FindName("ApplicationTitle")));
this.PageTitle =
((System.Windows.Controls.TextBlock)(this.FindName("PageTitle")));
this.ContentPanel =
((System.Windows.Controls.Grid)(this.FindName("ContentPanel")));
}
Schaut man sich diese Methode etwas näher an, so fällt auf, dass hier auf den zweiten
Teil der Klasse, den XAML-Code, zugegriffen wird. Mittels der Methode LoadComponent
wird die zugehörige XAML-Datei gelesen, um dort enthaltene Informationen, z. B. den
ApplicationTitle, zu lesen.
Eigenschaften und Methoden
Blickt man auf die Eigenschaften einer Page, so fallen einige Punkte ins Auge. Die erste
Eigenschaft ist ApplicationBar. Dahinter verbirgt sich die Möglichkeit, eine PageInstanz mit einer Leiste für besondere Funktionen auszustatten, die für den Anwender
direkt erreichbar sein sollen. Im folgenden Abschnitt wird diese Funktion vorgestellt.
Anschließend folgen die beiden Eigenschaften BorderBrush und BorderThickness, mit
denen sich Farbe und Stärke des Rahmens einer Page einstellen lassen. Auch der verwendete Font lässt sich konfigurieren. Dies geschieht mit FontFamily, FontSize,
FontStretch, FontStyle und FontWeight. Mittels der Eigenschaft Foreground lässt sich
die verwendete Farbe im Vordergrund der Page festlegen. Auch die Ausrichtung einer
Page lässt sich über eine Eigenschaft Orientation steuern. Hierzu später mehr. Die
Höhe und Breite einer Page werden über Height und Width festgelegt.
Verschiedene Ereignisse, auf die eine Page reagiert, lassen sich nutzen, um den Programmfluss zu steuern. Betätigt beispielsweise ein Anwender den Back-Button, so wird
das Ereignis BackKeyPress ausgelöst. Einen Ereignishandler hierfür können Sie durch
einen Doppelklick im Register Events von Visual Studio automatisch erzeugen. Sobald
eine Page vollständig geladen wurde, wird das Ereignis Loaded ausgelöst.
OrientationChanged reagiert, sobald die Ausrichtung einer Page sich ändert, und das
Ereignis Unloaded wird ausgelöst, wenn die Page vom Anwender verlassen wird. In
Abschnitt 7.4 wird vorgestellt, wie man mit dem Ereignis ManipulationStarted arbeitet.
Es wird verwendet, um zu überprüfen, ob ein Anwender die Oberfläche des Smartphones berührt hat.
7.1.6
Die Application Bar
Wenn Sie eine neue Page einfügen oder auch ein neues Projekt beginnen, so finden Sie
innerhalb einer Page im XAML-Teil folgenden Code, der auskommentiert ist:
60109-2 U1+U4
03.05.2011
10:14 Uhr
Seite 1
Christian Bleske
Christian Bleske
Aus dem Inhalt:
Know-how
ist blau.
• Windows Phone 7 im Detail
• Betriebssystem-Basics
• Das XNA-Framework
Programmierung –Tools – Funktionen
• Die Oberflächenbeschreibungssprache
und Silverlight
• Kurze Einführung in C#
XAML
• Windows Phone Developer Tools
Microsofts Windows Phone 7 ist neben Apple iOS und Google Android das
dritte große Smartphone-Betriebssystem auf dem Markt – was noch fehlt,
sind Apps! Dieses Buch zeigt, wie Sie diese Chance nutzen und Apps für
Windows Phone 7 entwickeln. Anhand einer konkreten Beispielapplikation
lernen Sie alle wichtigen Funktionen und das Oberflächendesign kennen und
programmieren. Zudem zeigt Autor Christian Bleske ausführlich, wie Sie Ihre
App fit für den Windows Phone-Marketplace machen.
씰
씰
씰
Windows Phone 7 macht vieles einfacher
Mit Windows Phone 7 hat Microsoft viel Ballast abgeworfen. So gibt es die
verschachtelten Menüs früherer Windows-Mobile-Versionen nicht mehr.
Auch für Entwickler wurde vieles einfacher: Die Applikationslogik wird nun
einheitlich in .NET-Sprachen wie C# programmiert, die Benutzeroberfläche
in der XML-basierten Sprache XAML gestaltet. Christian Bleske zeigt, wie
das Zusammenspiel zwischen C# und XAML funktioniert und wie die
beiden Ebenen ineinander greifen. Er führt kurz in die Entwicklungswerkzeuge Windows Phone Developer Tools ein und zeigt, wie Sie schnell
überzeugende Bedieneroberflächen für Ihre Apps programmieren.
• Projekte anlegen, kompilieren
und debuggen
• Der Aufbau einer App
• Konzept und Umsetzung der Beispiel-App
• Layout- und Oberflächentypen
• Die Steuerelemente
• Dateien laden und speichern
• Positionsbestimmung mit Geodaten
• Fotos in die App einbinden
• Die Lokalisierung der App
• Push Notifications
• Die App testen
• Veröffentlichung der App im Windows
Marketplace
Von der App-Idee bis zum Marketplace
Dieses Buch zeigt, wie Sie eine App für Windows Phone 7 von der ersten Idee
bis zum Einstellen in den Marketplace realisieren. Christian Bleske hat dafür
eine App entworfen, mit der Sie Daten zu Bauwerken aufnehmen und
verwalten können – komplett mit Fotos und Geo-Informationen.
Der Autor skizziert, wie Sie die App konzipieren und das Projekt in der
Entwicklungsumgebung anlegen. Schritt für Schritt erläutert er Ihnen die
einzelnen Funktionen von der Oberflächengestaltung über die Datenspeicherung bis hin zum Einbinden von Bild- und Positionsdaten. Zuletzt
zeigt er Ihnen, wie Sie die Anwendung testen und hilft Ihnen, den Zertifizierungsprozess beim Einstellen in den Marketplace zu bestehen.
Geld verdienen mit Windows Phone-Apps
Apps zu programmieren macht Spaß – und es kann sich lohnen! Wenn Sie
mit selbstentwickelten Apps für Windows Phone 7 Geld verdienen wollen,
dann müssen Sie sich bei Microsoft registrieren und brauchen eine
US-amerikanische Steuernummer. Klingt kompliziert, ist es aber nicht.
Christian Bleske ist diesen Weg für Sie gegangen und zeigt, wie Sie auf
Anhieb alles richtig machen.
Über den Autor:
Christian Bleske ist Autor,
Trainer und Entwickler.
Sein Arbeitsschwerpunkt
liegt auf MicrosoftTechnologien. Seine Fachaufsätze erscheinen in
vielen namhaften Entwicklerzeitschriften. Er lebt in
Witten im Ruhrgebiet.
Auf www.buch.cd
Der komplette Quellcode der im Buch
beschriebenen Beispiel-Applikation
30,– EUR [D]
ISBN 978-3-645-60109-2
Besuchen Sie unsere Website
www.franzis.de
Windows
Programmierung – Tools – Funktionen
> Programmieren Sie für das neue Smartphone-Betriebssystem von Microsoft!
> So gestalten Sie griffige Benutzeroberflächen
> Das Zusammenspiel von C# und XAML verstehen
> So machen Sie Ihre App fit für den Windows Phone-Marketplace
Bleske
Windows
Windows Phone 7-Apps
• Das .NET Compact Framework
Programmierung
Tools
Funktionen
Vorwort von Dr. Frank Prengel, Technical Evangelist
für Windows Phone bei Microsoft

Windows Phone 7-Apps entwickeln - Leseprobe

Transcription

Similar documents

Obfuscator-Techniken, oder wie kann in .NET Programmcode

PDF-Version - am Institut für Baustatik

Präsentation als pdf