Mobile Anwendungen

Erste Schritte mit Windows Phone-Entwicklungstools

Joshua Partlow

Beispielcode herunterladen.

Wie so viele von Ihnen, werde auch ich seit mehr als einem Jahr von einer Masse an postapokalyptischen Anzeigen überschwemmt, die an Terminator erinnern und mich darauf aufmerksam machen, was Droid alles kann. Auch ich kann die Werbespots von T-Mobile My Touch mitsummen. Und natürlich ist auch an mir nicht vorübergegangen, wie viele Apps Apple für das iPhone verkauft hat.

Allerdings habe ich, im Gegensatz zu Ihnen, im letzten Jahr immer wieder Freunden und Verwandten erklärt, dass ich zwar tatsächlich auch an einem mobilen Telefon arbeite, mit den genannten jedoch nichts zu tun habe.

Ich kann daher gut zugeben, dass ich ziemlich aufgeregt war, als Steve Ballmer und Joe Belfiore anlässlich des Mobile World Congress (MWC) in Barcelona das Windows Phone 7 angekündigt haben. Es war 6 Uhr morgens, Redmond-Zeit, am 15. Februar 2010, und ich saß mit einigen Hundert Kollegen in einem Besprechungsraum bei Microsoft, einige noch im Schlafanzug, und alle warteten gespannt darauf, per Live-Feed zu sehen, wie Belfiore unsere neue Vision für das Phone vorführt. Ich werde sicherlich noch viele Produkteinführungen erleben, aber diese wird für immer ein Highlight bleiben. Das war der aufregendste Moment, den ich in meiner Zeit bei Microsoft bis dahin erlebt hatte.

In diesem Artikel werde ich Ihnen die Windows Phone 7-Anwendungsplattform präsentieren und versuchen, Sie genauso für das Potenzial der Windows Mobile-Anwendungsentwicklung zu begeistern. Insbesondere werde ich auf die grundlegenden Komponenten der Anwendungsplattform eingehen, Ihnen anschließend eine Übersicht über die Windows Phone-Entwicklertools verschaffen und dann schrittweise die Erstellung einer Windows Phone-Anwendung zum Zugreifen auf einen Webdienst erläutern.

Der Bruch mit der Vergangenheit

Windows Phone 7 ist das Zugeständnis von Microsoft an die Veränderung auf dem Markt mobiler Anwendungen. Mittlerweile wird von einem Smartphone mehr erwartet, als nur das Lesen von E-Mails und Dokumenten zu ermöglichen: es soll ein Teil des alltäglichen Lebens sein. Benutzer möchten es auch verwenden, um beispielsweise Musik zu hören, Fotos und Videos auszutauschen und in Kontakt mit Freunden zu bleiben. Es hat sich gezeigt, dass auch geschäftliche Anwender Facebook nutzen und Jugendliche sich wie selbstverständlich im Web bewegen. Das ist jetzt keine wahnsinnig neue Erkenntnis, aber dieser Wandel stellt einen deutlichen Einschnitt in Bezug auf die Rolle von Smartphones in unserem Leben dar.

Als potenzielle Kunden haben Sie hoffentlich das Demo von Belfiore gesehen und sind gleich danach losgezogen, um ein Phone zu kaufen. Und, was mir noch wichtiger ist, als Entwickler sind Sie hoffentlich neugierig auf die Geschichte der Anwendung geworden. Die Entwicklung eines neuen Betriebssystems gehört letztendlich zum Wettbewerb auf dem hart umkämpften mobilen Markt dazu. Wenn es uns darum geht, Benutzern ein Phone anzubieten, mit dem sie Arbeit und Privatleben auf eine ganz neue Weise verbinden können, dann müssen wir das Betriebssystem mit einem Ökosystem beeindruckender Anwendungen kombinieren.

Ich möchte hier nicht das Phone in allen Einzelheiten beschreiben, das finden Sie sicher in geeigneten Blogs, sondern auf zwei größere Fragen eingehen, die sich Ihnen als Entwickler stellen: Auf welcher Anwendungsplattform von Microsoft basiert Windows Phone 7, und wie steige ich in die Entwicklung von Anwendungen ein?

Eine neue Welt für Entwickler

