Verwenden von Silverlight zum Erstellen eines Digg-Clients für Windows Phone 7

Silverlight ist die Hauptplattform für die Anwendungsentwicklung für Windows Phone 7. In einem vorherigen Lernprogramm haben wir beschrieben, wie Sie Ihr System für die Entwicklung von Windows Phone 7 einrichten. Anschließend haben wir eine entwickelt sehr einfache Silverlight-Anwendung, die eine Schaltfläche um ein Raster drehte. Dieser Artikel führt Sie in die erweiterten Silverlight-Funktionen ein und ermöglicht Ihnen die Entwicklung aussagekräftiger Anwendungen, die Daten auf interessante und einzigartige Weise anzeigen.

In diesem Artikel werden einige Windows Phone 7- und Silverlight-Funktionen auf mittlerer Ebene vorgestellt, darunter Anwendungsressourcen, Stile, Datenvorlagen und Ansichtsnavigation. Sie nutzen die Datenbindung und WP7 Dienste, mit denen Sie schnell und einfach zwischen den Seiten navigieren können. Sie sollten mit XAML und C # vertraut sein, bevor Sie mit diesem Lernprogramm beginnen.

Projekt erstellen

In diesem Lernprogramm erstellen Sie einen einfachen Digg-Client, mit dem ein Benutzer Storys nach Thema durchsuchen kann. Sie profitieren von den Funktionen von Silverlight und Windows Phone 7 auf mittlerer Ebene, einschließlich Anwendungsressourcen, Formatvorlagen, Datenvorlagen und Navigationsdiensten. Sie verwenden die Datenbindung, um Informationen von Digg und verschiedenen Informationen anzuzeigen WP7 Dienste, damit Benutzer mit Ihrer Anwendung umgehen können.

Stellen Sie zunächst sicher, dass auf Ihrem Computer die neuesten Windows Phone 7-Entwicklungstools installiert sind. Die Tools wurden am 12. Juli 2010 aktualisiert. Sie müssen möglicherweise ein früheres CTP deinstallieren und die Tools Beta installieren.

Öffnen Sie Visual Studio 2010 und klicken Sie in der linken Seitenleiste auf Neues Projekt. Wählen Sie in dem daraufhin angezeigten Dialogfeld "Windows Phone-Anwendung" aus den verfügbaren Vorlagen aus und geben Sie Ihrem Projekt einen Namen wie "SimpleDigg". Stellen Sie sicher, dass die Option "Verzeichnis für Lösung erstellen" aktiviert ist, und klicken Sie auf "OK". Ihre Einstellung sollte wie folgt aussehen:

Nachdem Ihr Projekt erstellt wurde, öffnet Visual Studio MainPage.xaml zur Bearbeitung. Schließen Sie diese Datei vorerst.

Erstellen von Digg-Datenklassen

Um auf die Daten von Digg zuzugreifen, verwenden wir deren offizielle API. Insbesondere verwenden wir die Methoden story.getAll und topic.getAll. Beispielantworten für jeden Anruf finden Sie unter den folgenden URLs:

  • story.getAll
  • topic.getAll

Wie du siehst, story.getAll gibt Artikel zurück. Geschichten haben viele Daten mit sich, aber wir werden uns auf 4 Informationen konzentrieren:

  • Titel
  • Beschreibung
  • Diggs
  • Verknüpfung

Erstellen wir die Klasse, die diese Daten enthalten soll. Klicken Sie im Projektmappen-Explorer von Visual Studio (der standardmäßig in der rechten Seitenleiste geöffnet ist) mit der rechten Maustaste auf Ihr Projekt und wählen Sie "Hinzufügen> Neuer Ordner". Benennen Sie diesen neuen Ordner Digg. Klicken Sie mit der rechten Maustaste auf den neu erstellten Ordner und wählen Sie "Hinzufügen> Klasse ...". Benennen Sie Ihre Klasse Geschichte und klicken Sie auf die Schaltfläche Hinzufügen.

