Microsoft 70-484: Essentials of Developing Windows Store...

Explore how Windows 8 design principles emerged from Zune concepts and spread across Windows 8, Windows Phone, and the broader Microsoft ecosystem.

Explore how Windows 8 works, tour start screen and missing start button, and dive into Visual Studio 2012 to examine the anatomy of a Windows 8 application and Windows Store.

Zune redux demonstrates how the Zune software redesigned the user interface with live updating tiles, motion, a flat, chrome-free layout, and right-click simplicity, shaping Windows 8.

Explore how Windows 8 changes the user interface and navigation across devices, and learn how to get around Windows 8 and adapt your applications for deployment.

Explore how the standard logon screen in Windows differs from earlier versions and how you can tell this isn’t the same old Windows before you log in.

Discover how Windows 8's start screen replaces the start menu with live tiles and app icons that display dynamic information, support gestures, integrate store and desktop apps, and enable customization.

Learn how to start a program not on the start screen by bringing up the Windows 8 search feature instead of shutting down the application under the traditional start menu.

Start typing from the start screen to locate apps with an instantaneous search and best matches; on tablet, swipe to reveal the charm bar and tap search for immediate results.

Explore how Windows 8 store apps differ in lifecycle from traditional desktop apps, showing there are no minimize, maximize, or close icons; apps suspend and resume when needed.

Learn how to close Windows 8 apps, including the maps application, via the task manager, dragging the window to the bottom, or using a keyboard shortcut, with cross-platform gesture equivalents.

Use desktop mode in Windows 8 with corner gestures to view Windows Store apps on Start screen, switch between apps, and access charm bar for search, share, devices, and settings.

Explore how desktop mode and gestures differ on Windows 8 and quickly navigate the most important user interface features for development.

Learn how Windows 8 mouse gestures map to touch gestures on tablets, aiding testing on touch devices, and review a table of touch, mouse features, and keyboard shortcuts.

Begin windows store app development with Visual Studio 2012, the industry standard IDE, and explore its updated look aligned with Windows 8 style apps.

Discover Visual Studio 2012's Windows Store app tools, including new templates, page inspector, JavaScript IntelliSense, image previews, a browser testing toolbar, AppStore support, and CSS improvements.

Explore the device simulator in Visual Studio to test Windows Store mobile apps in tablet form, mimicking rotation and touch events for testing without deploying to Windows Phone.

Move beyond hello world by exploring your first Windows Store app in Visual Studio 2012, choosing the language you’re most comfortable with, and accessing code samples in the research section.

Learn to run and test a Windows Store app with Visual Studio’s run menu, using the simulator, local, or remote machine options, and simulate touch, rotation, pinch, and various resolutions.

Explore the anatomy of a Windows 8 app by creating a blank C# project, running it, and inspecting package manifest, certificate, assets, main page, application definition, styles, and assembly info.

Explore Windows Store app requirements, including minimum resolution and snapped view, and how the package manifest and its Applications UI tabs configure name, splash, orientation, and logos.

Design a Windows Store app tile and splash screen by creating white on transparent images with paint.net or Photoshop, select a background color, and configure the overlayed text for tiles.

Enable wide tile support by adding a wide logo image and declaring it in the package manifest; provide logo.scale-100, 140, 180, and 80 files for density and backgrounds.

Explore the capabilities tab to select every capability required by your app, since a capability is a special permission for actions tied to privacy, data usage, or charges.

Explore how Windows Store apps declare capabilities as permissions that influence downloads, including location services, and how users enable or disable these via the settings charm and permission links.

Explore how the permissions settings enable turning capabilities on or off at runtime, categorized into four groups: file, device, network, and identity.

Restrict the capabilities your app requests to a minimum to gain a competitive advantage. A piano app asking to use the internet may trigger Windows Store processes or be disallowed.

Explore how Windows Store apps access files and devices through libraries, file pickers, and restricted capabilities, including documents, music, pictures, and videos libraries, removable storage, and network options.

Explore identity capabilities, focusing on the shared user certificates capability that accesses digital certificates to validate a user's identity for enterprise environments, a restricted outlier affecting App Store permissions.

Explore how the declarations tab enables contracts or extensions for cross-app communication with the outside world, under user control, exposed via the charms bar or file picker.

Enable seamless workflows by leveraging package manifest extensions that establish special agreements between an app and built-in window apps such as the camera, PC settings, or people, without running beforehand.

Configure the packaging tab for windows store listings. Replace the package name with a human-friendly one, and add a 50 by 50 logo centered; most values auto-replace on upload.

Package a Windows Store app by configuring version numbers (major, minor, build, revision), updating the store logo, and aligning publisher info with certificates for uploads.

Inspect the main page in a blank app: a page-derived main page with an empty themed grid and a code-behind that initializes components.

App.xaml defines the application class and handles app-level tasks, separate from visuals. Place application wide resources, such as custom styles, in the app's resources collection.

Explore how the app xml ties to standard styles and the common subfolder, initializes the component, and manages the launch with splash screens and assembly versioning.

Explore the under-the-hood structure of a Windows 8 app and move toward topics about being owned by stores.

Behold the XAML master part 1, exploring Zembla, Zahm, and Zambal as declarative languages for constructing and initializing objects, and how XML maps elements and attributes to objects and properties.

Discover how XAML defines declarative user interfaces for Windows store apps, while XML serves as a general purpose language beyond UI, enabling separation of visuals, behavior, and styling.

Explore how the XML specification maps object oriented properties and events to XML elements and attributes, comparing a button in XML to its C# equivalent with content and click event.

Explain how runtime event handlers attach before properties are set, allowing events to fire as attributes initialize, and show that property and event order should not matter.

Examine how a namespace is indicated in the samples by the x M L and S.

Explore how the SML namespace maps to windows runtime namespaces with hardcoded framework mappings, and learn to declare distinct SML namespaces and prefixes on root or child elements.

Identify the default imported namespaces on the main page and how the X prefix defines a zambo language namespace with XML parser directives that appear as attributes to SML elements.

Declare the UI XML namespace as the primary namespace and use a secondary namespace with a prefix for clarity, with the default namespace approach.

Understand the markup compatibility XML namespaces with the MC prefix, including ignorable and process content attributes, and how Visual Studio and Blend create design-time properties that are ignored at runtime.