Wenn wir davon ausgehen, dass der MWC Windows Phone 7 bekannt gemacht hat, dann waren die Game Developers Conference (GDC) und MIX10 die glückliche Fortsetzung. Im Rahmen der GDC und MIX hat Microsoft angekündigt, dass die Windows Phone 7-Anwendungsplattform auf Silverlight und XNA Framework basiert. Falls Sie auch in der Vergangenheit schon für Windows Mobile entwickelt haben, wissen Sie, dass dies einen grundlegenden Unterschied zu früheren Versionen des Betriebssystems bedeutet.

Was war der Grund dafür, alles auf den Kopf zu stellen? Meiner Meinung nach liegt die Stärke von Microsoft darin, dass eine so große Bandbreite von Produkten angeboten wird, und der Erfolg ist dann am größten, wenn diese kombiniert werden. Vor Windows Phone 7 wurden bei der Entwicklung von mobilen Anwendungen zwar auch schon einige Ressourcen von Microsoft genutzt, aber nicht in dem Maße wie heute.

Das XNA Framework wurde konzipiert, um komplexe und leistungsfähige 2D- und 3D-Spiele für Desktops, Konsolen und mobile Anwendungen zu entwickeln. Es umfasst eine breite Hardwarepalette, von den Grafikfunktionen der Xbox-Konsole bis hin zu den Sensor- und Touchfunktionen des Zune HD. Außerdem hatte man bei seiner Entwicklung schon die Vernetzung von Spielen im Hinterkopf.

Silverlight ist die Microsoft-Desktopplattform für webbasierte Medien- und Produktivitätsanwendungen. Wird diese mit Expression Blend kombiniert, ermöglicht sie die Erstellung beeindruckender Benutzeroberflächen, die sowohl eigenständig funktionieren als auch in Webdienste eingebunden werden können.

Sowohl das XNA Framework als auch Silverlight sind für sich genommen schon leistungsfähige Plattformen. Mit ihrer Kombination auf dem Phone wird allerdings eine ganz neue Ebene erreicht: es können Anwendungen mit wunderbaren Benutzeroberflächen und toller Grafik entwickelt werden, die ganz einfach die Funktionen eines mobilen Geräts nutzen können.

Da ich schon in einem frühen Entwicklungsstadium von Windows Phone 7 mit Silverlight und XNA-Anwendungen experimentiert hatte, war ich schnell überzeugt, auf einem guten Weg zu sein. Ich hatte mit beiden Plattformen und mit verwaltetem Code bis dahin noch keine Erfahrungen und war erstaunt, wie schnell ich in der Lage war, visuell beeindruckende Anwendungen zu entwickeln.

Ein weiteres bemerkenswertes Feature der neuen Anwendungsplattform ist die Standardisierung von Hardware und der programmatische Zugriff darauf. Außerdem wurde auf der MIX angekündigt, dass Windows Phone einen Satz von Hardwarekomponenten unterstützen würde, auf die Entwickler einen konsistenten und zuverlässigen Zugriff haben würden. Warum ist das wichtig? In der Vergangenheit war es schwierig, Anwendungen für verschiedene Phones zu entwickeln, da letztendlich immer gerätespezifische Versionen erstellt werden mussten. Auf einigen Phones konnte eine Anwendung entweder nur nach gründlicher Überarbeitung oder überhaupt nicht ausgeführt werden, da nicht alle erforderlichen Features unterstützt wurden.

Mit Windows Phone 7 ist es keine Frage mehr, ob das Phone, auf dem Ihre Anwendung ausgeführt wird, Standortdienste unterstützt, denn alle tun das. Sie müssen sich keine Gedanken mehr machen, ob Sie auf einen Beschleunigungsmesser zugreifen können, denn das ermöglichen dann alle Phones, und zwar konsistent. Und Sie müssen sich nicht den Kopf zerbrechen, ob Ihr Phone touchfähig ist, denn auch das ist durchgängig gewährleistet. Die Liste könnte ich noch fortführen, aber ich denke, es ist klar geworden, worum es mir geht.

Die Windows Phone 7-Anwendungsplattform ermöglicht Ihnen die Entwicklung einer einzelnen Anwendung mit der Gewissheit, dass die Tests auf einem Phone auf alle anderen übertragbar sind. Windows Phones werden zwar auch in Zukunft noch unterschiedliche Hardware haben, aber es wird einen Kern als zuverlässige Basis geben.