Visual Studio öffnet Ihre neue Klasse zum Bearbeiten. Fügen Sie innerhalb der Klassendefinition vier öffentliche Eigenschaften wie die folgenden hinzu:

 öffentliche Zeichenfolge Title get; einstellen;  public string Beschreibung get; einstellen;  public string Link get; einstellen;  public int Diggs get; einstellen;  

Fügen Sie nun die Klasse hinzu, die Themendaten enthalten soll. Klicken Sie mit der rechten Maustaste auf Ihre Digg Ordner erneut und wählen Sie "Hinzufügen> Klasse ...". Benennen Sie Ihre Klasse Thema und fügen Sie die folgenden Eigenschaften hinzu, wenn die Datei geöffnet wird:

 öffentlicher String Name get; einstellen;  public string ShortName get; einstellen;  

An diesem Punkt haben Sie alle Datenklassen erstellt, die Sie für dieses Lernprogramm benötigen, und können die für die übrige Anwendung erforderlichen Ansichten kennzeichnen.

Ansichten erstellen

Der SimpleDigg-Client hat drei verschiedene Ansichten, die erstellt werden müssen. Sie sind:

  • Themenliste - Listet alle Themen auf Digg auf
  • Story List (Story-Liste) - Listet aus Digg abgerufene Storys zu einem bestimmten Thema auf
  • Story-Detail - Zeigt Details zu einer ausgewählten Story an

Themenliste

Die Themenliste ist der erste Bildschirm, den Benutzer sehen, wenn sie Ihre Anwendung starten. Es enthält eine Liste von Themennamen, die beim Klicken auf eines der Themen zu einer Liste von Storys in diesem Thema führt. Da dies der erste Bildschirm ist, den Benutzer sehen, verwenden wir die zuvor erstellte MainPage.xaml-Datei, die bereits im Projekt vorhanden ist. Öffnen Sie MainPage.xaml und Sie sollten links eine visuelle Darstellung und rechts die Markierung für die Ansicht sehen.

Klicken Sie in der visuellen Darstellung auf den Text „Meine Anwendung“ und beachten Sie, dass a Textblock Element in der XAML-Darstellung wird hervorgehoben. Das Textblock hat ein Text Attribut, das derzeit mit dem Wert "MY APPLICATION" belegt ist. Ändern Sie diesen Wert in Ihren gewünschten Wert. Ich empfehle „Simple Digg“. Sie werden sehen, dass der visuelle Designer entsprechend Ihren Änderungen aktualisiert wird.

Wiederholen Sie nun den Vorgang mit der Zeichenfolge "Seitenname". Klicken Sie auf den Text und suchen Sie den entsprechenden Textblock und ändern Sie die Text Attribut. Diesmal empfehle ich, es in "Themen" zu ändern. Wenn Sie bis jetzt alles richtig gemacht haben, sollten Sie eine StackPanel Element, das zwei @ TextBlock @ s mit jeweils einem entsprechenden Wert enthält. Die XAML sieht folgendermaßen aus:

    

Jetzt müssen Sie den Listencontainer zu Ihrer Seite hinzufügen. Öffnen Sie die Steuerelement-Toolbox (auf der linken Seite von Visual Studio) und ziehen Sie ein ListBox-Element in den großen leeren Bereich Ihrer Seite. Sie müssen den Wert ändern, um die Breite und Höhe des Containers zu vergrößern. Setzen Sie den Cursor in den XAML-Editor und ändern Sie das ListBox-Element wie folgt:

 

Mit dieser Markierung werden alle vom visuellen Designer eingeführten Stile entfernt und das Element umbenannt, sodass Sie auf die darin enthaltenen Elemente zugreifen können. An diesem Punkt haben Sie das Markup für die Ansicht "Themenliste" abgeschlossen und können nun zu den anderen Teilen der Anwendung wechseln

Geschichtenliste