Discover how rich control composition lets a button host content, compare c-sharp and xml attribute syntax with property elements, and learn how type converters map strings to color and brush.

Explore how markup extensions, including type converters, evaluate string attributes at runtime to create objects, noting you cannot create your own, with built-in options invoked by curly braces in XAML.

Learn to apply multiple markup extensions in xaml by assigning them to properties, using the identifier in curly braces to name the extension, and leveraging positional and named parameters.

Explore how markup extensions mirror custom attributes in the Dot Net framework, an intentional extensible mechanism, and observe how binding lets content reflect the height property.

Markup extensions work with property elements syntax, mapping constructor arguments to properties like binding's path and relative source's mode.

Learn how xml-based sml enforces a single root object, uses content properties and collections, and implements lists and dictionaries with key-value pairs and C# equivalents.

Plain text inside an object element converts to a brush via a type converter, turning strings like white into a solid color brush and clarifying how mapping occurs.

Explore how Anmol integrates with the dot net type system to use arbitrary objects declaratively, requiring a default constructor and useful properties, with proper namespace usage.

Explore how XML based Windows Store apps blend XML with procedural code, and learn two ways to mix them—dynamic loading and parsing—using Visual Studio, and open a new blank app.

Learn to parse xml strings with a static reader, create Windows runtime objects, access root and child elements, and reliably identify a stop button by naming.

Illustrate how the language namespace defines primitives and why the system namespace isn’t needed, then explain xml processing rules for object elements' children: i-list, dictionary, and content property.

Explore mixing XAML and C# in a Windows Store app by locating a named start button on the main page using FindName, avoiding explicit casts.

Explains the x:Name syntax and the framework element name property for naming elements, shows when to use each, and why x:Name is necessary for elements without a name property.

Learn how loading and parsing XML at runtime integrates with procedural code in Windows Store projects, with Visual Studio generating the plumbing to connect XAML with code-behind.

Explore how XAML and code-behind connect in a blank app, using partial classes, auto-generated glue files, and Visual Studio's solution explorer to wire events like button clicks.

Explore how xaml and code-behind connect in windows store apps via generated g.cs and g.i.cs, wiring events and initializing components from xml elements and app resources.

Explore how the XML language namespace defines keywords treated specially by parsers, controlling exposure to procedural code and highlighting Windows Store–relevant keywords with the x prefix.

Discover XAML keywords and the language namespace, including two special attributes for whitespace parsing and declaring language and culture, with the ex-MIL prefix mapped to the standard SML namespace.

Master SML as we build user interfaces and examine controls, and use this initial review to reinforce our knowledge for the rest of the course.

Explore Windows Store app development with Visual Studio, focusing on full-screen, touch-first experiences, XML declarative models, and the balance between procedural code and markup extensions.

Explore the Visual Studio editor in the laboratory, and inspect how controls and the canvas behave, then complete independent laps to practice implementing ideas.

Build a basic data entry form with a bordered layout, including first name, last name, email, phone, and a contact type combo box with hardcoded options.

Dive into serious Windows 8 app development by applying the new architecture and operating system concepts in a world without chrome.

Learn to present data in Windows 8 apps using new controls, layout, sizing, lifecycle, and file handling with grid view bindings.

Explore data presentation with xaml in visual studio, contrasting older silverlight workflows with modern wizzy editors and zambo controls to efficiently create app pages.

Learn to design xml user interfaces in Visual Studio 2012, using the toolbox, document outline, properties pane, and xml tab to streamline complex window store applications.

Master the Visual Studio XAML designer: drag controls from the toolbox onto the page, use the document outline to locate and reorder elements, and edit properties in the pane.

Master core concepts of user interface development with XML by exploring the window, control stack, and categories of controls that guide layout, interaction, and content display for Windows Store apps.

Master layout concepts for Windows Store apps by using grid, stack panel, and canvas to position content with rows and columns, leveraging Visual Studio for practical demonstrations.

Explore grid layout controls in a blank app by defining row and column definitions in XML and via the designer, and understand attached properties for heights and widths.

Learn how attached properties define a global, settable property on any object, using a grid to manage row and column definitions in markup.

Learn how grid attach properties let child controls set their grid row and column, place a button in a 5-column by 3-row grid, with zero-based indexing, and explore sizing concepts.

Explore how the grid control sizes rows and columns using pixel-based, auto, and star sizing to create fluid layouts. Compare grid sizing with traditional HTML and CSS techniques.

Explore grid layouts in XAML by setting row heights with pixels, auto, or star sizing; see how auto adapts to content and how star values create flexible rows.

Master the grid control, the most common layout tool in Windows 8 based apps, to deliver content to users with flexible grid-based layouts.

Join a quick lab to walk through a process that demonstrates a concept just discussed, with you following along as you wish in grid control part 2.

Open a Visual Studio project, place controls on a grid, and nest a child grid with a 25-point margin. Define columns: first column, a 25-pixel column, and a three-star column.

Design a grid layout by arranging controls into multiple rows and columns, setting row heights and margins, and positioning elements in specific grid cells.

Explore grid control scope and positioning by examining how each element belongs to its parent container, then practice arranging controls with grids and stack panels to improve design precision.

Explore how the stacked panel control serves as a container to stack objects vertically or horizontally, with no columns or rows, and adjust margins via the orientation property for spacing.

Explore stacking controls with the stack panel: add buttons and text boxes, adjust orientation and alignment, and apply margins and styling in design view.

Explore how a stack panel enhances internal positioning within a grid by arranging buttons and text boxes, enabling left-right alignment and margin-based spacing for clean layouts.

Use the canvas control for absolute positioning, placing objects with top and left properties and the canvas top and canvas left attached properties on a paint-like canvas.

Position a canvas inside a stacked panel to serve as a reference for absolute positioning. Use the canvas left and top properties to fix controls in place across resizes.

Use the canvas control to build a simple Windows 8 game, drawing shapes and images in an easy area, and moving them with attached left and top properties.

Explore the scroll viewer as a container that enables vertical or horizontal scrolling for overflow content, with a single child that can be a canvas, stack panel, or grid.

Learn to create a scroll viewer, stretch it to fill the screen, host a horizontal stack panel, adjust margins and auto settings, and enable horizontal scrolling in a Windows app.