Weitere Informationen zur Windows Phone-Hardware und der Architektur der Anwendungsplattform bieten die entsprechenden Übersichten auf MSDN unter msdn.microsoft.com/library/ff402531(v=VS.92) und msdn.microsoft.com/library/ff637514(v=VS.92).

Erste Schritte

Nachdem wir nun kurz auf die Anwendungsplattform eingegangen sind, sprechen wir darüber, wie dort die Entwicklung funktioniert. Die Windows Phone-Entwicklertools, die sich zurzeit noch in der Betaphase befinden, können im Windows Phone-Entwicklerportal (developer.windowsphone.com) heruntergeladen werden. Falls Sie nicht über Visual Studio verfügen: die Entwicklertools werden mit Visual Studio 2010 Express für Windows Phone installiert. Wenn Sie Visual Studio 2010 installiert haben, werden die Tools direkt integriert. In beiden Fällen haben Sie alles, was Sie für die Entwicklung für Windows Phone 7 benötigen.

Die Entwicklertools umfassen einen Windows Phone-Emulator und Microsoft Expression Blend für Windows Phone. Zwar ist die Version noch nicht final, aber die Betaversion gibt schon einen guten Einblick. Möglicherweise müssen für die endgültige Version der Tools Änderungen am Code vorgenommen werden, aber diese sind entweder geringfügiger Art oder zumindest gut dokumentiert.

Ich habe die Betaversion der Tools installiert und Visual Studio 2010 Express für Windows Phone verwendet, und darauf basiert mein Beispielprojekt. Wenn Sie sich für den Anfang ein etwas einfacheres Lernprogramm ansehen möchten, bietet sich die schrittweise Anleitung für Windows Phone auf MSDN an, die Sie hier finden: msdn.microsoft.com/library/ff402529(v=VS.92).

Was wollen wir nun erstellen? Anstelle der üblichen „Hallo Welt“- oder „Flashlight“-Anwendung möchte ich Ihnen ein lustiges kleines Projekt zeigen, an dem ich gearbeitet habe.

Auf der MIX I habe ich eine Session zu einem Windows Azure-Projekt besucht: der Microsoft-Codename lautet „Dallas“ (microsoft.com/windowsazure/dallas). Dabei handelt es sich um einen Marktplatz für Entwickler, die von Webdiensten Daten für ihre Anwendungen kaufen möchten. In der zweiten CTP-Version (Community Technology Preview) können Sie das Onlineportal und einige kostenlose, zu Testzwecken bereitgestellte Datenquellen verwenden, um den Dienst auszuprobieren. Zwar ist die aktuelle Liste der Anbieter überschaubar, aber es gibt genug zu spielen. Ich persönlich fand die Bilddaten der NASA zu den Mars-Missionen ganz interessant und entschied, damit eine Windows Phone-Anwendung zu erstellen, mit der Benutzer durch die Bilder des Marsrovers blättern können.

Der hier enthaltene Code, der auch heruntergeladen werden kann, ist ein Beispiel, aber wenn Sie ihn ausführen möchten, müssen Sie sich für die Dallas-CTP registrieren, um ein Konto und eine Benutzer-ID zu erhalten, was ich in meinem Code leer gelassen habe (microsoft.com/windowsazure/developers/dallas).

Erstellen des Projekts

Der erste Schritt beim Erstellen des Image Viewers für die Bilder des Marsrovers ist das Windows Phone-Anwendungsprojekt. Wenn Sie die Express-Version von Visual Studio 2010 für Windows Phone starten, wird eine standardmäßige Startseite von Visual Studio geöffnet. Dort können Sie das nächste Projekt auswählen und sich für eine von zahlreichen Projektvorlagen entscheiden. Falls Sie nur die Windows Phone-Entwicklertools installiert haben, werden in der Liste lediglich Silverlight für Windows Phone und XNA Game Studio 4.0 angezeigt.

Ich habe eine Windows Phone-Anwendung aus den Silverlight-Vorlagen ausgewählt und mein Projekt „MarsImageViewer“ genannt. Nun erledigt Visual Studio seine Zauberei und erstellt ein Projekt für Sie.