Die Story-Listenansicht ist der Themenliste sehr ähnlich. Aus organisatorischen Gründen legen wir diese Ansicht (und später die Story-Detailansicht) in einem separaten Ordner ab. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Namen Ihres Projekts und wählen Sie "Hinzufügen> Neuer Ordner". Benennen Sie den neuen Ordner Ansichten. Klicken Sie dann mit der rechten Maustaste auf die Schaltfläche Ansichten Ordner und wählen Sie "Hinzufügen> Neues Element ...". Wählen Sie die Option Windows Phone-Portraitseite Vorlage und benennen Sie es Stories.xaml. Ihr Dialogfeld sollte folgendermaßen aussehen:

Ändern Sie wie bisher den Anwendungstitel in "Simple Digg" und den Seitennamen in "Stories". Ziehen Sie anschließend eine ListBox auf den leeren Bereich unter dem Seitentitel und ändern Sie die Markierung so, dass sie wie folgt aussieht:

 

Zu diesem Zeitpunkt sieht Ihre Story-Listenansicht nahezu identisch mit Ihrer Themenliste aus. Die tatsächlichen Unterschiede werden angezeigt, wenn Sie sie mit Datenelementen füllen.

Story-Details

Die letzte Ansicht für Ihre Anwendung ist die Ansicht "Story-Details". In der Ansicht "Story-Details" werden die vier Daten dargestellt, über die wir zuvor gesprochen haben:

  • Titel
  • Beschreibung
  • Diggs
  • Verknüpfung

Die Anzahl der Diggs und der Titel belegen den oberen Teil der Ansicht, und die Beschreibung der Story folgt darunter. Danach kann der Benutzer durch einen Link zu der betreffenden Story navigieren, wenn sie dies wünscht.

Klicken Sie mit der rechten Maustaste auf das Symbol Ansichten Ordner in Ihrem Projekt und wählen Sie Hinzufügen> Neues Element. Wähle aus Windows Phone-Portraitseite Vorlage und benennen Sie Ihre neue Ansicht Story.xaml. Klicken Sie auf Hinzufügen und Visual Studio wird erstellt Story.xaml und öffnen Sie es zur Bearbeitung.

Ändern Sie den Titel der Anwendung und des Seitentitels in "Simple Digg" und "Story". Ziehen Sie nun eine StackPanel in den leeren Bereich unter Ihrem Seitentitel. Ziehen Sie ein anderes StackPanel in den vorigen StackPanel. Diese StackPanel enthält den Titel der Story und die Digg-Zählung. Sie möchten, dass sich diese Elemente nebeneinander ausrichten, ändern Sie also die Orientierung Eigentum an Horizontal.

Zum Schluss ziehen Sie ein Textblock und ein Taste in deine erste StackPanel. Das Textblock wird die Storybeschreibung enthalten, während die Taste ermöglicht dem Benutzer, die Quellenquelle zu besuchen. Sie müssen einige umfangreiche Eigenschaftsänderungen an diesen Elementen vornehmen und müssen sie nicht einzeln durchgehen, sondern nur sicherstellen, dass Ihr Markup folgendermaßen aussieht:

       

Sie können sehen, dass wir die meisten explizit entfernt haben Höhe und Breite Eigenschaften und geändert Text und Name Eigenschaften etwas etwas beschreibender. Im Moment sieht es etwas hässlich aus, aber wir werden das später beheben. Wenn Sie alles richtig markiert haben, sollte Ihr visueller Designer-Fenster wie folgt aussehen:

An diesem Punkt werden die Grundlagen aller notwendigen Ansichten erstellt. Sie können F5 drücken, um die Anwendung zu starten, um zu bestätigen, dass alles funktioniert, aber es wird nur ein leerer Bildschirm mit "Topics" oben angezeigt.

Anpassen des Navigations-Mapper

Als Nächstes müssen Sie sicherstellen, dass Sie Benutzer über Ihre Anwendung leiten können. Dazu verwenden Sie die Navigationszuordnung von Silverlight mit ein paar einfachen Regeln. Öffnen Sie Ihr Projekt App.xaml Datei und platzieren Sie den Cursor innerhalb der Öffnung Anwendung Element und fügen Sie einen neuen Namespace wie folgt hinzu:

 xmlns: nav = "Clr-Namespace: System.Windows.Navigation; Assembly = Microsoft.Phone"

