Hands-on Windows Phone 7 Development

This course covers many real-world issues developers face when building Windows 7 Phone applications
Course info
Rating
(15)
Level
Intermediate
Updated
Apr 18, 2011
Duration
3h 5m
Table of contents
WP7 application architecture
WP7 and WCF Data Services
Phone controls and data
Managing state
Description
Course info
Rating
(15)
Level
Intermediate
Updated
Apr 18, 2011
Duration
3h 5m
Description

This course is intended for developers who are familiar with the fundamentals of Windows Phone 7 development. It tackles many of the issues developers will run into in practice when developing real applications, including application architecture, working with services, handling data, and managing settings and state.

About the author
About the author

Yacine has been involved in the development of database-driven, n-tier web applications for over 10 years. Over time he has taken on various roles, including development, project management, offshore platform management and technical consulting. He has helped build a few solutions for Microsoft North Africa.

More from the author
Introduction to Windows Phone 8
Intermediate
3h 59m
Apr 3, 2013
Windows 8 Store Apps Hands-on in 20 Lessons
Intermediate
5h 48m
Jan 28, 2013
More courses by Yacine Khammal
Section Introduction Transcripts
Section Introduction Transcripts

WP7 application architecture
Welcome to this Phone 7 Hands On course series. Throughout this talk and the ones that will follow we'll build a data backed phone application from the ground up, covering many aspects of Windows Phone 7 business application development. In this module, I'll introduce MVVM for the phone and I'll use basic simple data generated in memory to create our MVVM app structure. In upcoming modules we'll add support for accessing remote data through OData, we'll improve the UI using more sophisticated phone controls, and we'll manage lifecycle events such as deactivation and tombstoning. In a second stage we'll also add more features to our application such as image capture and manipulation, cloud supports, and push notifications. We'll begin this talk with a quick review of what the MVVM pattern is and we'll also discuss Windows Phone specific aspects that we need to consider when applying the pattern in an application. Next, we'll go over a simplified real life application scenario that we'll use throughout this course for building our demo application and we'll briefly discuss the app's requirements. We'll the dive in and start coding, building our Phone 7 application from the ground up. We'll create our application MVVM structure, then our ViewModel classes, followed by our Main View and View Hierarchy. Then we'll take a step back for a moment to discuss phone related navigation aspects and we'll go ahead and add navigation to our sample app. Then we'll finish this talk with a discussion of commanding and how it helps maintain separation of concerns in our MVVM app, and I'll show you an example of that using some of the infrastructure that's provided by the open source MVVM Light framework.

WP7 and WCF Data Services
Welcome to this second module of our Windows Phone 7 Hands On series. In this talk we pick up where we left off building a Windows Phone 7 MVVM application, which will continue to improve to make it a data backed application that can read and write data to and from a WCF Data Service. I'll begin with an overview of the Open Data protocol and we'll discuss what it is and what it brings to the table as a new way of exposing and accessing data. We'll also zoom in on Microsoft's implementation of OData, which fully integrates with both the Windows Communication Foundation and Web Stacks. And we'll look at how we can expose our own data as OData resources using WCF Data Services. We'll then shift back to the phone application with a discussion of the new OData client library for the phone. From there we'll examine how we generate queries from the phone to a data service using the library's asynchronous APIs and OData's built-in querying mechanisms that are embedded in URIs. And finally, we'll examine how changes that are made on the phone to data initially retrieved from the service are tracked by the client library and how we can easily push those changes back to the service for persistence in a data source.

Phone controls and data
Welcome to module 4 of this Hands On Windows Phone 7 series. In this talk we improve our phone applications UI by integrating more sophisticated controls from the platform itself and from the Silverlight Toolkit for the phone and we leverage these controls data capabilities. We'll first examine the pivot control, one of the phone's main and most useful built-in controls, and we'll see how to integrate it into our Express Parcels application. Then we'll take a quick tour of the Silverlight toolkit for Windows Phone, which provides a set of great controls and components to compliment the platform. We'll first talk about the PerformanceProgressBar and we'll see how we can bring it into our demo app and connect it to our data workflow. We'll then move on to a focus on the LongListSelector control, a powerful and versatile control that provides a rich selection UI and we'll set it up to work with our data service. We'll also look at how we can improve our application's user experience by deferring the loading of some data until it's needed, in conjunction with the pivot control's built-in capabilities. Along the way we'll see an example of using the MVVM Light framework's messaging facilities to easily achieve decoupled communication among our classes. Then we'll conclude with an example of using two other controls in a toolkit, the ListPicker and the TimePicker and binding them to our service data.

Managing state
Welcome to the fourth module of this Phone 7 course. In this talk we'll look at state management topics on the phone, specifically from a service backed data application viewpoint. We'll start this talk with a brief review of the phone's execution model and the event hooks that are available for managing application state throughout the lifecycle. We'll also look at the constraints that the execution model imposes on our application when working with external data, then we'll dig into OData's specific answer to data state management challenges associated with the phone's lifecycle model, and we'll examine the new DataServiceState class that was designed to address these needs. In the process we'll highlight some of the shortcomings of the current version of DataServiceState and I'll point some ways around these limitations. Then we'll zoom in on some of the challenges of page and control state management in the face of tombstoning. And finally we'll take a stab at storing data locally on the phone and we'll look at an example of enabling a local versus remote data scenario.