Wenn Sie schon mit Windows Presentation Foundation (WPF) oder Silverlight gearbeitet haben, sollten Sie von dem Ergebnis nicht mehr überrascht sein. Sie erhalten eine Entwurfsoberfläche mit einem coolen Phone-Gehäuse, eine Toolbox mit einigen grundlegenden Steuerelementen und eine Reihe von XAML-Dateien mit den zugehörigen C#-CodeBehind-Dateien (siehe Abbildung 1). Falls Sie mehr über die genauen Unterschiede zwischen Silverlight und XNA auf Windows sowie Silverlight und XNA auf Windows Phone erfahren möchten, sehen Sie sich die Übersicht über das Windows Phone-Framework auf MSDN an: msdn.microsoft.com/library/ff402528(v=VS.92).

Abbildung 1 Ihr erstes Windows Phone-Projekt in Visual Studio

Erläuterungen zu XAML

Wie bei Silverlight bietet die Vorlage der Windows Phone-Anwendung eine „App.xaml“- und eine „MainPage.xaml“-Datei, die den Kern Ihrer Anwendung bilden. Da die fast genauso funktionieren wie ihre Entsprechungen in Silverlight, werde ich darauf nicht näher eingehen, aber zwei wichtige Unterschiede möchte ich doch erwähnen, bevor wir die Anwendung erstellen.

Betrachten wir zunächst die Standarddatei „App.xaml“. Der Großteil des automatisch erstellten Codes entspricht dem, der in einem Silverlight-Projekt angezeigt würde, aber es gibt einen zusätzlichen Abschnitt mit einem PhoneApplicationService-Objekt:

<shell:PhoneApplicationService 
  Launching="Application_Launching" Closing="Application_Closing" 
  Activated="Application_Activated" Deactivated="Application_Deactivated"/>

Die Betaversion der Windows Phone-Entwicklertools bietet ein neues Ausführungsmodell, mit dem das Verhalten von Anwendungen vorgeschrieben wird. Dieses Modell tritt in diesem Markupabschnitt und im CodeBehind von „App.xaml.cs“ in Erscheinung. Wenn Sie das Verhalten von Windows Phone-Anwendungen und diesem Objekt besser verstehen möchten, können Sie sich über das Ausführungsmodell für Windows Phone auf MSDN genauer informieren unter msdn.microsoft.com/library/ff769557(VS.92).

Der zweite Unterschied betrifft die Datei „MainPage.xaml“, wo ich mit dem Erstellen der Anwendung beginne. Bei genauer Betrachtung ähnelt diese Datei Silverlight, aber es gibt einen auskommentierten XAML-Abschnitt für eine Anwendungsleiste. Die Anwendungsleiste ist eine Systemsteuerung, mit der Sie Schaltflächen und Menüelemente verfügbar machen können. Das erspart Ihnen nicht nur den Aufwand, diese selbst zu erstellen, sondern verleiht dem Phone Konsistenz, da es in Aussehen und Verhalten dem der Kernanwendungen entspricht. Ich ändere dieses Vorlagenmarkup, um meine Anwendungsleiste zu erstellen. Sie können zum Erstellen von Anwendungsleisten aber auch C# verwenden (siehe dazu auch msdn.microsoft.com/library/ff431786(VS.92)).

Stehlen der Anwendungsleiste

Der erste Schritt beim Erstellen der Anwendungsleiste besteht darin, die gewünschten Symbole zu finden. Sie können eigene erstellen oder die in den Entwicklertools enthaltenen Symbole verwenden. Standardmäßig sind die Symbole unter folgendem Pfad gespeichert: „C:\Programme (x86)\Microsoft SDKs\Windows Phone\v7.0\Icons\“ (64-Bit Windows) und „C:\Programme\Microsoft SDKs\Windows Phone\v7.0\Icons\“ (32-Bit Windows). Es lohnt sich, diese anzusehen, da sie zum Phone passen.

Nachdem Sie die gewünschten Bilder ausgewählt haben, erstellen Sie in Ihrem Projekt einen Bildordner für die Symbole. Dann legen Sie die Eigenschaften für die einzelnen Symbole fest: Der Buildvorgang sollte „Inhalt“ sein, und für „In Ausgabeverzeichnis kopieren“ sollte die Option „Immer kopieren“ ausgewählt sein, wie in Abbildung 2 gezeigt.

Abbildung 2 Hinzufügen von Bildressourcen zum Projekt