Tune the ScrollViewer control by configuring vertical visibility options (automatic, disabled, hidden, visible) and enabling an auto horizontal scrollbar to allow scrolling through the app’s controls.

Explore text and button controls in Windows Store apps, learn how code-behind handles events, and preview the MVVM approach with data binding to separate UI from logic.

Compare the text block and text box controls in xml, focusing on their text and content properties, and learn how buttons display text using content while capturing user input.

Learn to implement button controls, handle click events, and customize button content such as text, images, or shapes, including dropdown-driven actions, in a Windows Store app.

Learn to wire a button click event to change a color changing rectangle in a grid, using code-behind to set the rectangle's fill to a solid color brush.

Explore handling button click events to change colors in a wrap rectangle, naming buttons like green button click and blue, yellow, and orange, and observe how events affect other elements.

Explore the checkbox control with content. Use three-state mode with checked, unchecked, and indeterminate events to update a text box, and navigate to pages or links with the hyperlink button.

Create a Windows 8 app that navigates between pages with a frame and a basic page, using a stack panel of two hyperlink buttons for internal and external navigation.

Learn how to load external content with the hyperlink button in a Windows Store app. Unlike Silverlight, the navigate URI property doesn't redirect automatically; handle the click event to redirect.

Handle a click event to launch a browser asynchronously, using await to wait for completion and keep the UI responsive while navigating external and internal links via a hyperlink button.

Discover how the combo box uses an item collection, sets default selections, handles selection changes, and displays the chosen item's content property.

Define a public contact class with first name, last name, full name, and title; populate an observable collection and bind it to a combo box, including a select contact placeholder.

Bind an observable contact list to a combo box, set display member path to fullname, and update text blocks with the selected contact's full name and title on selection change.

Explore how the radio button control presents all options, enforces single selection with a shared group name, and uses the checked property for defaults, shown in an AFC North example.

Configure a slider to set sensible minimum and maximum ranges, handle the value changed event, and customize tick marks with tick frequency and placement.

Learn to display images in your app with the image control, using internal or external sources, and manage size via stretch options like none, fill, uniform, and uniform to fill.

Use the media element control to add multimedia to your app, configuring the source for assets or resources and enabling play, stop, rewind, and fast-forward in a Visual Studio sample.

Explore styling controls with control styles, XML features to reduce code, and data binding for dynamic interfaces, use Windows Store controls like list view and grid view with semantic zoom.

Apply styles to Windows controls by creating a style and applying it to one or many controls, and compare css-like control styles in XAML with font and margin properties.

Explore how to style text box and text block controls using control styles and resource dictionaries to apply across pages or the whole app.

Refactor repeated controls into basic text block and basic text box styles, apply them with static resources, and use target type and global styling to standardize controls.

reference app-wide styles by adding them to app.xaml or a custom resource dictionary to provide global access to resources and globalization strings for language switching.

Create a resource dictionary, move basic styles there, and merge it into the app to make global styles available across pages and resolve style references.

Learn to reference styles across a Windows Store app using Microsoft’s default common standard styles to ensure consistent UI and safe customization through copies.

Explore how data binding with zambo controls links the user interface to underlying data, eliminating manual control access and auto-updating the user interface.

Explore how to bind a player data entry form to a player class loaded from a database using data binding in Visual Studio, contrasting no binding versus binding approaches.

Explore data binding in a Windows store app by wiring a player and team class to UI controls, using a data context and a player view model to populate lists.

Explore how data binding reduces boilerplate code and streamlines collecting form values and saving to or loading from a database.

Explore data binding in a Windows app by binding the item source to a view model's team list and setting display member path to show team names, reducing boilerplate code.

Bind a program object to the user interface to auto-load values, and implement two-way binding so user edits update the bound player via text boxes in Visual Studio.

Explore two-way data binding in a Visual Studio app by binding a team list to a selected team, updating the view model, and reflecting selections in the UI.

Set the grid data context to the selected player to bind text box controls to the player's properties, while the lists on the main page maintain their own bindings.

Demonstrate two-way data binding in a Windows Store app by binding the selected player's properties through a base view model and INotifyPropertyChanged, enabling real-time UI updates via XML.

Demonstrates two-way data binding by setting a single data context on the container grid to bind multiple controls to the same object, reducing code behind.

Explore two-way data binding to capture user input from text boxes, update bound objects, and push new values back to the database or data store.

Participate in a hands-on data binding lab to explore data binding concepts and modes, sharpening practical skills in a lab-focused learning session.

Explore binding modes by using two-way binding in a text box, see how edits push changes to the object, and distinguish one-way and one-time bindings.

Bind a business object to UI controls to auto refresh data context and track changes; use data-bound controls to manage collections with combo box, list box, list view, grid view.

Bind a combo box to a collection, handle selection changes, and populate a form with two-way data binding using a display member path for the full name.

Choose when to bind to a specific property versus a full object in data binding for combo boxes and lists, and access properties after selection.

Explore the list box control in Windows 8, presenting all options at once and comparing it to the combo box for displaying lists of content or data.

Bind a list box to an item source and use a display member path to show names from the contacts view model, and handle selection changes with selection changed event.

Explore how list view and grid view provide flexible, customized presentations of data beyond basic combo boxes and list boxes, enabling vertical, tailored layouts for business objects in user interfaces.

Discover how a list view binds an item source to a property, presenting richer items with selection check marks and color changes via data templates.

Learn to define a data template and bind properties to present data with a thumbnail, title, and author information; explore template selection by logic and display of hierarchical data.

Define a data template for a list view to display books with image, title, and author, binding the image path and using page resource styles.

Explore list view data binding and selection modes, from single to extended. Learn when to use observable collections versus generic lists and how notify property changed updates the list view.

Learn how the grid view, a powerful data control, displays a content collection horizontally with optional grouping, supports data binding, and uses data templates for each item.

Use grid view control to display items in a horizontal layout with two books per row, using a data template with thumbnail, title, author, and subject.

Explore how a grid view groups items by a subject key, using collection view source and a grouped booklist to present roached book objects in a grouped grid.

Group a roached books collection by subject using a collection view source and grid view, binding the items source to the grouped view and displaying headers for each subject.

