This is the first in a series of mini-tutorials and related content on moving applications from Android to Windows Phone.
To get us started, let’s take a look at a simple Android application that takes an amount and computes the total with an 18% tip. We’ll then rebuild it in Windows Phone.
We would like to live in a world in which any time you turn your phone on the 
network is there, full strength. We’d also like to live in a world of peace and harmony.
Until all of this is accomplished, however, you will need to test for network availability and handle those unfortunate moments when the network is not available.
To do so, you can call upon two useful features of the NetworkInformation namespace: the NetworkAddressChanged event and the GetIsNetworkAvailable method.
Periodically, I step up my organizational skills or tools or both (usually after being yelled at for missing something!). Lately, I’ve been doing 
this more intensively as I’m working on a number of different projects and I need to ensure that each is getting its share of my time.
To manage this, I decided to budget a certain amount of time each day to each activity. To be realistic, I allocated the time on a weekly basis, as each day can be somewhat different depending on what comes over the threshold.
Here is my budget
Please be sure to send me your full mailing address and your email address and the name you use to sign on to my site. Once confirmed, all of the books will be going out immediately.
My apologies for the delay.
There has been some confusion about how to make the Silverlight Unit Tests work on 
Windows Phone. The latest release of the Silverlight Unit Tests comes with the Silverlight Toolkit, and it targeted at Silverlight 4. Windows Phone is based on an enhanced version of Silverlight 3 and cannot use these DLLs.
Fortunately, Jeff Willcox has made the right DLLs available on his web site.
Silverlight 3 binaries for the Silverlight Unit Test Framework
Paul Betts works in Office Labs at Microsoft and is the creator of Reactive UI – an MVVM 
framework based on Reactive Extensions.
Listen| Return to Yet Another Podcast
Call in comments: 1-347-YAP-CAST
Walt is a .NET programmer and UX enthusiast. His current UI obsession includes Silverlight, Windows Phone 7 and WPF APIs. His blog can be found at blog.wpfwonderland.com. Walt is also a MVP and the author of the free Shazzam Shader Editor.
Links
http://www.wintellect.com/Training/Courses/Mastering-Windows-Presentation-Foundation
Listen| Return to Yet Another Podcast
Call in comments: 1-347-YAP-CAST
Reactive Programming, Posting # 10
In the previous posting on Reactive Extensions, we created an application that calls on
the Bing translation service to translate a phrase into Japanese, and then back into English. This allowed the introduction of the SelectMany operator.
In this posting we’ll ask the Bing Translation service for a list of every language it knows about, and then we’ll translate a phrase into each language in turn. This will highlight the chaining aspect of SelectMany. (Click on image to see full size).
Part 8 in the Full Stack series in which Jon and I are building an entire application from conception to delivery that includes MVC 3 ASP.NET, Silverlight and Windows Phone.
Also available on Channel 9
Reactive Programming, Posting # 9
Reactive Extensions (Rx) has a number of operators that we’ve looked at already, 
including Select, Throttle, Subscribe and so forth. While SelectMany is not the most important Rx operator, it is surely the most powerful.
SelectMany’s principal job is to allow you to select against an IObservable<T>, run a func<u> and get back an IObservable<u>
IObservable<U> SelectMany(IObservable<T>, func<U>)
|
Read that in your head “SelectMany takes an IObservable of T and a func (funk) of U and returns an IObservable of U.” |
Today we’ll take a look at the case of having a function that returns an IObservable and you wish to then pass the results to a function that returns an IObservable. That is, the case where you wan to chain calls. If you were to use Select, you would end up with an IObservable<IObservable<T>> which is not what you want. SelectMany flattens that for you.
In yesterday’s posting we looked at the Sterling Database. and how to set up and initialize tables, store an retrieve data. Today we’ll build on that to set up the database in App.xaml so that we can handle tombstoning.
When you wish to persist state across usages of your application, Isolated Storage allows you to write to the disk and stash away key-value pairs. For state, this is usually sufficient, but if what you wish to persist is data, especially relational data, then Isolated Storage is a bit limiting.
To meet this need for a more robust data storage scheme, a number of libraries have been developed that work on top of isolated storage. This posting is the first in a series that will examine these options; beginning with the Sterling Database.