Im nächsten Schritt geht es darum, die Kommentare des Anwendungsleistenmarkups zu entfernen und für die Anwendung zu ändern. In diesem Fall müssen zwei Schaltflächen und die zugehörigen Ereignishandler erstellt werden. Ich habe eine Schaltfläche zum Abrufen des nächsten Fotos und eine zum Abrufen des vorherigen Fotos erstellt. Außerdem habe ich Klickergebnisse zum XAML-Code hinzugefügt und das Erstellen von Ereignishandlern in Visual Studio eingerichtet. Der XAML-Code der Anwendung sollte nun wie der Code in Abbildung 3 aussehen.

Abbildung 3: Konfigurieren der Anwendungsleiste

<phone:PhoneApplicationPage.ApplicationBar>
  <shell:ApplicationBar 
    IsVisible="True" IsMenuEnabled="False">
    <shell:ApplicationBarIconButton 
      x:Name="appbar_BackButton" 
      IconUri="/Images/appbar.back.rest.png" 
      Text="Back" 
      Click="appbar_BackButton_Click">
    </shell:ApplicationBarIconButton>
    <shell:ApplicationBarIconButton 
      x:Name="appbar_ForwardButton" 
      IconUri="/Images/appbar.next.rest.png" 
      Text="Next" 
      Click="appbar_ForwardButton_Click">
    </shell:ApplicationBarIconButton>
  </shell:ApplicationBar>
</phone:PhoneApplicationPage.ApplicationBar>

Bevor ich mich an den CodeBehind mache, habe ich mir außerdem die Zeit genommen, einen Anwendungstitel und einen Seitennamen anzugeben und dem Stammraster von „MainPage.xaml“ ein Bildsteuerelement hinzuzufügen, wie in Abbildung 4 gezeigt. Daraufhin sollte die Entwurfsoberfläche aussehen wie in Abbildung 5, wo Sie eine leere Anwendungsleiste mit vier Kreisen sehen.

Abbildung 4 MainPage.xaml

<!--TitlePanel contains the name of the application and page title-->
<StackPanel x:Name="TitlePanel" Grid.Row="0" Margin="24,24,0,12">
  <TextBlock x:Name="ApplicationTitle" 
    Text="MarsImageViewer" 
    Style="{StaticResource PhoneTextNormalStyle}"/>
  <TextBlock x:Name="PageTitle" 
    Text="Images" 
    Margin="-3,-8,0,0" 
    Style="{StaticResource PhoneTextTitle1Style}"/>
</StackPanel>

<!--ContentPanel - place additional content here-->
<Grid x:Name="ContentGrid" Grid.Row="1">
  <Image Height="300" 
    HorizontalAlignment="Left" 
    Margin="36,104,0,0" 
    Name="MarsImage" 
    Stretch="Fill" 
    VerticalAlignment="Top" 
    Width="400" />
</Grid>

Abbildung 5 Konfigurierte Entwurfsoberfläche

Nachdem wir die Anwendungsoberfläche definiert haben, wird es Zeit, einige Marsrover-Bilder abzurufen. Das Dallas-Portal ist benutzerfreundlich und ermöglicht es Ihnen, mit Abfragen zu experimentieren. Außerdem erhalten Sie dort die entsprechende Webdienst-URL, sehen, wie Parameter hinzugefügt werden und können die Headerinformationen für Ihre Abfragen abrufen.

Über das Portal habe ich herausgefunden, dass der Webdienst der NASA parameterbasierte Abfragen nach Bilddaten bzw. das Abrufen bestimmter JPEG-Bilder über eine Bild-ID ermöglicht. Für dieses Programm hat das zur Folge, dass zwei Operationen erforderlich sind. Die erste ist das Abfragen von Bilddaten einschließlich der Bild-ID. Die zweite Operation besteht darin, den zurückgegebenen XML-Code für die Bild-IDs zu analysieren, um damit ein bestimmtes Bild abzurufen.

Ich rufe Houston ... Dallas, meine ich natürlich

Fangen wir also an. In der Standarddatei „MainPage.xaml.cs“ habe ich using-Anweisungen für drei Namespaces hinzugefügt:

using System.Xml.Linq;
using System.IO;
using System.Windows.Media.Imaging;