Discover how the grid view groups items by category and how semantic zoom supports pinch gestures and control and mouse wheel to zoom in or out and navigate grouped content.

Explore how semantic zoom uses a zoomed-out subject grid to navigate many subjects, with a collection view grouping headers, and tap a subject to open its books.

Wrap the grid view in a semantic zoom control to enable zoomed-in grouping and a zoomed-out header view; bind zoomed-out view to groups via a collection view source using subject.

Master finishing touches for Windows Store UI with data binding, app bar, toast notifications, customized splash screen, and live tiles to deliver a complete Windows Store app experience.

Learn how Windows Store apps reduce chrome by using top and bottom application bars for navigation and command actions. See a maps app example illustrating operations like traffic and directions.

Learn to create the top level app bar and bottom bar, add filtering and sorting, and follow the top-navigation bottom-functionality pattern to master the app bar.

Navigate the dread pirate world by exploring stories, characters, and missions using a Windows Store app with top and bottom app bars, a main frame, and image-driven navigation.

Explore built-in Windows Store app bar styles in Visual Studio 2012, including the previous bar button style, and implement a subframe for multi-page navigation with back and forward controls.

Configure the home page to display categories (stories, characters, emissions) using XML with stacked panels, images, and text blocks, and wire taps to navigate by tag to the destination pages.

Wire up the stories page with a reusable top and bottom app bar, a grid view using a shared book template, and filter and sort with observable collections and LINQ.

Set up app bars, per-page filters, and sorts for characters and emissions using grid views, templates, and code behind with LINQ queries to enable contextual navigation.

Explore how toast notifications deliver concise messages in Windows Store apps, featuring top-right display, optional sounds, configurable messages, user opt-out, and remote delivery via the Windows push notification service.

Learn to use Windows 8 toast notifications judiciously, with standard seven-second toasts and rare twenty-five-second toasts, created via simple SML messages and templates.

Demonstrate how to create and display Windows 8 toast notifications using the toast notification manager and XML templates, customizing text, images, and sounds.

Configure toast notifications by editing the XML to add image and text nodes with attributes and audio, then test on a device in full screen mode to verify foreground behavior.

Discover how Windows 8 live tiles replace static icons with dynamic tiles that show real-time information from your application, using static tiles for logos and lifestyles for standout apps.

Learn to implement live tiles that act as a user dashboard, showing calendar events, birthdays, messages, contacts, weather, and other live notifications at a glance without opening the app.

Update live tiles by reflecting background state changes, such as weather, so users see current information on the start screen; choose a tile template and tailor data for the updater.

Explore lifestyle templates for tiles, including text-based options and image support. Start with a background image and color in Visual Studio, then layer text and images.

Create custom live tiles for your Windows Store app and practice sending notifications to update the start screen.

Update a wide live tile with user input using the tile update manager and a template; preview a 10-second notification on the Start Menu.

Replace the default splash screen asset in the assets folder to create a custom splash screen for Windows 8 store apps, which displays during load and must meet specifications.

Replace the default splash screen with a custom image sized 620 by 300 pixels, then run the app to view your new splash screen.

Explore how Windows 8 rethinks app management with a mobile-like lifecycle: store apps suspend in memory for seamless resumes and terminate when memory is low.

Learn how to close a music app on a tablet by dragging down from the top, and understand that gesture-based life cycle controls require practice before they work smoothly.

Explore Windows 8 lifecycle and execution states not running, running, suspending, suspended; note store certification forbids ui elements that close apps and use win key x to open task manager.

Explore how Windows 8 shows a splash screen on first launch and configure it via the manifest with transparent PNGs, background color, and scale images for high CPI displays.

Extend the splash screen to run long activation tasks, load assets quickly, and display a progress ring on a mimicked splash page for a seamless app transition.

Explore how Windows Store app activation works, including contracts and extensions that enable inter-app interfaces and enhance built-in Windows 8 features.

Configure the app manifest with declarations for contracts such as file open and save pickers, file type association, background tasks, auto play, search, share target, and launch activation.

Understand how a Windows Store app suspends, remains in memory, and resumes from where it paused, and why it may refresh stale data on resume.

Learn to manage Windows Store app lifecycles by handling suspensions, resumes, and terminations, saving state locally, and using activation and previous execution state insights.

Explore how Windows 8's new application programming interfaces empower apps to handle application data, files, access permissions, and networking across diverse devices, sensors, storage, and network capabilities.

Explore how Windows Store apps store and access data across local, roaming, and temporary stores, declare manifest access, and use Windows storage namespace for files and settings with async operations.

Declare explicit capabilities to access locations like music library, documents library, and picture library, and use the file picker to grant future access to folders and downloads.

store and manage local application data to persist settings and files, using containers and keys, with options for larger data via file io and async operations.

Enable a seamless multi-device experience by using the Windows roaming data store to synchronize app settings, favorites, themes, and colors across devices via a Microsoft account.

Roaming settings store lightweight data like user preferences and navigation bookmarks, enabling cross-device task continuation while respecting roaming quota and handling data changed events with a dispatcher.

Learn how temporary application data stores files that may be deleted, accesses the application data temporary folder, and uses versioning to upgrade or convert old data, including clearing stores.

Explore accessing libraries in a lab setting by examining pictures, whether yours or mine, and learn to navigate the lab environment while clearing application data.

Query the pictures library and display images in a grid by building a picture viewer with a data template, a picture converter, and bound items via collection's view source.

Discover how the Windows file picker functions as a contract that provides three services to apps: enabling user file access, saving files, and handling file updates.

Open a picture file with the file picker and display its name to the user to illustrate basic file selection.

Demonstrates a file open picker in thumbnail mode to select a single file from the pictures library. Uses the most recently used list, future access list, and file type filters.

Learn how Windows MRU and future access lists work, with MRU up to 25 items and future access up to 1000, including adding files, retrieving via tokens, and manual removal.

Demonstrate serialization and deserialization in dotnet using data contracts, including a runner class, roaming folder storage, and optimizing the data member name property for roaming store efficiency and json interoperability.

Encrypt and decrypt data in a Windows Store app using the Windows.Security.Cryptography namespace and its sync methods. Review cryptography policies before submitting your app for Windows Store certification.

Assess local versus remote data storage, remote data access planning, data access APIs, and content and configurations management to plan data requirements for Windows Store apps.