Dadurch wird auf den Windows-Systemnavigations-Namespace (eine Silverlight-Funktion) verwiesen, und Sie können die verschiedenen darin enthaltenen Bibliotheksklassen verwenden. Jetzt finde die Anwendung.Resourcen Element in App.xaml und fügen Sie die folgenden Elemente hinzu:

      

Der soeben eingegebene Code erstellt eine Vielzahl von URI-Zuordnungen für die Ansichten in Ihrer Anwendung. Sie entsprechen jeweils der Themenliste, der Story-Liste und der Story-Detailansicht. Wie Sie sehen, können Sie mit der Silverlight-Navigationszuordnung Abfragevariablen in Ihren benutzerdefinierten Zuordnungen definieren. Dies wird sich später als nützlich erweisen, wenn wir tatsächlich Daten füllen.

Mit der URI-Zuordnung sind Sie jedoch noch nicht fertig. Sie müssen Ihre Anwendung dazu auffordern, dies zu verwenden UriMapper, also öffne die App.xaml Code hinter, indem Sie auf den Pfeil neben klicken App.xaml und öffnen App.xaml.cs. Innerhalb der App Methode nach dem Aufruf an InitializePhoneApplication () Fügen Sie die folgende Anweisung hinzu:

 RootFrame.UriMapper = Ressourcen ["UriMapper"] als UriMapper; 

Diese Anweisung weist Ihre Anwendung an, den soeben definierten UriMapper zu verwenden XAML für Ihre Telefon-App. Nun fangen wir an, einige Daten aufzufüllen.

Füllen der Themenliste

Als Erstes müssen wir die Themenliste auffüllen. Wir machen das, wenn der Benutzer zum ersten Mal navigiert MainPage.xaml Seite. Um sicherzustellen, dass dies geschieht, überschreiben Sie das OnNavigatedTo Methode für die Hauptseite Klasse. Öffnen MainPage.xaml.cs Klicken Sie auf den Pfeil neben MainPage.xaml. Platzieren Sie den Cursor hinter dem Konstruktor und fügen Sie den folgenden Code hinzu:

 protected überschreibt void OnNavigatedTo (System.Windows.Navigation.NavigationEventArgs e) Basis.OnNavigatedTo (e); WebClient digg = neuer WebClient (); digg.DownloadStringCompleted + = neuer DownloadStringCompletedEventHandler (digg_DownloadStringCompleted); digg.DownloadStringAsync (neuer Uri ("http://services.digg.com/1.0/endpoint?method=topic.getAll"));  void digg_DownloadStringCompleted (Objektsender, DownloadStringCompletedEventArgs e)  

Das kann man im Inneren sehen OnNavigatedTo Methode, die Sie erstellen WebClient Weisen Sie ihm einen Event-Handler zu, wenn ein String heruntergeladen wird, und weisen Sie ihn an, den String vom Digg herunterzuladen topic.getAll Methoden-URL. Wir wissen, dass der herunterzuladende String im XML-Format vorliegt. Daher müssen wir sicherstellen, dass unser Event-Handler das XML-Format analysieren kann. Zu diesem Zweck verwenden wir die im .NET-Framework verfügbaren Linq-Bibliotheken. Bevor wir diese Bibliotheksklassen verwenden können, müssen wir der Bibliothek jedoch einen Verweis hinzufügen. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Eintrag "Verweise" und wählen Sie "Verweis hinzufügen ...". Wählen Sie in der angezeigten Liste die Option aus System.Xml.Linq und klicken Sie auf "OK".

Jetzt müssen Sie nur noch den von Ihnen erstellten Ereignishandler ausfüllen. Veränderung digg_DownloadStringCompleted so sieht es wie folgt aus:

 void digg_DownloadStringCompleted (Objektsender, DownloadStringCompletedEventArgs e) if (e.Error! = null) return;  XElement topicXml = XElement.Parse (e.Result); var topics = von topic in topicXml.Descendants ("topic") neues Thema auswählen Name = topic.Attribute ("name"). Value, ShortName = topic.Attribute ("short_name"). Value; TopicsList.ItemsSource = topics;  

