30 coole Windows Phone MSDN Samples

Auf MSDN gibt es ja bedauerlicherweise nicht zu wenig Content, sondern eher zu viel. Da verliert man schon leicht den Überblick. Vor kurzem bin ich über diesen sehr coolen Überblick nach Features für Windows Phone gesurft.

30 tolle Beispiele für Windows Phone Features.

Wer die Links nicht lesen kann: aka.ms/WP8Sample1 bis aka.ms/WP8Sample30.

Neue Bing-Apps für Windows Phone

bing_apps_windowsphoneSeit einigen Tagen gibt es drei neue (und äußerst praktische!) Bing-Apps im Windows Phone Store: Kochen & Genuss, Reisen, Gesundheit & Fitness.

Mit der Bing Kochen & Genuss kann man sich leckere Rezepte auf das Handy holen und damit in der Küche einen super Essen zaubern.

Die zusätzlichen Kalorien kann man sich dann mit der Bing Gesundheit & Fitness – App wieder abtrainieren.

Hat man dann die Nase voll, von Selbstgemachtem, fährt man einfach in den Urlaub und informiert sich mit der Bing Reisen – App einfach über spannende Urlaubsorte.

Die Apps gibt es auch für Windows 8.1 und synchronisieren sich natürlich über die Cloud miteinander, wenn man es möchte. Sehr praktisch.

Link: http://msft.it/BingAppsWP

Neue Hackathon-Termine im Februar und Mai

Die beliebte Hackathon-Reihe von Microsoft Deutschland geht auch 2014 weiter. Bei den Hackathons handelt es sich um Programmierevents für alle, die sich bereits auf der Microsoft-Plattform auskennen und erste Erfahrungen in Sachen App-Entwicklung für Windows 8 und Windows Phone haben. Ziel der Hackathons ist es, gemeinsam mit Gleichgesinnten App-Ideen umzusetzen. Die besten Apps jedes Hackathons werden prämiert. Für 2014 stehen bisher drei Termine fest: 22. Februar in Braunschweig, 10. Mai in München und am 17. Mai in Berlin.

Microsoft kümmert sich vor Ort um den passenden Rahmen: Internetzugang, Testgeräte und natürlich ausreichend Zucker, Koffein, Pizza und Club Mate. Darüber hinaus stehen die Experten von Microsoft auch für inhaltliche Unterstützung zur Verfügung. 

Link: http://msft.it/hackathons_2014

NextGen Reader – Nachrichten noch einfacher lesen und über die Cloud synchronisieren

Nach dem Google sich entschieden hat, den Google Reader einzustellen, und trotz großer Proteste sich nicht davon abbringen ließ, musste ich mir eine Alternative suchen. Und ich habe eine sehr, sehr gute Alternative gefunden. Der NextGen Reader für Windows 8 und Windows Phone 8 ist eine sehr gute App die Cloud-basiert (z.B. über Feedly) Nachrichten aus den diversen Quellen bereitstellt und komfortabel lesbar macht. Über die Cloud wird gesyncht, welche Artikel ich bereits gelesen habe. Damit sehe ich Artikel die ich bereits gelesen habe nicht mehr auf meinen diversen Windows 8 Rechnern oder auf meinem Telefon.

NextGen Reader für Windows

Platform Info Days zu Windows 8, Windows Phone 8 & Windows Azure

Windows 8/8.1 und Windows Phone bieten im Zusammenspiel mit Windows Azure eine breite Palette an Funktionen, die Sie für die Entwicklung von Apps und Anwendungen nutzen können.

Auf dem Platform Info Day lernen Sie die vielfältigen Möglichkeiten dieser Plattformen, sowohl einzeln als auch in Kombination, näher kennen. Sie erfahren welche Features Windows 8, Windows Phone und Windows Azure mit sich bringen, wie diese zusammenspielen und wie Sie für die einzelnen Plattformen entwickeln.

Die Platform Info Days richten sich an Einsteiger, Interessierte, Projektleiter und technische Entscheider, für eine Teilnahme sind keine Programmierkenntnisse vonnöten.

Link: http://bit.ly/platforminfoday

//build Keynote-Live-Viewing in Deutschland

Google und Apple haben ihre Pläne für das neue Jahr vorgestellt. Jetzt ist es an der Zeit zu sehen, auf welche neuen Produkte und Services Microsoft zukünftig setzt:
Am 26. Juni 2013 startet unsere jährliche Entwicklerkonferenz, die //build/ 2013, im Moscone Center in San Francisco.