Explore remote data access by treating cloud and remote endpoints as data sources in Windows 8, using JSON or XML data from services like Facebook or Flickr.

Plan remote data access by balancing local and remote data usage, acknowledging device storage limits and how relational databases and media such as images, audio, and video affect offline access.

Discover sequel lite, a self-contained transactional relational and file-based database ideal for offline data in Windows apps, with easy migration to server or cloud when needed.

Explore remote data options by consuming and delivering JSON or XML via web services across devices, including Windows Store apps, RESTful ASP.NET services, and the Open Data protocol (OData).

Build back-end services with ASP.NET web API to create consistent restful services that apps can consume over HTTP, hosted on remote servers, Windows instances, with data stored anywhere.

Explore Sky Drive as a cloud storage option with seven gigabytes per user and access via file open or save pickers, and use Windows mobile services for cross-platform apps.

Explore managing app configuration data and metadata, including user preferences and temporary data, and centralize or synchronize data with Windows Azure across platforms.

Explore the application data API in the Windows storage namespace, using local or roaming settings to store configuration data and cache offline data efficiently without excess disk usage.

Learn to design remote data architecture for Windows Store apps by hosting data in the cloud, while accommodating legacy databases and supporting structured and blob storage for content and configuration.

Explore how to use Zambo to build Windows 8 interfaces with XML, event handling, and controls like grid, canvas, and stack panel, plus data binding and semantic zoom.

Build a Windows store contact app with two pages. Define a contact class with name, category, company, email, image, and associations, and implement a category grid with semantic zoom.

Explore Windows 8 contracts and associated extensions, a different arrangement within Windows, as the lecture moves into deeper discussions of these concepts.

Explore how Windows store apps use contracts and extensions to declare interactions, outlining requirements and agreements between apps and the Windows operating system.

Explore an overview of Windows 8 contracts, focusing on search settings and share contracts, and an introduction to Windows extensions in contracts 101.

Explore Windows 8 contracts such as the file picker, cached file updater, play to, share, search, and settings contracts, and see how apps enable file selection and cloud synchronization.

The lecture explains how the search contract elevates search from apps to the Windows operating system search, delivering a consistent experience across the app and activation via the search charm.

Implement the search contract in a quick lab and inspect an application that uses Netflix data to search for movies and entertainment content.

Create a new blank app, add the search contract template in Visual Studio 2012, and implement on search activated with the sample search results page.

Explore how a Netflix search app adapts when the data stream is unavailable, implementing search activation, query submission, and navigation to results using MVVM in Windows Store apps.

Explore the MVVM pattern, a presentation-model inspired approach that abstracts a view into its state and behavior. Learn how it leverages core UI features for streamlined WPF and Silverlight development.

Master the model view view model pattern to gain separation of concerns, embrace declarative data binding, and use the view model with business-layer validation to minimize code-behind.

Explore mvvm pattern where the model represents data, the view displays user interface controls, and the view model mediates with declarative data binding, exposing properties and commands.

Explore the Netflix view model in MVVM, exposing an observable collection of release years and an asynchronous get titles method to fetch, order by rating, and apply filters.

Expose app settings through the settings contract and charm for quick access from the screen edge, ensuring a consistent Windows platform experience.

Identify how settings provide entry points for options, help, notification management, and permissions, while ratings and reviews are system-generated and linked to the app's rate page in the window store.

Leverage the share contract to build reachable Windows Store apps without custom code for social networks, using the data transfer manager to handle data requested and target application chosen events.

Explore how the devices charm provides a streamlined interface to send content from the current app to target devices, using the play to contract in a video player example.

Learn to stream images, audio, and video to compatible devices using the play to feature, manage play to sources and playlists, and handle device state on a shared local network.

Explore contracts 102 with a deeper dive into share, search, and settings, building on the initial contracts 101 overview.

Expose content search via the search contract to enable in-app and outside-app search, add a search results page, and register the app as a search provider.

Override the on search activated to define behavior when the search charm activates, and implement a query submission handler to control how the search is executed.

Delve into the search contract and how Windows orders search pane results by user query frequency. Examine the auto-generated search page's features and why developers must supply the results logic.

Explore how the auto generated search results page uses a class with image, title, subtitle, and description properties, binding via data templates to render hard-coded search results in Visual Studio.

Demonstrate search contract usage by adding a search result class and a search results page, showing hard-coded results, filter changes, and navigation arrows for a demo.

Implement search filters by adding named filters with counts and active state in the load state, then verify filtered results update for chosen categories and handle empty queries gracefully.

Handle the search pane's suggestion requested event to provide up to five suggestions, using deferral for longer tasks, and optionally include separators and storage file data.

Explore how to use search features to check visibility, access the current query, set placeholder text, and show the search box programmatically, while handling query changed and submitted events.

Enable local content suggestions in the search pane for Windows Store apps, specify folders to index (such as the pictures library), and use advanced query syntax to limit results.

Learn guidelines for implementing search in your app with the search charm, leveraging user queries and history to improve visibility, and adding a prominent search icon or box for consistency.

Explore a simple search suggestions feature, while noting that results may not match every need; some file names lack extensions, and the Windows indexer excludes files with underscores.

Revisit the laboratory and dive into a deep dive on the subject, kickstarting contracts search part 1.

Generate data for a contacts list by creating a new application with a search contract and a search result class, then run the app in Visual Studio.

Searches in a contacts app use a contact model with image, name, company, phone, and email, a search result UI, and a view model for professional, personal, and other lists.

Integrate with the settings pane using the settings contract, handle commands, add up to eight links with id, label, and callback, and programmatically show the settings pane.

Explore adding app-specific links to the settings page, showing a settings pane user interface on click, and why you can't inject custom user interface into the pane for shared targets.

Develop a custom settings pane for a Reversi game by using a light-dismissing pop-up, a shared settings fly-out, and a view-model architecture to manage display options.

Use the settings pane as the primary entry point, keep settings simple with smart defaults, and create concise entry points that group related options.

Create a consistent Windows Store settings UI using flat surfaces launched from entry points, side flyouts, fixed widths, back button, and standard controls like toggles, radios, selects, and text inputs.

participate in a hands-on lab to add settings to the contacts application, updating the app with new settings and guiding you through implementing these settings in the Windows store app.