Zuerst prüfen Sie, ob der Download erfolgreich abgeschlossen wurde. Wenn dies der Fall war, parsen Sie die resultierende Zeichenfolge und generieren eine Sammlung von Themen mit Linq to XML. Bei Interesse können Sie auf der offiziellen MSDN-Site mehr über Linq to XML erfahren.

Zum Schluss ordnen Sie die ItemsSource Eigentum der Themenliste zu den Themen, die Sie analysiert haben. Wenn Sie unter Topic eine gekrümmte Linie sehen, platzieren Sie den Cursor danach, klicken Sie auf den Abwärtspfeil, der unter dem Wort angezeigt wird, und wählen Sie "using SimpleDigg.Digg" aus. An diesem Punkt sind Ihre Themen gefüllt. Starten Sie Ihren Telefonemulator durch Drücken von F5, und es sollte etwa Folgendes angezeigt werden:

Wie Sie sehen, wurde Ihre Liste gefüllt, aber die korrekten Daten werden nicht angezeigt. Kümmern wir uns jetzt darum.

Datenvorlagen

Datenvorlagen sind eines der leistungsfähigsten Werkzeuge in Ihrem Silverlight-Toolkit. Damit können Sie das Markup definieren, das für beliebige Objekte angezeigt werden soll. An dieser Stelle definieren wir DataTemplates für Digg-Themen und -Stories. Öffnen App.xaml und platziere deinen Cursor innerhalb der Anwendung.Resourcen Element. Fügen Sie folgendes Element hinzu:

   

Dieses DataTemplate enthält eine einfache Textblock Element, das an das gebunden ist Name Eigenschaft des angezeigten Objekts. Wenn Sie sich erinnern, die Digg.Topic Klasse enthält a Name Eigenschaft, die auf den Wert gesetzt ist Name Attribut, das vom Digg-Themen-API-Aufruf zurückgegeben wurde. Kehre zu deinem zurück MainPage.xaml und finde das ListBox Element. Fügen Sie eine neue Eigenschaft hinzu ItemTemplate zum ListBox wie folgt:

 ItemTemplate = "StaticResource TopicTemplate"

Diese Codezeile weist die Anwendung an, die zuvor erstellte zu verwenden DataTemplate Ressource, um die Topic-Objekte anzuzeigen, aus denen sich ListBoxs Sammlung. Wenn Sie die Taste F5 drücken und Ihre Anwendung ausführen, werden die Themennamen jetzt ordnungsgemäß angezeigt:

Stories abrufen und anzeigen

An diesem Punkt können wir anfangen, Geschichten pro Thema abzurufen und aufzulisten. Zuerst müssen wir der Anwendung mitteilen, dass die Anwendung beim Tippen auf einen Thematitel zur Stories-Liste navigieren soll. Öffnen MainPage.xaml und finde dein ListBox Element. Ergänzen Sie die SelectionChanged Eigenschaft und erlauben Sie Visual Studio, einen neuen Ereignishandler zu erstellen. Im MainPage.xaml.cs, Ändern Sie Ihren Event-Handler so, dass er etwa Folgendes liest:

 private void TopicsList_SelectionChanged (Objektsender, SelectionChangedEventArgs e) Topic topic = TopicsList.SelectedItem als Thema; NavigationService.Navigate (neuer Uri ("/ Topics /" + topic.ShortName, UriKind.Relative));  