Dann habe ich einen Verweis zu „System.Xml.Linq DLL“ hinzugefügt, indem ich im Projektmappen-Explorer auf „Verweise“ geklickt, im Dialogfeld „Verweis hinzufügen“ die Datei „System.Xml.Linq“ ausgewählt und anschließend auf „OK“ geklickt habe. „System.Xml.Linq“ bietet den Zugriff auf Klassen, die das Laden des XML-Codes aus Datenströmen und die anschließende Abfrage dieses XML-Codes über LINQ ermöglichen. Es ist kein Problem, wenn Sie sich nicht mit LINQ auskennen. In diesem Beispiel wird nur sehr wenig LINQ to XML verwendet, und Sie können sich jederzeit auf MSDN ausführlicher informieren.

Außerdem habe ich zwei private Variablen für die Seite erstellt. Ein IEnumerable(Of XElement)-Objekt namens „entries“, um die Ergebnisse einer LINQ to XML-Abfrage zu speichern, und einen Ganzzahlindex, um zu verfolgen, welches Bild angezeigt wird. Dann habe ich den MainPage-Konstruktur geändert, um den Index auf 0 zu initialisieren und eine getImageIDs-Funktion aufzurufen:

private IEnumerable<XElement> entries;
  private int index;

  // Constructor
  public MainPage() {
    InitializeComponent();

    index = 0;
    getImageIDs();
  }

Mit der getImageIDs-Funktion wird das Abrufen von Bilddaten über den Webdienst gestartet. Die Funktion nutzt die Webdienst-URL und einen Webclient, um eine asynchrone Anfrage nach den Bilddaten zu starten.

private void getImageIDs() {
  Uri serviceUri = new Uri("https://api.sqlazureservices.com/NasaService.svc/MER/Images?missionId=1&$format=raw");
  WebClient recDownloader = new WebClient();
  recDownloader.Headers["$accountKey"] = "<Your account key>";
  recDownloader.Headers["$uniqueUserID"] = "<Your user ID>";
  recDownloader.OpenReadCompleted += 
    new OpenReadCompletedEventHandler(recDownloader_OpenReadCompleted);
  recDownloader.OpenReadAsync(serviceUri);
}

Wie Sie sehen, habe ich aus Gründen der Einfachheit den missionId-Parameter auf „1“ hartcodiert, was in unserem Beispiel die Mission des Opportunity-Rovers darstellt. Im Idealfall werden dieser und andere Parameter dynamisch vom Benutzer definiert.

Bei allen asynchronen Anforderungen ist ein Handler erforderlich. Dieser wird aufgerufen, wenn die Datenanforderung abgeschlossen ist. Der Handler verwendet dann den zurückgegebenen Datenstrom sowie grundlegendes LINQ to XML, um auf alle „entry“-Tags im zurückgegebenen XML zuzugreifen. „entry“ bezeichnet dabei das Anfangstag für die einzelnen Bilddatensätze.

private void recDownloader_OpenReadCompleted(
  object sender, OpenReadCompletedEventArgs e) {
  if (e.Error == null) {
    Stream responseStream = e.Result;
    XNamespace ns = "http://www.w3.org/2005/Atom";
    XElement marsStuff = XElement.Load(responseStream);
    entries = marsStuff.Elements(ns + "entry");
    string imageID = 
      (string)entries.ElementAt<XElement>(index).Element(
      ns + "title").Value;
    getImage(imageID);
  }
}

Die zurückgegebene Auflistung wird in den zuvor deklarierten IEnumerable(Of XElement)-Objekten („entries“) gespeichert. Nun noch ein wenig LINQ to XML, und der Handler ruft den Wert des Titeltags für das erste XElement in „entries“ ab. Der Wert des Titeltags in diesem XML-Schema entspricht zufällig der Bild-ID, die dann an eine getImage-Funktion übergeben wird.

Die getImage-Funktion entspricht weitgehend der getImageIDs-Funktion. Der einzige Unterschied liegt in der verwendeten Webdienst-URL. Mit dieser Funktion wird asynchron ein Datenstrom zum Bild abgerufen, das durch den ID-Parameter identifiziert wird. Dessen Handler verwendet diesen Datenstrom, um die Quelle des Bildsteuerelements festzulegen, das ich in der Datei „MainPage.xaml“ definiert habe (siehe Abbildung 6).

Abbildung 6 Abrufen des Bilds