Learn to add settings options that control visibility of professionals, personal, and other lists using a two-way binding and a custom settings pane, enabling instant UI updates.

Explore the share contract, a richer Windows clipboard that lets apps act as sender, receiver, or both, sending text, images, documents, or custom data.

Learn to handle the data requested event, populate a data package in multiple formats, and show the share UI to share via mail, people, or social apps.

Learn to share data with custom formats using data packages and set data provider methods. The first parameter identifies the format, with built-in shortcuts like set text for set data.

Learn how data format IDs and the standard data formats class support share contracts. Understand why standard representations ensure cross-app compatibility and how conventions for people, places, and movies evolve.

Identify apps involved with publishing, storing, or transforming data, such as adding speech bubbles to photos, as share targets. Declare support in the package manifest for formats or file types.

Learn how to add a share target contract to a Windows app, configure supported data formats like text, and handle share target activation with the share pane and quick links.

Learn how apps act as share sources and targets for specific data formats, displaying metadata in content previews. Handle long sharing operations with progress updates and clear error messages.

Learn best practices for Windows Store sharing contracts, including linking to online content, preserving user selections, and presenting metadata to keep the sharing flow simple and integrated.

Debug target apps with simulators or remote debugging; the debugger may dismiss the app. Keep the fullscreen app open, go to the start screen, and perform the share scenario.

debug a share target app by attaching on the local machine or simulator, handle activation errors gracefully, and process long running shares asynchronously with a strict call order.

Add sharing capabilities to a Windows Store application by exploring how to implement and integrate sharing features during practical lab-style scenarios.

Add sharing to your app by implementing the share contract with a data manager transfer class, handling events, deciding what contact data to share, and choosing share source or target.

Add sharing capabilities to the app by configuring the data transfer manager as a share source, handling the data requested event, and sharing a contact's name, company, email, and phone.

Explore adding sharing to an application by using share targets like Mail and People, including full text in the share payload, and handling incoming shared data as contacts.

Integrate Windows charms for search, share, print, stream, and settings to differentiate your app, while programmatically showing relevant panes and considering an app-specific search experience.

Explore how extensions form an agreement between an app and the Windows operating system to extend Windows features through their own Windows Store apps.

Explore a variety of extensions, including account picture provider extension, auto play extension, background tasks extension, contact picker extension, file activation, protocol activation, and ssl certificates extension.

Prompt the user before changing the current user's account picture. Use the Windows system user profile's user information class and its account picture changed event to refresh the UI.

Explore the account picture provider, which sets a user's profile image via set account picture, set from stream, or storage files for small, large, and video versions; handle protocol activation.

Explains how to declare auto play actions for new content such as discs or content shared via tap and go NFC, including content events, display names, and verbs.

Design Windows Store apps to suspend when not in foreground and resume on return; use background capabilities for limited real-time tasks, while considering battery power and responsible use.

Learn how store apps register and host background tasks using the background task builder in the Windows application model, implement the background task interface, determine triggers, and allocate system resources.

Use the Windows contact picker to select one or more contacts, restrict retrieved fields with the desired fields property, and pass data to your app or other apps via activation.

Explore how apps use the file activation extension to activate when a user opens a file, register to handle file extensions in manifest, and override the on file activated method.

Define file type associations in package manifest with display name, logo, info tip, an all-lowercase id, and content type, then manage extensions, safe-open settings, and file activation in file explorer.

Declare a protocol in your package manifest to handle schemes like mail, enabling protocol activation, and use the SSL certificates extension to install digital certificates for secure communication.

Address unacceptable behavior in a section lab while learning how to add declarations to an app in Windows Store development.

Explore adding declarations to a sample app, including a file picker, search by contacts, a custom settings pane, and data sharing of name, email, phone, and image.

Explore key Windows Store contracts—search, share, and settings—and their code samples, plus related extensions like file activation and protocol activation, to implement interaction scenarios in Windows apps.

Wire up the app and handle diverse input methods—touch, pen, mouse, and keyboard—across Windows Store development for a flexible user experience.

Use built-in framework controls to support touch, mouse, keyboard, and pen across Windows Store apps, coding for touch to get correct mouse and pen behavior, and optimize for specific inputs.

Explore a touch-first input approach, covering touch and manipulation, zooming with the mouse, using a stylus or pen, and the traditional keyboard.

Learn how Windows 8 supports Xbox 360 controllers and exposes input to C# and VB via DirectX, while noting that game development isn't covered in this course.

Explore options for handling touch and mouse interactions, focusing on cross sliding and dragging events in Windows 8.

Explore touch input in Windows store apps, including multi-touch, pointers, gestures, and manipulations, and learn how built-in controls like the scroll viewer handle events automatically.

Explore how Windows 8 introduces the pointer abstraction for touch, mouse, and pen, enabling a single API to handle common input characteristics across devices.

Explain how pointer devices such as touch, mouse, and pen generate pointer points with properties like contact size, button, pressure, and angle, and how Windows enumerates devices.

Explore the pointer class and its four properties, including pointer ID and the pointer device type, and learn to distinguish touch input from mouse for contact and in range events.

Explore the pointer point class, which exposes position, raw position, time stamp, frame ID, pointer ID, and device, plus predication state; use static methods to get current and intermediate points.

PointerPoint properties expose the contact rectangle, raw position, contact radius, primary pointer status, and touch confidence, with data affected by touch predication and possible near-touch range or z-axis detection.

Learn how your code accesses pointer classes via pointer events, a routed UI event exposed by every visual element that can raise them and bubble up through the element tree.

Master pointer events for touch and pen inputs, including pressed, moved, released, entered, exited, cancelled, and pointer capture, with app-relative or element-relative positions and high-resolution coalesced points.

Learn to implement drag and drop with pointer events by capturing the pointer on pointer pressed and releasing it with release pointer capture to keep dragging under the cursor.

Explore draggable user interface concepts for Windows Store app development, focusing on implementing drag interactions and draggable elements, as introduced in draggable Jan part 1.

Use pointer capture properties to manage dragging without an is-dragging flag, attaching capture logic to the shape field to avoid page-wide capture, and release is a no-op if not captured.

Drag Jan around a simple image inside a border on a canvas, with pointer pressed, moved, and released events updating left and top to implement drag-and-drop.