Wenn Sie Ihre Anwendung jetzt ausführen (durch Drücken von F5), können Sie sehen, dass Sie bei Auswahl eines Themas zur Seite Stories navigieren. Jetzt müssen wir nur noch die Story-Liste auffüllen und sie entsprechend anzeigen lassen. Wie zuvor haben wir das übersteuert OnNavigatedTo Methode, um das zu erreichen. Öffnen Views / Stories.xaml.cs und fügen Sie den folgenden Code hinzu:

 protected überschreibt void OnNavigatedTo (System.Windows.Navigation.NavigationEventArgs e) Basis.OnNavigatedTo (e); String Name; NavigationContext.QueryString.TryGetValue ("Topic", out name); WebClient-Client = neuer WebClient (); client.DownloadStringCompleted + = neuer DownloadStringCompletedEventHandler (client_DownloadStringCompleted); client.DownloadStringAsync (neuer Uri ("http://services.digg.com/1.0/endpoint?method=story.getAll&topic=" + name));  void client_DownloadStringCompleted (Objektsender, DownloadStringCompletedEventArgs e) if (e.Error! = null) return;  XElement storyXml = XElement.Parse (e.Result); var stories = aus story in storyXml.Descendants ("story") Neue Digg.Story Title = story.Element ("title") auswählen. Wert, Beschreibung = story.Element ("description"). Wert, Diggs = Int32. Parse (story.Attribute ("diggs"). Value), Link = story.Attribute ("link"). Value; StoriesList.ItemsSource = Stories;  

Vieles wird Ihnen bekannt vorkommen. Der einzige Teil, der möglicherweise ungerade aussieht, ist das Abrufen des Themennamens. Wenn Sie sich erinnern, haben Sie zugeordnet / Themen / Thema zu /Views/Stories.xaml?Topic=topic. Das heißt, Sie erlauben, dass die Topic-Abfragezeichenfolgenvariable in einem benutzerfreundlichen Format übergeben wird. Beim Navigieren aus der Themenliste haben wir den Themenkurznamen im relativen Uri übergeben. Wenn im obigen Code zu der Story-Liste navigiert wird, rufen wir diese Variable ab und verwenden sie, um die Digg-API-URL mit einem bestimmten Thema aufzurufen.

Wir wissen, dass wir, wenn wir unsere Anwendung zu diesem Zeitpunkt starten, nicht das Aussehen bekommen, das wir für unsere Story-Auflistung wünschen. Definieren Sie ein anderes DataTemplate, das in dieser Ansicht verwendet werden soll. Aufmachen App.xaml und fügen Sie folgenden Code hinzu Anwendung.Resourcen Element.

        

Jetzt mach auf Ansichten / Stories.xaml und ändern Sie Ihre ListBox Element, so dass es wie folgt lautet:

  

Starten Sie Ihre Anwendung, indem Sie die Taste F5 drücken, und klicken Sie auf einen Themennamen. Warten Sie einen Moment und Sie werden sehen, wie Ihre Geschichten erscheinen. Als Nächstes müssen wir die Details der Story auf der Detailseite anzeigen.

Story-Details anzeigen

Um Story-Details anzeigen zu können, müssen wir zunächst die Navigation zur Story-Detailseite zulassen und dann die Anzeige von Daten übernehmen. In der Story-Liste haben wir eine Reihe von Story-Elementen. Wenn einer von ihnen ausgewählt ist, möchten wir das speichern Geschichte Objekt irgendwo und verwenden Sie es dann auf der Story-Detailseite. Dazu fügen wir dem Ereignis einen Ereignishandler hinzu SelectionChanged Veranstaltung wie folgt:

 private void StoriesList_SelectionChanged (Objektsender, SelectionChangedEventArgs e) PhoneApplicationService.Current.State ["Story"] = StoriesList.SelectedItem; NavigationService.Navigate (neuer Uri ("/ Story", UriKind.Relative));  

Hier speichern Sie die ausgewählte Story in der PhoneApplicationService Klasse Zustand Eigenschaft, wie von den Best Practices des Ausführungsmodells empfohlen. Wenn Sie eine rote Schnörkellinie haben PhoneApplicationService Setzen Sie dann den Cursor in das Wort und wählen Sie die Dropdown-Liste aus. Wählen Sie "using Microsoft.Phone.Shell"..