Ihr möchtet live mit dabei sein, wenn unsere Neuigkeiten rund um Windows, Windows Phone, Xbox und Kinect, Azure und vieles mehr vorgestellt werden?
Dann schaut mit uns gemeinsam die Keynote und tauscht euch mit uns über die geplanten Neuerungen aus! Außerdem werden unsere Evangelisten Daniel Meixner in San Fransisco und Heike Ritter in Madrid per Live-Schalte direkt von ihren Eindrücken der //build/ und der TechEd Europe berichten.

Wir veranstalten drei //build/-Keynote-Viewings in Deutschland:

Betahaus Berlin
Anmeldung unter: http://build-berlin-2013.eventbrite.com/

Microsoft Office Köln
Anmeldung unter: http://build-cologne-2013.eventbrite.com/

Werk1 München
Anmeldung unter: http://build-munich-2013.eventbrite.com/

Die Agenda sieht wie folgt aus:

17.00 Uhr Kick-off und Networking
18.00 Uhr Keynote Live-Stream
21:00 Uhr Ende

Nach der Keynote haben wir dann noch Gelegenheit zum gemeinsamen Chillen und Austausch mit unseren Evangelisten vor Ort. Für Getränke & Pizza sorgen wir, ihr bringt gute Laune und Neugier mit.

Meldet euch noch heute für eure Stadt an! Wir haben nur begrenzt Plätze.

Ich selber werde in München mit dabei sein.

Neue Windows Phone 8 Sample Apps verfügbar

Das Windows Phone Team hat neue Sample Apps für Windows Phone 8 bereitgestellt. Neben den bereits sehr umfangreichen Beispielen die es hier frei zum Download erhältlich sind. (Link)

clip_image002

Windows Phone 8: Zentrale Datenhaltung mittels einfachem ViewModel

Wo halte ich meine Daten? Wo ist meine Logik? Wer steuert eigentlich die App intern?

Immer wieder stoße ich auf sehr wilde Apps, die sich mit wildestem Spaghetti-Code hinter jedem Button-Click-Ereignis ihre Daten von diversen Quellen zusammen suchen, und dabei ein und den selben Code 4x schreiben.

Dabei geht es doch auch viel einfacher. Man steuert alles über eine zentrale Klasse und tut nur noch das Nötigste in der eigentlichen Phone-Page. Nämlich mit einer zentralem ViewModel. Entwicklungsesotheriker und CleanCode-Fanatiker werden bestimmt meckern, das sei ja “schmutzig“, denen Antworte ich aber, “Es ist pragmatisch, einfach und ich werde sogar fertig mit meiner App und sterbe nicht in Schönheit”.

Was benötigt man? Eine zentrale Klasse (das ViewModel), das alles andere steuert, je nach Komplexitität auch Unter-ViewModels. Diese Klasse wird einmal statisch bei Anwendungsstart erzeugt und steht von da an, von überall zur Verfügung.

Hier meine einfachste Version eines ViewModels:

using System.Collections.ObjectModel;
using System.ComponentModel;

namespace PhoneViewModelSample
{
    public class MyViewModel : INotifyPropertyChanged
    {
        private ObservableCollection<Customer> _customerList;

        public ObservableCollection<Customer> CustomerList
        {
            get 
            {
                if (_customerList == null)
                {
                    _customerList = new ObservableCollection<Customer>();
                    for (int i = 0; i < 100; i++)
                    {
                        var newCustomer = new Customer();
                        newCustomer.Name = "Kunde " + i;
                        newCustomer.Id = i;
                        _customerList.Add(newCustomer);
                    }
                }
                return _customerList; 
            }
            set { _customerList = value; OnPropertyChanged("CustomerList"); }
        }

        #region INotifyProperty - Stuff

        public event PropertyChangedEventHandler PropertyChanged;
        private void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        #endregion

        private Customer _selectedCustomer;
        public Customer SelectedCustomer
        {
            get 
            {
#if DEBUG
                if (DesignerProperties.IsInDesignTool)
                {
                    _selectedCustomer = new Customer();
                    _selectedCustomer.Id = 11;
                    _selectedCustomer.Name = "Oliver Scheer Inc.";
                }
#endif
                return _selectedCustomer; 
            }
            set { _selectedCustomer = value; }
        }
    }
}

Die dazugehörige Customer-Klasse:

namespace PhoneViewModelSample
{
    public class Customer
    {
        public string Name { get; set; }

