windows phone 7-apps - ciando ebooksmit selbstentwickelten apps für windows phone 7 geld verdienen...

45
Christian Bleske > 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 Windows Phone 7-Apps entwickeln Programmierung – Tools – Funktionen Know-how ist blau. Vorwort von Dr. Frank Prengel, Technical Evangelist für Windows Phone bei Microsoft

Upload: others

Post on 27-May-2020

9 views

Category:

Documents


0 download

TRANSCRIPT

Christian Bleske

> 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

Windows Phone 7-Apps entwickelnProgrammierung – Tools – Funktionen

Microsofts Windows Phone 7 ist neben Apple iOS und Google Android dasdritte große Smartphone-Betriebssystem auf dem Markt – was noch fehlt,sind Apps! Dieses Buch zeigt, wie Sie diese Chance nutzen und Apps fürWindows Phone 7 entwickeln. Anhand einer konkreten Beispielapplikationlernen Sie alle wichtigen Funktionen und das Oberflächendesign kennen undprogrammieren. Zudem zeigt Autor Christian Bleske ausführlich, wie Sie IhreApp fit für den Windows Phone-Marketplace machen.

� Windows Phone 7 macht vieles einfacherMit Windows Phone 7 hat Microsoft viel Ballast abgeworfen. So gibt es dieverschachtelten Menüs früherer Windows-Mobile-Versionen nicht mehr.Auch für Entwickler wurde vieles einfacher: Die Applikationslogik wird nuneinheitlich in .NET-Sprachen wie C# programmiert, die Benutzeroberflächein der XML-basierten Sprache XAML gestaltet. Christian Bleske zeigt, wiedas Zusammenspiel zwischen C# und XAML funktioniert und wie diebeiden Ebenen ineinander greifen. Er führt kurz in die Entwicklungs-werkzeuge Windows Phone Developer Tools ein und zeigt, wie Sie schnellüberzeugende Bedieneroberflächen für Ihre Apps programmieren.

� Von der App-Idee bis zum MarketplaceDieses Buch zeigt, wie Sie eine App für Windows Phone 7 von der ersten Ideebis zum Einstellen in den Marketplace realisieren. Christian Bleske hat dafüreine App entworfen, mit der Sie Daten zu Bauwerken aufnehmen undverwalten können – komplett mit Fotos und Geo-Informationen.Der Autor skizziert, wie Sie die App konzipieren und das Projekt in derEntwicklungsumgebung anlegen. Schritt für Schritt erläutert er Ihnen dieeinzelnen Funktionen von der Oberflächengestaltung über die Daten-speicherung bis hin zum Einbinden von Bild- und Positionsdaten. Zuletztzeigt er Ihnen, wie Sie die Anwendung testen und hilft Ihnen, den Zertifizie-rungsprozess beim Einstellen in den Marketplace zu bestehen.

� Geld verdienen mit Windows Phone-AppsApps zu programmieren macht Spaß – und es kann sich lohnen! Wenn Siemit selbstentwickelten Apps für Windows Phone 7 Geld verdienen wollen,dann müssen Sie sich bei Microsoft registrieren und brauchen eineUS-amerikanische Steuernummer. Klingt kompliziert, ist es aber nicht.Christian Bleske ist diesen Weg für Sie gegangen und zeigt, wie Sie aufAnhieb alles richtig machen.

Windows Phone 7-Apps entwickelnProgrammierung –Tools – Funktionen

Aus dem Inhalt:• Windows Phone 7 im Detail

• Betriebssystem-Basics

• Das .NET Compact Frameworkund Silverlight

• Das XNA-Framework

• Kurze Einführung in C#

• Die OberflächenbeschreibungsspracheXAML

• Windows Phone Developer Tools

• Projekte anlegen, kompilierenund 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 WindowsMarketplace

Christian BleskeKnow-how

ist blau.

ProgrammierungTools

Funktionen30,– EUR [D]

ISBN 978-3-645-60109-2

Besuchen Sie unsere Website

www.franzis.de

Bles

keW

indo

ws

Phon

e 7-

App

s

Vorwort von Dr. Frank Prengel, Technical Evangelistfür Windows Phone bei Microsoft

Über den Autor:Christian Bleske ist Autor,Trainer und Entwickler.Sein Arbeitsschwerpunktliegt auf Microsoft-Technologien. Seine Fach-aufsätze erscheinen invielen namhaften Entwick-lerzeitschriften. Er lebt inWitten im Ruhrgebiet.

Auf www.buch.cdDer komplette Quellcode der im Buchbeschriebenen Beispiel-Applikation