Jetzt müssen wir das am anderen Ende abrufen. Öffne deine Ansichten / Story.xaml.cs Fügen Sie den folgenden Code hinzu, der überschrieben wird OnNavigatedTo:

 protected überschreibt void OnNavigatedTo (System.Windows.Navigation.NavigationEventArgs e) Basis.OnNavigatedTo (e); Digg.Story story = PhoneApplicationService.Current.State ["Story"] als Digg.Story; this.DataContext = Geschichte;  

Hier fangen Sie die Navigation zur Detailansicht der Story ab und rufen die in der gespeicherte Story ab PhoneApplicationService's Zustand Eigenschaft, und entfernen Sie dann die Geschichte aus der PhoneApplicationService's Zustand Sammlung. Sie stellen dann das ein DataContext für den Blick auf die abgerufene Geschichte. Dies ist der Schlüssel, da wir diese Bindung verwenden, um die entsprechenden Daten anzuzeigen.

Öffnen Sie Ihr Markup für die Story-Detailansicht in Ansichten / Story.xaml. Ändern Sie die Bindungen wie folgt:

         

Wenn Sie Ihre Anwendung jetzt starten (drücken Sie F5), können Sie einen Drilldown von der Themenliste, der Story-Liste bis hin zu den vollständigen Story-Details durchführen. Die Detailansicht der Story sollte in etwa wie folgt aussehen:

Es gibt nur eine letzte Sache zu tun. Fügen Sie der Link-Schaltfläche in einen Click-Ereignishandler hinzu Ansichten / Story.xaml wie folgt:

 

Ändern Sie Ihren Event-Handler, Link_Click, zu lesen wie folgt:

 private void Link_Click (Objektsender, RoutedEventArgs e) WebBrowserTask task = new WebBrowserTask (); task.URL = (this.DataContext als Digg.Story) .Link; task.Show ();  

Wenn Sie eine rote, geschwungene Linie sehen WebBrowserTask, Bewegen Sie dann den Mauszeiger über die Klasse und wählen Sie dann "using Microsoft.Phone.Tasks" aus der Dropdown-Liste aus. Dieser Code startet den Windows Phone 7-Webbrowser, wenn Sie auf die Schaltfläche klicken, und navigiert zur URL der Story.

Beenden

Sie haben zu diesem Zeitpunkt einen voll funktionsfähigen, wenn auch einfachen Digg-Client. Sie können Storys nach Themen durchsuchen, Storydetails anzeigen und die gesamte Story in der WP7 Webbrowser. In diesem Tutorial haben wir:

  • Erstellt Klassen zum Speichern von Digg-Daten
  • Erstellen und Anpassen von Anwendungsansichten mit dem visuellen Designer
  • Benutzerdefinierte Navigations-URIs und benutzten den Windows Phone 7-Navigationsdienst
  • Implementierte DataTemplates und Styles zum Anzeigen von Storys und Themen
  • Überschreiben Sie die Ereignisbehandlungsroutinen OnNavigatedTo und OnNavigatedFrmo, um die entsprechenden Funktionen für jede Seite bereitzustellen
  • Verwenden Sie die Windows Phone 7-Tasks, um einen Webbrowser zu starten

Einige der Themen, die wir behandelten, sind zu ausführlich, um sie in einem einfachen Tutorial zu behandeln, so dass Sie wahrscheinlich mehr über sie erfahren möchten. Die folgenden Ressourcen sollen Ihnen den Einstieg erleichtern:

  • Datenvorlagen
    • Datenvorlagen - Übersicht
    • WPF-Tutorials: Datenvorlagen
  • Styles
    • WPF-Tutorials: Styles
    • WPF Guided Tour - Stile
  • Windows Phone 7-Programmierung
    • Programmieranleitung
    • Fertig machen

Ich hoffe, Ihnen hat dieses Tutorial gefallen. Wenn Sie Fragen haben oder in einem zukünftigen Windows Phone 7-Lernprogramm etwas anderes sehen möchten, lassen Sie es mich in den Kommentaren wissen.