Explore a drag and drop with single-pointer input, contrast with multi-pointer interactions, and learn why pointer captures and event handling are needed to prevent pointer conflicts in user interface elements.

Explore how an element's capture can block pointer events for elements beneath it, and describe other conditions that prevent the underlying element from receiving events, a testable (hittable) case.

Explore how visibility and hit testing determine rendering and input for UI elements, including a separate hit test visible knob that keeps an element visible but unresponsive.

Understand why the visibility property uses a two-value enum (visible or collapsed) for compatibility with Silverlight Windows Phone and Windows 8 porting. APF defines a three-value visibility (visible, collapsed, hidden).

Explore how hit testing reacts to transparency and opacity across backgrounds and content. Understand canvas bounds, empty pages, and zero-size elements that still affect pointer events.

Test an element’s hit ability using the visual tree helper and FindElementsInHostCoordinates, account for obscuring elements, and understand the top-to-bottom hit order when querying coordinates.

Explore how Windows gesture recognizers convert raw pointer events into high-level gestures like taps, press-and-hold, and double taps, ensuring consistent behavior across apps, mouse, touch, and pen.

Explore tap, press and hold, and double tap interactions to trigger context menus and launch actions, and master edge gestures like edge swipes and cross slide to close.

Leverage gesture events exposed on all UI elements rather than manually handling the Windows UI input gesture recognizer, since UI elements already manage gestures for you.

Explore the Windows runtime gesture recognizer and its tap, hold, and cross sliding gestures, and learn to configure settings, tap counts, and attach handlers with pointer points.

Explore the meaning of the right tapped event in touch input and why it mirrors a right-click, since it fires after releasing a single finger press-and-hold gesture.

Explore how a gesture recognizer detects press-and-hold across mouse, touch, and pen using hold flags and a three-state event model started, completed, cancelled, plus swipe and right-tap handling.

Avoid using the gesture recognizer with controls like buttons and list boxes, as control logic can interfere and trigger pointer-in-use exceptions; use simple shapes or custom controls for reliable gestures.

Explore edge gestures in Windows UI: a vertical edge swipe that toggles bottom and top app bars, using the edge gesture class and gesture recognizer, handling starting, completed, canceled events.

Demonstrate how apps automatically detect edge gestures and show or hide them, avoiding direct event handling due to mouse input limitations and a Windows XML apps bug awaiting future versions.

Attach handlers for tapped, right-tapped, double-tapped, and holding on routed ui element gestures, reducing boilerplate and aligning with built-in gesture recognizers; double-tap adds an extra event, with default enabled settings.

Examine the manipulation gesture class detected by the Windows gestural recognizer, designed to handle panning, rotating, and zooming.

Explore three basic manipulations: swipe for navigation and panning, pinch and stretch to zoom, and twist for rotation using multipoint touch, though rotation support is limited on many devices.

Explore multi-touch manipulation gestures, including swipe, twist, pinch, and stretch, and map them to translate, rotate, and scale transforms for UI elements.

Discover how UI element manipulation events expose data for transforms, including started, updated, inertia starting, and completed, and enable them by setting manipulation mode flags (rotate, scale) on the element.

Explore manipulation events, delta data conveying translation (x, y), scale (percentage), and rotation (degrees), to drive element transforms, including expansion in device-independent pixels.

Analyze manipulation delta routed events, compare delta since the last update and cumulative delta since start, and learn to stop manipulation with the completed method, previewing the manipulating Jan lab.

Explore basic manipulation by dragging Jenna around and performing manipulation during laboratory events, while expressing frustration and grabbing a coffee.

Explore manipulating a draggable image in a windows store app by handling manipulation started and delta events, applying composite transforms to drag, rotate, and zoom.

Explore how using a scroll viewer affects built-in panning and zooming, and why manipulation events update transforms on the UI thread, while a second thread smooths performance to avoid lag.

Enable inertia for manipulation events to slow objects gradually after a gesture, creating realistic flicks where distance follows flick speed; inertia activates when manipulation mode is set to all.

Parse manipulation delta events, past values, and inertia, including the inertia starting event. Understand that manipulation completed waits for all delta events, including inertia, and how to customize inertia.

Learn to control inertia in interactions, prevent unwanted flicks off the screen, and implement strategies for smooth motion in Windows Store app development.

Learn to control inertia by adding a flag in your code to manage dragging behavior, preventing unwanted movement while dragging and easing inertia.

Implement an inertia flag to suppress delta events during inertial or dragging gestures. Experiment with transform modes translate X, translate Y, rotate, and scale, noting inertia depends on swipe speed.

Explore how mouse input maps to pointer and gesture events, with mouse dragging as translation and Ctrl+scroll zoom via manipulation events, plus mouse-specific APIs for richer cases.

Explore the window mouse input model, including the mouse device class, retrieving the view, mouse moved events, and mouse capabilities such as presence, scroll support, swap buttons, and button counts.

Explore mouse input concepts, focusing on the scroll wheel and related interactions, and explain why touch input topics were skipped as they are typically mouse-specific.

Learn how pointer events expose pointer point properties to reveal horizontal mouse wheel status, wheel delta, and which of five standard or extended mouse buttons are pressed.

Handle the middle mouse button with pointer point properties and the tapped event to determine which button is pressed, noting pointer events differ for mice and touch.

Explore how gesture recognizer handles mouse, pen, and touch for drag and pan, and why touch uses manipulation or pointer events. Observe dragging state: started, continuing, completed.

Explore gesture recognizer drag events for mouse and pen, drag over, drop, drag enter, and drag leave, and learn why right tapped better handles touch press and hold.

Examine how pen input and stylus support on Windows 8 can fail to clear the screen, highlighting common issues and troubleshooting frustrations.

Explore how Windows 8 integrates pen input as a screen digitizer and exposes pen-specific data like pressure and eraser mode. Enable palm rejection to ignore touch while writing.

Explore pen input details with pen-specific point properties, including barrel button, eraser, pressure, orientation, twist, and tilt. Learn how proximity and non-contact events influence pointer moved events and right-tap behavior.

Examine the keyboard input API, traditional and simpler than older Microsoft tech, with identical input for software and hardware keyboards. Use Windows.Devices.Input.KeyboardCapabilities to query KeyboardPresent and edge gesture behavior.