        public int Id { get; set; }
    }
}

Die Klasse MyViewModel wird zentral in der App.xaml instanziert und steht dann allen UI-Elementen in der App sofort zur Verfügung. D.h. ich kann sofort gegen Elemente aus dem ViewModel binden.

image

Damit man auch aus dem Code drauf zugreifen kann, habe ich eine Statische Variable in der App-Klasse erzeugt, die dieses Resources “TheViewModel” auch im Code anbietet.

 

 

public static MyViewModel TheViewModel { get; set; }

private void InitializePhoneApplication() { if (phoneApplicationInitialized) return; // Create the frame but don’t set it as RootVisual yet; this allows the splash // screen to remain active until the application is ready to render. RootFrame = new PhoneApplicationFrame(); RootFrame.Navigated += CompleteInitializePhoneApplication; TheViewModel = (MyViewModel)Resources[„TheViewModel“]; // Handle navigation failures RootFrame.NavigationFailed += RootFrame_NavigationFailed; // Handle reset requests for clearing the backstack RootFrame.Navigated += CheckForResetNavigation; // Ensure we don’t initialize again phoneApplicationInitialized = true; }

 

Das Video, das das ganze noch mal langsam erklärt befindet sich hier.

Der Sourcecode zur App kann hier heruntergeladen werden.

Windows Phone 8: Wie speichert man Benutzereinstellungen

In diesem kleinen Tutorial möchte ich erklären, wie man mit ganz wenigen Schritten Einstellungen die ein Benutzer in der App machen kann, im Isolierten Speicher (Isolated Storage) von Windows Phone speichert.

image

Schritt 1: Anlegen einer leeren App

In Visual Studio legt man einfach ein neues Projekt für Windows Phone an. Es sollten in diesem Beispiel kein Unterschied zwischen Version 7 und 8 geben.

Am besten man legt sich eine leer App an.

Schritt 2: Erstellen der Settingsklasse

Die MyCustomSettings-Klasse:

public class MyCustomSettings : INotifyPropertyChanged
    {
        public string Name
        {
            get { return (string)GetSetting("Name", "John Doe"); }
            set { SetSetting("Name", value); }
        }

        public int Age
        {
            get { return (int)GetSetting("Age", 38); }
            set { SetSetting("Age", value); }
        }

        private void SetSetting(string settingName, object settingValue)
        {
            IsoStore[settingName] = settingValue;
            OnPropertyChanged(settingName); 
        }

        private object GetSetting(string settingName, object defaultValue)
        {
            if (DesignerProperties.IsInDesignTool)
            {
                return defaultValue;
            }

            if (IsoStore.Contains(settingName))
            {
                return IsoStore[settingName];
            }

            return defaultValue;
        }

        private IsolatedStorageSettings _isoStore;
        private IsolatedStorageSettings IsoStore
        {
            get 
            {
                if (DesignerProperties.IsInDesignTool)
                {
                    return null;
                }

                if (_isoStore == null)
                {
                    _isoStore = IsolatedStorageSettings.ApplicationSettings;
                }

                return _isoStore; 
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        private void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }

Die Eigenschaften Namen und Age lesen und schreiben ihre Werte direkt über die Methoden GetSetting und SetSetting. Diese Methoden wiederum greifen zur Laufzeit auf den Isolated Storage zu, genaugenommen auf den ApplicationSettings-Storage für die Anwendungseinstellungen.

Dadurch das die Eigenschaften in direkt über die Methode SetSetting das Ereignis “PropertyChanged” aufruft, und die Klasse die Schnittstelle “INotifyPropertyChanged” implementiert, funktioniert die Datenbindung sofort aus dem Stand.

Schritt 3: Binden der Settings an die UI

Als erstes muss ein obergeordnetes Element der UI an eine Instanz der MyCustomSettings-Klasse gebunden werden. Ich wähle eine übergeordnete Instanz, damit alle darin befindlichen Elemente (Textboxen, etc.) sich bereits in dem gebundenen Datenkontext befinden.

image

Das Grid mit dem Namen “LayoutRoot” hat in der Eigenschaft DataContext eine neue Instanz der Klasse MyCustomSettings zugewiesen bekommen.

Die Textboxen für Name und Age, werden keine Texte direkt zugewiesen, sondern über Datenbindung.

Das Beispiel als Video

Dieses Video zeigt das ganze Vorgehen ausführlich.

Der Sourcecode kann hier heruntergeladen werden.