60109-2 U1+U4 03.05.2011 10:14 Uhr Seite 1

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 Entwicklungs-zyklus 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 Sprach-anpassung (für internationale Märkte) wird sogar die Verwendung von Push Notifica-tions, einem speziellen Konzept unter Windows Phone 7, mittels eines cloud-basierten Dienstes auf Windows Azure diskutiert. Abgerundet wird das Ganze durch eine ausführ-liche 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 ver-meiden.

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 Typumwandlung .............................................................................. 51 3.3 Klassen............................................................................................ 51 3.3.1 Partielle Klassen .............................................................................. 55 3.3.2 Eigenschaften .................................................................................. 55 3.3.3 Methoden ........................................................................................ 58 3.3.4 Ereignisse ........................................................................................ 62 3.3.5 Konstruktoren und Destruktoren ...................................................... 64 3.4 Schnittstellen .................................................................................. 64 3.5 Namespaces .................................................................................... 65 3.6 Klassendesign der Denkmal-App...................................................... 65 3.6.1 Anlage des Projekts ......................................................................... 67 3.6.2 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 11

5.2.12 Effektives Arbeiten mit Expression Blend .......................................110 5.2.13 Action, Bild und Sound ..................................................................112 5.3 Windows Phone Developer Tools ...................................................114 5.3.1 Application Deployment.................................................................114 5.3.2 Der Windows Phone Emulator ........................................................115 5.3.3 Windows Phone Developer Registration .........................................115 5.3.4 Windows Phone Developer Tools – October 2010 Update ..............115 5.3.5 Das January-Update 2011 ..............................................................116

6 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 Anpassungen für die Denkmal-App ................................................252

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 Anpassungen für die Denkmal-App ................................................273 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 15