Explore keyboard input handling in Windows Store apps by examining key down and key up events, key routed event args, and properties like key, repeat count, and scan code.

Learn how UI keyboard events fire only when elements have focus, and how to capture every keystroke by handling the accelerator key activated event via Windows current core window dispatcher.

Explore keyboard input handling in Windows apps using virtual key states. Use get key state and get async state to detect key combinations with the core virtual key states flags.

Demonstrates simulating a game loop with a dispatcher timer that continually checks virtual key states, including the menu and alt keys, to report when the G key is pressed.

Explain the difference between GetKeyState and GetAsyncKeyState in Win32. GetKeyState reflects the key state at an input event, while GetAsyncKeyState returns the state; include left and right variants for modifiers.

Explore how pointer events report keyboard modifier state via the key modifiers property, and learn to handle multiple pressed keys using Windows system modifiers in your Visual Studio keyboard code.

Explore handling keyboard input during pointer movement by detecting the old key, and using key modifiers and virtual key modifiers to respond to specific key presses.

Understand how a UI element gains keyboard input by becoming focus eligible—enabled, visible, testable, and in tab navigation—while the focus manager uses keyboard, pointer, and programmatic states.

Apply finishing touches by adding a context menu for contacts, implementing an app bar for navigation, and enabling editing, adding, drag-and-drop, and filtering and sorting a data-templated contact list.

Explore finishing touches to a Windows app by implementing a drag-and-drop from a contacts list into a detail page, with a drop target and an associate action to link contact.

Learn to handle touch, mouse, and pen inputs through pointer events and properties, and manage keyboard input across software and hardware keyboards, using built-in controls.

We review layout differences, controls, contracts, and extensions, and cover input methods—mice, touch, pens, and keyboards—as we shift focus to getting our app ready for the Windows Store.

Explore the MVP pattern and architect the Windows Store app for deployment. Learn monetization strategies and the steps to deploy and push the app to Windows to generate revenue.

Plan deployment for Windows store apps by examining architecture patterns, monetisation strategies, and steps to prepare the app for store submission.

Developers apply different tools and design patterns to fit the project, and best practices guide solving challenges; start with the VM design pattern for Windows apps.

Explain MVVM, a design pattern for XML-based applications like Windows Store apps, WDF, Silverlight, and Windows Phone, with three elements: the model, the view, and the view model.

Compare the view first and view model first approaches within the BVM pattern. Understand the pros and cons, including data context setup and how views and view models interact.

Advocates a view model first approach using data templating, letting you avoid instantiating views from the view model and keep views and view models in separate projects.

Bind the view to its view model with a locator and binding, enabling focus on user experience while MVVM decouples UI from logic for testable, shareable view models.

Explore inversion of control (IoC) and dependency injection (DI), which remove dependencies to boost testability and maintainability, via an object graph assembled through abstractions or service locator.

Explore inversion of control and dependency injection by refactoring a player editor to accept an IStatChecker via constructor, gaining flexibility through externalized dependency information and injectable implementations.

Explore inversion of control and dependency injection through the Hollywood principle, moving from hard-coded concrete classes to a framework that instantiates objects and satisfies dependencies with abstractions like interfaces.

Explore how IoC and dependency injection decouple components, enable swapping implementations, and facilitate testing with mocks, then implement mvvm with an IoC container and a view model locator.

Explore monetization strategies for Windows Store, including free, paid apps, in‑app purchases, trials, ads, and enterprise deployment options to maximize reach, pricing control, and revenue.

See how customers view the Windows Store as just another app, deeply integrated with Windows 8 and surfaced by the Start screen tile, accessible from the web browser.

Navigate the Windows Store start screen, browse categories, view app descriptions, overviews, details, and reviews, and see how store panes empower the selling platform for installs.

Optimize your Windows Store listing to improve discoverability by crafting a strong app name, clean logo, compelling screenshots and promotional images, and use contracts to boost first impression and visibility.

Learn how to optimize your Windows Store listing by crafting a compelling first paragraph, separating features into concise notes, and using the conversion report to turn views into downloads.

Promote your app by adding Windows Store protocol links and meta tags to your web pages, enabling direct linking and seamless discovery for Windows 8 and Windows 10 users.

Understand the Windows Store revenue model, where new apps earn 70 percent and 80 percent after 25k, offering a larger share and faster targets.

Windows Store scales with revenue, offering developers eighty percent of revenues at around twenty-five thousand, compared to seventy percent at competing stores.

Explore monetization options in the Windows Store, including one-time purchases, time-limited trials, ad-supported models, and existing commerce integrations, and how trials boost downloads and revenue.

Learn how the Windows Store works, explore monetization strategies, and follow a Visual Studio deployment checklist to publish a new app.

Follow the Visual Studio store checklist to deploy a Windows Store app: open a developer account, reserve a name, obtain a license, edit the manifest, and associate with the store.

Capture high-quality screenshots with the Visual Studio simulator and its capture screen button. Upload images to your Windows Store entry from the developer dashboard.

Build the Windows Store project, run in the simulator, and capture screenshots with the copy screenshot button, then save, locate, view, and upload them to the developer center.

Build and create the deployment package in Visual Studio, sign in with Windows Live ID, then upload the package to the Windows Store and await the Microsoft application certification process.

Explore the Windows Store app deployment process with MSDE and the Windows developer Center, including the application certification process. Create a new Windows Store app and walk through it.

Section lab part 1 presents a scenario where finishing up tasks and going home collide with wanting to play rock band after work.

Add models to support all views with dedicated view models, ensure consistent styling across the app, and follow the deployment checklist as needed.

Explore the VBM, IOC, and DI patterns for building usable Windows Store apps, emphasizing discoverability, strong naming and look and feel, plus the App Store checklist and publishing steps.

Emphasize hands-on concepts with code practice and an included questions-and-answers resource to test yourself, and prepare to build and publish a Windows Store app.

Learn the process of developing Windows 8 store applications and start building apps today. Consider the advanced application development in Windows course to enhance your skills and monetize your projects.

Identify the primary resources for building Windows 8 Metro apps, including Adam Nathan's books and Charles Petzold's Programming Windows, to guide you in developing Windows Store apps.