private void getImage(string ID) {
  Uri serviceUri = new Uri(
    "https://api.sqlazureservices.com/NasaService.svc/MER/Images/" + 
    ID + "?$format=raw");
  WebClient imgDownloader = new WebClient();
  imgDownloader.Headers["$accountKey"] = "<Your account key>";
  imgDownloader.Headers["$uniqueUserID"] = "<Your user ID>";
  imgDownloader.OpenReadCompleted += 
    new OpenReadCompletedEventHandler(imgDownloader_OpenReadCompleted);
  imgDownloader.OpenReadAsync(serviceUri);
}

private void imgDownloader_OpenReadCompleted(
  object sender, OpenReadCompletedEventArgs e) {
  if (e.Error == null) {
    Stream imageStream = e.Result;
    BitmapImage imgsrc = new BitmapImage();
    imgsrc.SetSource(imageStream);
    MarsImage.Source = imgsrc;
  }
}

Gestalten der Schaltflächen

Der Rest der Anwendung ist ziemlich einfach; es müssen nur noch die automatisch erstellten Ereignishandler für die Schaltflächen der Anwendungsleiste implementiert werden. Das sind die Schaltflächen, mit denen wir durch die Bilder des Marsrovers blättern werden. Wie Sie sehen, habe ich im Grunde nur die getImage-Funktion wiederverwendet und entsprechende Logik zum Ändern des Index für den aktuellen Datensatz in der „entries“-Auflistung hinzugefügt. Hier der Handler für die Zurück-Schaltfläche:

private void appbar_BackButton_Click(
  object sender, EventArgs e) {
  if (index > 0) {
    index--;
    XNamespace ns = "http://www.w3.org/2005/Atom";
    string imageID = (string)entries.ElementAt<
      XElement>(index).Element(ns + "title").Value;
    getImage(imageID);
  }
}

Der Handler für die Vorwärts-Schaltfläche ist im Wesentlichen identisch, mit Ausnahme der Indizierung:

The forward button handler is pretty much the same, except for its indexing:
if ((index + 1) < entries.Count<XElement>()) {
  index++;
  ...

Jetzt können Sie das Programm mit dem Windows-Emulator ausführen, der enthalten ist. Wählen Sie auf der Standardsymbolleiste im Menü mit den Zielgeräten den Windows Phone 7-Emulator aus. Drücken Sie F5, und das Programm wird erstellt und für den Emulator bereitgestellt (siehe Abbildung 7).

Abbildung 7 Ausführen der Anwendung im Emulator

Bereit für den Start

Dieses Beispiel war relativ einfach, aber ich hoffe, Sie haben eine grobe Vorstellung von den Entwicklertools bekommen und gesehen, wie einfach Anwendungen für Windows Phone entwickelt werden können. Windows Phone 7 bietet zahlreiche Möglichkeiten, die Sie sich noch genauer ansehen sollten.

Sie haben hier nur einen ersten Eindruck davon bekommen, was die Anwendungsplattform zu bieten hat. Die von mir konzipierte Anwendung ist ein Beispiel dafür. Mit einer weiteren Schaltfläche und ungefähr 12 Codezeilen könnten Sie die MediaLibrary-Klasse im Microsoft.Xna.Framework.Media-Namespace verwenden, um ein Foto in der Medienbibliothek zu speichern (siehe msdn.microsoft.com/library/ff769549(v=VS.92)).

Das ist richtig – Sie können XNA-APIs aus Ihren Silverlight-basierten Windows Phone-Anwendungen verwenden. Diskussionen über die Verflechtung von Silverlight und XNA-APIs in Anwendungen und viele weitere Themen müssen wir leider auf ein anderes Mal verschieben. Achten Sie also auf umfassendere und zielgerichtetere Artikel, und sehen Sie sich die Dokumentation und Beispiele auf MSDN an: msdn.microsoft.com/library/ff402535(v=VS.92).

Joshua Partlow arbeitet als Redakteur im Bereich Programmierung im Windows Phone 7-Team. Zu seinen Aufgaben gehört das Dokumentieren der Entwicklung von Phones, Gerätetreibern und Anwendungen für OEMs, die Windows Phones erstellen.

Unser Dank gilt dem folgenden technischen Experten für die Durchsicht dieses Artikels: Windows Phone 7-Team