19.3 Einstellen der App..........................................................................334 19.3.1 Hochladen der App ........................................................................335 19.3.2 Dokumentation bereitstellen..........................................................336 19.3.3 Hochladen des App-Artworks .........................................................337 19.3.4 Festlegen des Preises.....................................................................338 19.3.5 Freigabe zur Zertifizierung..............................................................339 19.4 Checkliste ......................................................................................342 19.5 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 ein-zige 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 ver-missen. 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 Ant-wort lautet: Das geschlossene System. Es gibt keine Möglichkeit, eine Anwendung ein-fach 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 – aller-dings 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 Pro-grammierung mit mindestens einer Sprache wie beispielsweise C, Pascal (Delphi) oder auch Visual Basic verfügen. Sollten Sie mit Begriffen wie Klasse, Objekt, Instanz, Eigen-schaft 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 Pro-grammierung sollten aber noch zusätzliches Material heranziehen, um sich zurecht-zufinden. Außerdem gehe ich davon aus, dass Ihnen Grundbegriffe in Bezug auf grafi-sche 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 Steuer-elemente (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 zusammenbin-det. 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äu-tert, 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 Kapitel 1: Einleitung

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 Giga-hertz Taktfrequenz verfügen. 2 Gigabyte Hauptspeicher sind unter Windows Vista oder Windows 7 zu empfehlen. Gehen Sie davon aus, dass die Installation aller Entwicklungs-werkzeuge 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ätes-tens 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-Varian-ten 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-Vor-gangs 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 Ein-trag 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 Ein-trags 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-4f97-952c-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 Hardware-voraussetzungen 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 GPS-Sensor 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-Web-seite 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 Kapitel 1: Einleitung

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 obligatori-sche 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.

1.4 Was zum Start benötigt wird … 23

Nach einigen Starts von Visual Studio Express 2010 werden Sie aufgefordert, einen Registrierungscode einzugeben. Sie erhalten ihn, wenn die Schaltfläche Obtain a registra-tion 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 Projektvorlagen- Dialog von VS 2010 Professional

24 Kapitel 1: Einleitung

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 Rech-nung 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 Start-Page 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 Projekt-namen. Dort kann auch der Speicherort des Projekts festgelegt werden. Als Projekt-namen 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.

1.4 Was zum Start benötigt wird … 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üg-baren Steuerelementen. Schließen Sie diesen Bereich. Der Bereich für den Phone-Designer 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 Properties-Fenster (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 Kapitel 1: Einleitung

Nach Abschluss der Eingabe mit Enter wird umgehend die Änderung auch im Phone-Designer sichtbar, siehe Bild 1.7. Damit sind bereits alle Arbeiten für das HalloWelt-Beispiel erledigt. Die Anwendung kann jetzt gestartet werden. Mit einem Mausklick auf

oder alternativ mit Betätigung der Taste F5 wird die App kompiliert und auto-matisch 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 Erstel-lung 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 kosten-freie 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 Pro-grammierer, die mit Entwicklungswerkzeugen von Microsoft arbeiten. Natürlich gibt es eine Homepage innerhalb des MSDN, die speziell für das Thema Windows Phone 7

1.4 Was zum Start benötigt wird … 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 Ent-wickler, 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 Pro-gramm 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 Daten-typen Character (char) und String (string). Um ein Zeichen zu speichern, wird der Datentyp char verwendet. Muss eine Zeichenkette, also z. B. ein ganzes Wort, gespei-chert 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 unterschie-den. 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 43

Bezeichnung/Typ Wertebereich

Sbyte -128 bis 127

UInt16 0 bis 65535

UInt32 0 bis 4294967295

UInt64 0 bis 18446744073709551615

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 Kapitel 3: C# im Überblick

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 Ver-gleich 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 Operato-ren 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 Variant-Datentyp. 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 Kapitel 3: C# im Überblick

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 Daten-typ eingesetzt wird. Der Compiler analysiert die entsprechenden Codeabschnitte und wählt anschließend den passenden Datentyp aus. Er ersetzt also quasi das var-Schlüs-selwort durch den passenden Datentyp. Somit wird die Anwendung auch nicht langsa-mer, 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 Inte-ger. 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 Verwen-dung 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 Programmflus-ses in C#.

3.2.1 Fallunterscheidung

Basierend auf einer Boole’schen Auswertung kann auch in C# mit der If-else-Anwei-sung 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 Variable enthält den Wert 5");

break;

case 10:

MessageBoc.Show("Die Variable enthält den Wert 10");

break;

case 20:

MessageBoc.Show("Die Variable enthält den Wert 20");

break;

default:

MessageBoc.Show("Die Variable enthält weder 5, 10 noch 20!");

break;

}

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 kopf- und 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 foreach-Schleife 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 Kapitel 3: C# im Überblick

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 abstei-gend 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 foreach-Schleife 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 (Collec-tions) oder Arrays benutzt.

3.2 Kontrollstrukturen 49

3.2.4 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 Kapitel 3: C# im Überblick

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 51

3.2.6 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() aufge-rufen 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 Um-wandlungsfunktionen (ToByte, ToInt, ToString …) bereitgestellt.

3.3 Klassen

Der folgende Abschnitt gibt eine kurze Einführung in die objektorientierte Programmie-rung 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 beschrei-ben 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 Pro-grammcode 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 Entwi-ckeln 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 Kapitel 7: Entwicklung einer App

7.1.1 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ötig-ten/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 Biblio-theken 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 wer-den 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 verwen-det werden. In der Regel sind dies: Microsoft.Phone, Microsoft.Phone.Interop, mscorelib, system, System.core, System.Net, System.Windows sowie System.xml.

130 Kapitel 7: Entwicklung einer App

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, Back-ground.png, WindowsPhoneApplication.dll, WindowsPhoneApplication.pdb und Windows-PhoneApplication.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 Zusammen-fassung 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 bin-Ordner wird man ggf. zusätzlich benötigte Assemblies (DLLs) wie zum Beispiel Third-Party-Controls finden, die nicht in die fertige Datei kompiliert werden, nicht aber im obj-Ordner.

7.1 Aufbau einer App 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 Kapitel 7: Entwicklung einer App

Betätigung das Live Tile wieder entfernt. Ein kurzes Antippen startet die App. Der soge-nannte 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 Kapi-tel 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

7.1 Aufbau einer App 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 Gegen-satz zum Schließen der App den aktuellen Zustand, damit der Anwender zu ihm zurückkehren kann. Deshalb wird auch nicht das Application_Closing-Ereignis aus-geführt, sondern Application_Deactivated. Sobald also eine App deaktiviert wird, versieht Windows Phone sie mit einem sogenannten Tombstone (zu Deutsch: Grab-stein) und merkt sich den Status der App. Über den Back-Button besteht dann die Mög-lichkeit, 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 ausge-fü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 Kapitel 7: Entwicklung einer App

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 deakti-viert, 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 Anwendungs-status«, 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 referen-ziert und dort als Startseite festgelegt. Was für die Klasse App gilt, gilt auch für die Page-Klasse. 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 Solu-tion-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.

7.1 Aufbau einer App 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-Explo-rer die Page-Ansicht dort erweitert.

136 Kapitel 7: Entwicklung einer App

Bild 7.7: Erweiterte Ansicht im Solution-Explorer

Ein Doppelklick auf das Icon öffnet die Codeansicht der Klasse in Visual Studio.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using 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 einge-bunden wurden, ist natürlich die Page-Klasse selbst Bestandteil der Datei. Eine einzelne Methode (InitializeComponent) wird im Konstruktor der Page vordefiniert aufgeru-fen. 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")));

7.1 Aufbau einer App 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 Page-Instanz 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 ver-wendete 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 Pro-grammfluss 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 Smart-phones 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:

Christian Bleske

> 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

Windows Phone 7-Apps entwickelnProgrammierung – Tools – Funktionen

Microsofts Windows Phone 7 ist neben Apple iOS und Google Android dasdritte große Smartphone-Betriebssystem auf dem Markt – was noch fehlt,sind Apps! Dieses Buch zeigt, wie Sie diese Chance nutzen und Apps fürWindows Phone 7 entwickeln. Anhand einer konkreten Beispielapplikationlernen Sie alle wichtigen Funktionen und das Oberflächendesign kennen undprogrammieren. Zudem zeigt Autor Christian Bleske ausführlich, wie Sie IhreApp fit für den Windows Phone-Marketplace machen.

� Windows Phone 7 macht vieles einfacherMit Windows Phone 7 hat Microsoft viel Ballast abgeworfen. So gibt es dieverschachtelten Menüs früherer Windows-Mobile-Versionen nicht mehr.Auch für Entwickler wurde vieles einfacher: Die Applikationslogik wird nuneinheitlich in .NET-Sprachen wie C# programmiert, die Benutzeroberflächein der XML-basierten Sprache XAML gestaltet. Christian Bleske zeigt, wiedas Zusammenspiel zwischen C# und XAML funktioniert und wie diebeiden Ebenen ineinander greifen. Er führt kurz in die Entwicklungs-werkzeuge Windows Phone Developer Tools ein und zeigt, wie Sie schnellüberzeugende Bedieneroberflächen für Ihre Apps programmieren.

� Von der App-Idee bis zum MarketplaceDieses Buch zeigt, wie Sie eine App für Windows Phone 7 von der ersten Ideebis zum Einstellen in den Marketplace realisieren. Christian Bleske hat dafüreine App entworfen, mit der Sie Daten zu Bauwerken aufnehmen undverwalten können – komplett mit Fotos und Geo-Informationen.Der Autor skizziert, wie Sie die App konzipieren und das Projekt in derEntwicklungsumgebung anlegen. Schritt für Schritt erläutert er Ihnen dieeinzelnen Funktionen von der Oberflächengestaltung über die Daten-speicherung bis hin zum Einbinden von Bild- und Positionsdaten. Zuletztzeigt er Ihnen, wie Sie die Anwendung testen und hilft Ihnen, den Zertifizie-rungsprozess beim Einstellen in den Marketplace zu bestehen.

� Geld verdienen mit Windows Phone-AppsApps zu programmieren macht Spaß – und es kann sich lohnen! Wenn Siemit selbstentwickelten Apps für Windows Phone 7 Geld verdienen wollen,dann müssen Sie sich bei Microsoft registrieren und brauchen eineUS-amerikanische Steuernummer. Klingt kompliziert, ist es aber nicht.Christian Bleske ist diesen Weg für Sie gegangen und zeigt, wie Sie aufAnhieb alles richtig machen.

Windows Phone 7-Apps entwickelnProgrammierung –Tools – Funktionen

Aus dem Inhalt:• Windows Phone 7 im Detail

• Betriebssystem-Basics

• Das .NET Compact Frameworkund Silverlight

• Das XNA-Framework

• Kurze Einführung in C#

• Die OberflächenbeschreibungsspracheXAML

• Windows Phone Developer Tools

• Projekte anlegen, kompilierenund 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 WindowsMarketplace

Christian BleskeKnow-how

ist blau.

ProgrammierungTools

Funktionen30,– EUR [D]

ISBN 978-3-645-60109-2

Besuchen Sie unsere Website

www.franzis.de

Bles

keW

indo

ws

Phon

e 7-

App

s

Vorwort von Dr. Frank Prengel, Technical Evangelistfür Windows Phone bei Microsoft

Über den Autor:Christian Bleske ist Autor,Trainer und Entwickler.Sein Arbeitsschwerpunktliegt auf Microsoft-Technologien. Seine Fach-aufsätze erscheinen invielen namhaften Entwick-lerzeitschriften. Er lebt inWitten im Ruhrgebiet.

Auf www.buch.cdDer komplette Quellcode der im Buchbeschriebenen Beispiel-Applikation

60109-2 U1+U4 03.05.2011 10:14 Uhr Seite 1