SilverlightShow: Silverlight Community

Daily News Digest 5/23/2013

editorial@silverlightshow.net (Silverlight Show ) — Thu, 23 May 2013 11:26:29 GMT

Here is the new SilverlightShow content for Thursday, May 23rd, 2013.

Subscribe to our Daily News Digest RSS Feed to receive a summary of all SilverlightShow news!

Or follow our news on Twitter - @silverlightshow!

[Windows 8] Provide search suggestions based on local files

editorial@silverlightshow.net (Silverlight Show ) — Thu, 23 May 2013 11:18:59 GMT

Read original post at Thomas Lebrun's Blog

Windows Store Applications allows developers to provide search suggestions to users, so they can find quickly what they are looking for.

For example, you can provide search suggestions using a Web Services or you can even use local files for that. Here is a “naïve” way to do it [...]

Getting the current system language

editorial@silverlightshow.net (Silverlight Show ) — Thu, 23 May 2013 11:12:29 GMT

Read original post at Kraig Brockschmidt's Blog

Although swapping out language resources is something that happens
somewhat automatically when the user changes system language, sometimes
you want to know that directly.

There are a number of APIs in WinRT that relate to this (thanks to Erik Fortune for this) [...]

What Yahoo and Acer can teach Windows 8 app developers

editorial@silverlightshow.net (Silverlight Show ) — Thu, 23 May 2013 10:55:12 GMT

Read original post by Ed Bott at ZDNet

Microsoft has sold plenty of licenses for Windows 8. Six months after its launch, the company announced that 100 million licenses had been sold, with each one representing an upgrade copy or a PC that had rolled off the assembly line and was ready for sale. A rough extrapolation from current usage share figures collected by NetMarketShare and StatCounter suggests that 60-70 million of those PCs are in use today.

But how many people are actually trying out the signature feature of Windows 8, its new apps? And how many are continuing to use those apps on a daily basis?

Implementing the ISupportIncrementalLoading interface in a Windows Store app

editorial@silverlightshow.net (Silverlight Show ) — Thu, 23 May 2013 10:37:47 GMT

Read original post at Marco Minerva's Blog

The ISupportIncrementalLoading interface allows to easily create a collection in which data is loaded incrementally, when a user is about to the end of the items available on the user interface. Using it, we can obtain a fast & fluid scrolling while loading an huge set of records.
First of all, we need a class that inherits from ObservableCollection and implements the ISupportIncrementalLoading interface [...]

Create location aware apps using geolocation and Bing Maps

editorial@silverlightshow.net (Silverlight Show ) — Thu, 23 May 2013 10:22:33 GMT

Read original post by Ross Heise at Windows 8 App Developer Blog

By tying together a user’s location to the business logic of your app, you can easily provide app users with weather, coupons, sporting events, or concert listings for their current location. You can use the geolocation capabilities of Windows 8, along with the Bing Maps SDK, to create great location aware Windows Store apps.

Let’s take a look at how your app can use the location service to provide users location-specific info with either an IP address, WiFi network, or GPS data. Once you have the location, you can use the Bing Maps SDK to show the user where they are.

Daily News Digest 5/22/2013

editorial@silverlightshow.net (Silverlight Show ) — Wed, 22 May 2013 14:38:33 GMT

Here is the new SilverlightShow content for Wednesday, May 22nd, 2013.

Subscribe to our Daily News Digest RSS Feed to receive a summary of all SilverlightShow news!

Or follow our news on Twitter - @silverlightshow!

Basics of Caliburn Micro in WPF MVVM – Part II, Binding

editorial@silverlightshow.net (Silverlight Show ) — Wed, 22 May 2013 14:19:45 GMT

Read original post by Amit Choudhary at CSHandler.com

In the first part of the MVVM using caliburn micro with WPF we saw how to write the bootstrapper to setup everything for the caliburn micro library. Now in this part we’ll see how to start creating new pages in the application and how the binding and events are being defined using this small library project with power of MVVM.

Before we start I would recommend you to go through the previous article showing how to do setup. Once you done with the setup you can design the MainWindowView.Xaml file.

Step-by-Step – Making Windows 8 Pong for a complete beginner

editorial@silverlightshow.net (Silverlight Show ) — Wed, 22 May 2013 14:16:36 GMT

Read original post by Susan Ibach at Go DevMENTAL Blog

Instead of building Hello World to get started learning Windows 8 development, consider customizing your own version of Pong.

“I want to build a Windows 8 app/game, but I don’t know how to get started.”

“I want to do a workshop with some kids but I am not sure what to do.”

“I want to do a workshop with a group who has little or no coding experience, what can I do?”

“I know how to code but I’ve never built a game, how do I get started?”

In my role as technical evangelist, I get asked questions like that a lot! A couple of months ago, one of my team members built a version of Pong with HTML5/JavaScript. It’s not a complicated game, in fact he originally wrote it as a tool to help XNA developers get started with HTML5/JavaScript. But, because he took the time to structure and comment the code, we discovered this template also makes a fun workshop/hands on lab for beginners.

How to create custom XMLNS namespaces to keep your XAML clean?

editorial@silverlightshow.net (Silverlight Show ) — Wed, 22 May 2013 14:05:42 GMT

Read original post at Kunal-Chowdhury.com

XAML namespace is an extension of XML namespace and conventionally written as “xmlns” in XAML pages. We use it on all XAML pages in Silverlight, Windows Phone, Windows 8, WPF related technologies to better reference assemblies and namespaces.

In this post we will learn more about this XMLNS namespace and the way to customize it for a cleaner XAML page. Interested to know it? Continue reading and share your feedback about the post.

Windows 8 XAML Tips - Peeking AppBar

editorial@silverlightshow.net (Silverlight Show ) — Wed, 22 May 2013 10:41:33 GMT

Read original post by Fons Sonnemans at Reflection IT Blog

I have many app is the Windows 8 store now. My Sudoku Free app is the most popular one. It has almost 500.000 downloads and it is played around 13.000 a day. Until recently I received many mails on how to use the app. My support email address is in the Settings panel. Most of these mails where request to add features to the game like 'can I validate a puzzle?', 'can I solve a puzzle?', 'can I get statistics?' or 'can I get a hint?'. Those features are all available in the AppBar of the game. My conclusion is that the average user is still not aware that the AppBar can exist.

To make my users aware of the AppBar I added a peek behavior to it. When you start a sudoku puzzle the AppBar peeks out for just a second, see video. After the implementation I got almost no more of those emails any more.

Testing your Windows Phone app – Part 2

editorial@silverlightshow.net (Silverlight Show ) — Wed, 22 May 2013 10:23:52 GMT

Read original post by Adam Denning at Windows Phone Developer Blog

Testing your app throughout the development process can help you create a really great Windows Phone app. Testing helps ensure that your app is effectively represented in the Windows Phone Store as an app that offers Windows Phone users a high level of performance and quality. A small investment in the key areas described in this post can help you bypass common errors early in the development process, and help you get positive results in the long term. This post is part 2 of a 3-part series that outlines key test areas that you should consider before submitting your app to the Store. See part 1 for additional details.

Daily News Digest 5/21/2013

editorial@silverlightshow.net (Silverlight Show ) — Tue, 21 May 2013 14:24:08 GMT

Here is the new SilverlightShow content for Tuesday, May 21st, 2013.

Subscribe to our Daily News Digest RSS Feed to receive a summary of all SilverlightShow news!

Or follow our news on Twitter - @silverlightshow!

NEW Article: 'WinRT Business Apps with Prism: PubSubEvents'

editorial@silverlightshow.net (Silverlight Show ) — Tue, 21 May 2013 14:16:59 GMT

We just published the fourth part of Brian Noyes' series WinRT Business Apps with Prism (read part 1/part 2 /part 3). Check it out:

WinRT Business Apps with Prism: PubSubEvents

In this part, the author covers the loosely coupled communication mechanism from the newly released Prism for Windows Runtime, called PubSubEvents. Read more »

Brian Noyes is also the author of two of the most successful SilverlightShow ebooks:

WCF RIA Services
Working with Prism 4

Follow us on Twitter and/or Facebook and be up-to-date with all new content published at SilverlightShow!

WinRT Business Apps with Prism: PubSubEvents

editorial@silverlightshow.net (Brian Noyes ) — Tue, 21 May 2013 14:01:00 GMT

Download the source code for this article

This is part 4 in the series WinRT Business Apps with Prism.

Introduction

In this article, I am going to cover the loosely coupled communication mechanism from the newly released Prism for Windows Runtime, called PubSubEvents. This communication mechanism is also known as EventAggregator because it is based on the design pattern of the same name. If you have had exposure to Prism 4, then you might also be familiar with EventAggregator from there. If you already know how to use Prism 4’s EventAggregator, you know how to use the one that ships with Prism for Windows Runtime, because this is simply a ported version, no functional differences other than the projects in which you can use it. For those folks, the quick and dirty is this: the EventAggregator of Prism 4 was ported to a Portable Class Library that uses a SynchronizationContext under the covers for the thread dispatching features, which removes the coupling to WPF and Silverlight and avoids taking a new dependency on WinRT for what the EventAggregator does. This library is set up so that it works with any .NET 4.0 or later, Silverlight 4 or later, Windows Phone 7.1 or later, or WinRT project.

Don't miss

All SilverlightShow Ebooks

In this article, for those that don’t already have a lot of experience with EventAggregator, I will show you how you can use it to communicate between components in your application, typically between ViewModels or between client side services, so that those components do not have to take direct dependencies on each other. Additionally, I’ll show how you can benefit from the fact that Prism PubSubEvents use weak references by default, alleviating the need to worry about unsubscribing from events to avoid memory leaks, how to use it’s thread dispatching capabilities, and how to wire up filter methods to keep your event handlers from being called unless some criteria is met.

Step 1: Set up an app with two decoupled ViewModels

I’m using a modified version of the EventAggregator QuickStart from the Prism for Windows Runtime guidance as my starting point. You can download that starting point here.

The official QuickStart is pretty close to the same as the completed sample from this article. The main difference is that the official one does not use the MvvmAppBase class on the App class, so there is a bunch of boilerplate startup code in the App class. This is because this QuickStart was written and documented prior to the MvvmAppBase class being factored out. If you look at the sample code from this article, you will see that the App class is simple and clean by using the MvvmAppBase class instead, the structure of which was discussed in Part 1 and Part 2 of this series.

This app has a parent ViewModel on the MainPage, with two simple child Views/ViewModels – PublisherViewModel and SubscriberViewModel. Here is what the UI will look like running.

Step 2: Grab the Prism Libraries through NuGet

To build the app starting point solution, you will need to add in the Microsoft.Practices.Prism.StoreApps and Microsoft.Practices.Prism.PubSubEvents libraries. You can do that by downloading the code from here, or you can use NuGet to pull in the binaries. I’m going to do the latter for this article. So head out to Nuget, and do a search on the terms Prism.StoreApps and Prism.PubSubEvents. At the time I am writing this, the NuGet feed has not been updated, so I had to select Pre-release at the top. But that should be updated soon since Prism for Windows Runtime officially released on May 17 2013.

At this point, if you downloaded the starting point solution in Step 1, you should be able to build and run, but the buttons don’t do anything noticeable yet.

Step 3: Add the EventAggregator

To do pub/sub events, you need a middleman object to decouple the publisher and the subscriber. The idea is that they can each take a dependency on the middleman, then they don’t have to directly depend on each other. The EventAggregator is that middleman in Prism PubSubEvents. It is a singleton service that acts as a repository or registry of event objects. The event objects are the things that actually do the dispatching of calls from a publisher out to the subscribers for a particular event. So you need to make a reference to the singleton IEventAggregator reference available to the publishers and subscribers. You could do this through a container as was covered in Part 2, but for this article I am just going to use manual dependency injection.

The way the app is structured, the MainPageViewModel explicitly constructs the two child ViewModels (PublisherViewModel and SubscriberViewModel) and renders their views via DataTemplates.

   1: public class MainPageViewModel : ViewModel

   2: {

   3:     public MainPageViewModel()

   4:     {

   5:         SubscriberViewModel = new SubscriberViewModel();

   6:         PublisherViewModel = new PublisherViewModel();

   7:     }

8:

   9:     public SubscriberViewModel SubscriberViewModel { get; set; }

  10:     public PublisherViewModel PublisherViewModel { get; set; }

  11: }

   1: <Page.Resources>

   2:     <DataTemplate x:Key="SubscriberTemplate">

   3:         <views:SubscriberView />

   4:     </DataTemplate>

   5:     <DataTemplate x:Key="PublisherTemplate">

   6:         <views:PublisherView />

   7:     </DataTemplate>

   8: </Page.Resources>

   9: ...

  10: <ContentControl Content="{Binding PublisherViewModel}"

  11:             ContentTemplate="{StaticResource PublisherTemplate}"

  12:             HorizontalContentAlignment="Center"

  13:             VerticalContentAlignment="Center" />

  14: <ContentControl Grid.Column="1"

  15:             Content="{Binding SubscriberViewModel}"

  16:             ContentTemplate="{StaticResource SubscriberTemplate}"

  17:             HorizontalContentAlignment="Center"

  18:             VerticalContentAlignment="Center" />

So I can simply construct the EventAggregator up in the App class, and pass it into the MainPageViewModel by using a Register call on the ViewModelLocator. It is important to construct the EventAggregator on the UI thread so that it can set up the underlying SynchronizationContext correctly for thread dispatching, so I wait until the OnInitialize override to construct it, then pass it into the MainPageViewModel as a parameter, keeping it in a member variable on the App class to make the singleton lifetime match the App lifetime.

   1: sealed partial class App : MvvmAppBase

   2: {

   3:     IEventAggregator _EventAggregator;

4:

   5:     protected override void OnLaunchApplication(LaunchActivatedEventArgs args)

   6:     {

   7:         NavigationService.Navigate("Main", null);

   8:     }

9:

  10:     protected override void OnInitialize(IActivatedEventArgs args)

  11:     {

  12:         base.OnInitialize(args);

  13:         _EventAggregator = new EventAggregator();

  14:         ViewModelLocator.Register(typeof(MainPage).ToString(),

  15:             () => new MainPageViewModel(_EventAggregator));

  16:     }

  17: }

Next I need to modify the MainPageViewModel to accept the constructor parameter, and to pass it down to the PublisherViewModel and SubscriberViewModel.

   1: public class MainPageViewModel : ViewModel

   2: {

   3:     public MainPageViewModel(IEventAggregator eventAggregator)

   4:     {

   5:         SubscriberViewModel = new SubscriberViewModel(eventAggregator);

   6:         PublisherViewModel = new PublisherViewModel(eventAggregator);

   7:     }

8:

   9:     public SubscriberViewModel SubscriberViewModel { get; set; }

  10:     public PublisherViewModel PublisherViewModel { get; set; }

11:

  12:     ...

  13: }

Now likewise, they each need parameterized constructors to accept and hold the reference to IEventAggregator.

   1: public class PublisherViewModel : ViewModel

   2: {

   3:     private readonly IEventAggregator _EventAggregator;

4:

   5:     public PublisherViewModel(IEventAggregator eventAggregator)

   6:     {

   7:         _EventAggregator = eventAggregator;

   8:         ...

   9:     }

  10:     ...

  11: }

   1: public class SubscriberViewModel : ViewModel

   2: {

   3:     private readonly IEventAggregator _EventAggregator;

4:

   5:     public SubscriberViewModel(IEventAggregator eventAggregator)

   6:     {

   7:         _EventAggregator = eventAggregator;

   8:         ...

   9:     }

  10:     ...

  11: }

Step 4: Define an event class for the needed communication

For the sample app, the idea is that the publisher will publish when a shopping cart has changed that the subscriber also needs to monitor and display information about. When using Prism PubSubEvents, you define an event class for each distinct communication along with a strongly typed payload that can be passed along with the event. The event for our sample looks like this:

   1: public class ShoppingCartChangedEvent : PubSubEvent<ShoppingCart> { }

Believe it or not, that is all there is to defining the event. All the implementation is in the PubSubEvent base class. You just need to define a class that represents the specific event you want to publish and maps it through the generic argument to the payload entity you want to pass when it fires. If you have no payload, you can just use object as the type and pass null.

Step 5: Publish

Wherever it is appropriate in your code (based on user interaction or other triggers) you just need one line of code to publish:

   1: _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Publish(_cart);

You call the GetEvent method on IEventAggregator to get a reference to a singleton instance of your event class (managed by the EventAggregator itself), and then call Publish on that event, passing the strongly typed payload. In the sample app, this is done from the command handlers for the buttons in that view, specifically the PublishOnUIThread method for now.

   1: private void PublishOnUIThread()

   2: {

   3:     AddItemToCart();

   4:     _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Publish(_cart);

   5: }

Step 6: Subscribe

Likewise, in the Subscriber, you can hook up the subscription wherever it makes sense, but typically in a ViewModel that is on construction, as soon as the EventAggregator reference is injected:

   1: public SubscriberViewModel(IEventAggregator eventAggregator)

   2: {

   3:     _EventAggregator = eventAggregator;

   4:     ...

   5:     _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Subscribe(HandleShoppingCartUpdate);

   6: }

The handling method that you pass as a delegate reference to this method needs to have a void return (events are fire and forget) and takes in a single parameter of the payload type:

   1: private void HandleShoppingCartUpdate(ShoppingCart cart)

   2: {

   3:     ItemsInCart = cart.Count;

   4: }

That is it for the basic hookup of pub/sub events in Prism. At this point you should be able to run, click on the “Add Item to Cart (UI Thread) button, and see the count increment in the subscriber view.

Step 7: Define a background subscriber for showing weak references

There is a separate class defined in the sample called BackgroundSubscriber:

   1: public class BackgroundSubscriber

   2: {

   3:     CoreDispatcher _dispatcher;

   4:     public BackgroundSubscriber(CoreDispatcher dispatcher)

   5:     {

   6:         _dispatcher = dispatcher;

   7:     }

8:

   9:     public void HandleShoppingCartChanged(ShoppingCart cart)

  10:     {

  11:         var threadId = Environment.CurrentManagedThreadId;

  12:         var count = cart.Count;

13:

  14:         // Assign into local variable because it is meant to be fire

  15:         // and forget and calling would require an await/async

  16:         var dialogAction = _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>

  17:             {

  18:                 MessageDialog dialog = new MessageDialog(

  19:                     string.Format(CultureInfo.InvariantCulture,

  20:                     "Shopping cart updated to {0} item(s) in background subscriber on thread {1}",

  21:                     count, threadId));

  22:                 var showAsync = dialog.ShowAsync();

  23:             });

  24:     }

  25: }

There is a little complexity in the code there, but basically this is a class with a method that can be targeted by the pub/sub event that will pop a message dialog even if it is called on a background thread and will show what thread it was called on and the number of items in the shopping cart.

The reason for this class is that it is an object that we can explicitly new up, hold a reference to from the view model, then release the reference and cause garbage collection, and see if it sticks around if there is still an event subscription targeting it.

So in the subscriber view you can see two buttons – Add Background Subscriber and GC Background Subscriber. The command handler for the first creates the subscriber, adds an event subscription for it, and holds it in a member variable.

   1: private void AddBackgroundSubscriber()

   2: {

   3:     // Create subscriber and hold on to it so it does not get garbage collected

   4:     _subscriber = new BackgroundSubscriber(Window.Current.Dispatcher);

   5:     _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Subscribe(

   6:         _subscriber.HandleShoppingCartChanged);

   7: }

The second button command handler releases the member variable reference to the subscriber and forces a garbage collection – but note that no code has unsubscribed the event handling that pointed to the object through its handling method.

   1: private void GCBackgroundSubscriber()

   2: {

   3:     // Release and GC, showing that we don't have to unsubscribe

   4:     //  to keep the subscriber from being garbage collected

   5:     _subscriber = null;

   6:     GC.Collect();

   7: }

After adding that code, if you run, click on the Add Background Subscriber button, and then start firing the events from the UI thread, you will see the message dialog pop each time. Then press the GC Background Subscriber button, fire a few more events, and you will see that the background subscriber is no longer there to receive events because it has been garbage collected even though there was never an Unsubscribe call to release the reference that was passed into the event through a delegate.

This is there to address the number one cause of memory leaks in .NET applications – event subscriptions between two objects with different lifetimes where the subscribing object has a shorter lifetime from the consuming code that the object it is subscribing on. A normal event subscription through a delegate holds a strong reference back to the subscriber that will prevent it from being garbage collected if it does not get unsubscribed, even if all other references are released.

But Prism events use a WeakReference under the covers by default, which the garbage collector ignores in its reference counting scheme, so it will allow the underlying object to get garbage collected if nothing else has a reference to it, thus alleviating you from needing to worry about unsubscribing at the appropriate time.

If you want to have a strong reference, just use an overload of the Subscribe method with a second parameter named keepSubscriberReferenceAlive:

   1: _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Subscribe(

   2:     _subscriber.HandleShoppingCartChanged, true);

Step 8: Leverage Thread Dispatching

Another feature of the PubSubEvents is the ability to tell Prism when you subscribe what thread you want to be notified on. If you were to publish from the non-UI thread button in the publisher using a Task to fire on a background thread:

   1: private void PublishOnBackgroundThread()

   2: {

   3:     AddItemToCart();

   4:     Task.Factory.StartNew(() =>

   5:         {

   6:             Debug.WriteLine(String.Format("Publishing from thread: {0}",

   7:                 Environment.CurrentManagedThreadId));

   8:             _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Publish(_cart);

   9:         });

  10: }

You would see you have a problem on the subscriber side when it tries to update a property that is bound from the UI – it throws an exception because the event comes into the subscriber on the background thread of the publisher. All you need to do to fix that is use a different overload of the Subscribe method that takes a ThreadOption parameter. This allows you to dictate from the subscriber that you want to be notified on either the Publisher thread (the default), the UIThread, or a Background thread.

   1: _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Subscribe(

   2:     HandleShoppingCartUpdate, ThreadOption.UIThread);

The PubSubEvents class will handle getting the call dispatched onto the UI thread using a SynchronizationContext it sets up when it is constructed. This means if you are going to use the UIThread option, you need to make sure the EventAggregator is constructed on the UI thread. If you don’t you will get an exception when the Subscribe call is made telling you that. Using SynchronizationContext instead of a Dispatcher means the code can be portable to any .NET platform. If you choose the Background option, a Task will be used to call the subscriber on a Task Scheduler background thread.

Step 9: Leverage Filtering

Sometimes you don’t want your event handler to be called unless some criteria is met first. You could do this by putting a guard condition in the handling method, but from a testability and separation of concerns perspective, that should happen outside of the method that is focused on handling the event. So Prism PubSubEvents lets you pass a filter criteria, in the form of a Predicate<T> delegate (which is equivalent to a Func<T,bool> delegate). You can do that by passing a full delegate reference to a method that takes in the payload type and returns a bool, or you can pass a lambda expression directly to the Subscribe method.

So for our example, if we want to show a warning on the screen if the count of items in the shopping cart exceeds 10, we can do the subscription like this:

   1: _EventAggregator.GetEvent<ShoppingCartChangedEvent>().Subscribe(

   2:     HandleShoppingCartUpdateFiltered,

   3:     ThreadOption.UIThread, false, (cart) => cart.Count > 10);

HandleShoppingCartUpdateFiltered just sets a property that causes a warning to show. But that won’t be called unless the filter criteria (cart.Count > 10) is met.

Summary

In this article, I showed you how simple PubSubEvents in Prism are to use. You saw that once you have a reference to the IEventAggregator in the publisher and subscriber, it is one line of code to publish, one line of code to subscribe, and effectively one line of code to define the event itself. On the subscriber side you have the options of not using weak references (which it does by default), controlling the thread you are notified on, and passing a filter condition that gets evaluated and must pass (return true) before the handling method is called. The publish and subscribe methods are strongly typed based on the payload type specified by the event class.

This allows you to have communications between ViewModels or between repositories and other client side services without needing to pass explicit references between them – meaning more loose coupling in your architecture.

About the Author:

Brian Noyes is CTO of Solliance (www.solliance.net), a software development company offering Architecture as a Service, end-to-end product development, technology consulting and training. Brian is a Microsoft Regional Director and MVP, Pluralsight author, and speaker at conferences worldwide. Brian worked directly on the Prism team with Microsoft patterns and practices. Brian got started programming as a hobby while flying F-14 Tomcats in the U.S. Navy, later turning his passion for code into his current career. You can contact Brian through his blog at http://briannoyes.net/ or on Twitter @briannoyes.

Quick Tip: Processing HTML Content in Windows Store Apps

editorial@silverlightshow.net (Silverlight Show ) — Tue, 21 May 2013 13:54:01 GMT

Read original post by Jeremy Likness at C#er : IMage

The WebView control allows you to display content from sites in your app using a small window that renders the HTML using the same rendering engine as Internet Explorer. It does have some limitations and most likely if you are providing content in your app, your goal is to augment your app with fresh data rather than try to superimpose a full-blown web application on your own native Windows Store app.

Trying to strip down content can be quite cumbersome once you wade through the myriad RegEx expressions or other utilities available. Here’s a simple trick that will work with most content-oriented sites like blogs and online magazines. It allows you to get a more basic view of the content and present it without all of the bells and whistles you may end up pulling down with regular content.

Pre-beta Windows 8.1 WinRT Developer APIs

editorial@silverlightshow.net (Silverlight Show ) — Tue, 21 May 2013 13:49:41 GMT

Read original post at Justin Angel's Blog

In this article we’ll review new developer WinRT features that’ll be released in the upcoming Windows 8 release (dubbed “Windows 8.1” / “Windows Blue”). Microsoft recently announced that during June 2013’s BUILD conference a developer preview of Windows 8.1 will be released for download. In the meanwhile many Windows 8.1 “leaked” images are available online. These “leaked” images allows us to get a sneak preview of the featuresets that’ll be announced in BUILD conference. For the length of this article we’ll go over those features.

Use your HTML5 skills, port your PhoneGap app to Windows Phone, and win prizes

editorial@silverlightshow.net (Silverlight Show ) — Tue, 21 May 2013 12:09:17 GMT

Read original post by JC Cimetiere at Windows Phone Developer Blog

Many of you have heard about PhoneGap (aka Apache Cordova), the popular open source framework you can use to create mobile apps using HTML, CSS, and JavaScript. PhoneGap has supported the Windows Phone platform since Windows Phone 7.5, and had a major update to support new capabilities in Windows Phone 8, including Internet Explorer 10.

Today, we’re launching a Porting Challenge and inviting developers who have used PhoneGap to publish apps in other stores – for example, Apple iTunes, Google Play, Blackberry World, Bada, Symbian, or Palm OS – to take any of their existing PhoneGap apps, published in any store, and port it to Windows Phone 8, like the Untappd app recently ported to Windows Phone 8.

Async Development in WinRT – Part I

editorial@silverlightshow.net (Silverlight Show ) — Tue, 21 May 2013 12:04:32 GMT

Read original post at Can Bilgin's Blog

When you are dealing with an application that directly interacts with a network, or works on network resources, your app is bound to make some long running calls. If we were dealing with a good old Windows Forms application, the most important point was to avoid your application from blocking the UI. We would use some background threads or a background worker, while displaying a (relatively annoying) loading sign. We could extend this pattern by using some completed or error event handlers to notify the UI about the worker thread. The basic goal here is to let the user know that the application is doing some work in the background without blocking the UI thread, hence avoiding the “MyApp is not responding” status.

Conference Buddy on WPF

editorial@silverlightshow.net (Silverlight Show ) — Tue, 21 May 2013 11:54:02 GMT

Read original post by Jesse Liberty at The Telerik Blogs

As you may know, a number of the Evangelists at Telerik are working together on an application tentatively called Conference Buddy, described and summarized here by Phil Japikse. Carey Payette and I decided to create a version of the client in WPF, taking advantage of Telerik’s extensive controls and the fact that WPF runs on all versions of Windows. We decided to use the Windows 8 version as a functional specification – to mimic the capabilities of that application without mimicking the look and feel.

To get started, we created a series of screen mockups to give ourselves an idea of how things will hang together. To do this, we turned to the Storyboarding feature in PowerPoint. This is an add-on that is made available to PowerPoint when you install premium versions of Visual Studio.

Daily News Digest 5/20/2013

editorial@silverlightshow.net (Silverlight Show ) — Mon, 20 May 2013 12:33:02 GMT

Here is the new SilverlightShow content for Monay, May 20th, 2013.

Subscribe to our Daily News Digest RSS Feed to receive a summary of all SilverlightShow news!

Or follow our news on Twitter - @silverlightshow!

New Ebook Added to SilverlightShow Shelf: Windows Store apps with XAML and HTML

editorial@silverlightshow.net (Silverlight Show ) — Mon, 20 May 2013 11:40:17 GMT

The Windows Store made it simple for millions of customers to find, try and buy apps from practically anywhere in the world. If you plan to start building your own Win Store applications, our just released ebook might be of help:

Windows Store apps with XAML and HTML: Ebook

This ebook, authored by Silverlight MVP Andrea Boschin, collects the following 6 chapters:

Chapter 1: Understand the projects
Chapter 2: Layout elements into the page
Chapter 3: Controls to the max
Chapter 4: Handling asynchronous operations
Chapter 5: Using Typescript in Windows Store apps
Chapter 6: Writing C# components for the Windows Srore apps

Andrea is also the author of the following SilverlightShow ebooks:

Visit SilverlightShow Ebooks Market »

Using Viewbox for automatic control scaling

editorial@silverlightshow.net (Silverlight Show ) — Mon, 20 May 2013 11:18:13 GMT

Read original post at Toni Petrina's Blog

Presenting content of varied size can often be tricky. For example, displaying names of metro stations with fixed font size, and it always is a fixed font size, can result in a part of the text being clipped off. Or if you use text wrapping, a large block of text can extend way beyond your intended design. Trimming might help, but you cannot always do that.

Consider the following page:

It uses a very simple layout – two equally wide columns. Notice how the default font might be too small for the text on the left and how variation in button captions create problems for buttons on the right. We would like to increase font size for the text on the right, but it is hard to anticipate how large the text would be. Or if there are large words in the text, they might “bleed” onto the right side. As for the buttons, you would want the entire text to be seen.

XAudio2 Performance and Battery Considerations for Windows Phone 8

editorial@silverlightshow.net (Silverlight Show ) — Mon, 20 May 2013 11:11:49 GMT

Read original post by Joao Lucas Guberman Raza at Windows Phone Developer Blog

In this post we cover important information for Windows Phone 8 developers who use the XAudio2 APIs, including best practices for battery performance. XAudio2 is a high-performance audio API available in Windows 8, Xbox 360, and Windows Phone 8. An app developer can use XAudio2 to create audio graphs in which they can treat each audio source in the graph as a distinct “voice.” The developer can apply different effects to each of the “voices.”

In Windows Phone 8, the XAudio2 engine must be aligned with the life cycle of the app. This means that if an app is suspended, the app that’s using XAudio2 must force the XAudio2 engine to stop. When the app resumes/rehydrates, if it is designed to resume sounds using XAudio2, it must restart the XAudio2 engine. Significant battery drain can occur if an app doesn’t stop the XAudio2 engine when the app is suspended, and the engine continues to run.

How to Specify the Startup Page in Windows Phone

editorial@silverlightshow.net (Silverlight Show ) — Mon, 20 May 2013 10:51:48 GMT

Read original post at Michael Crump's Blog

Something that I get quite often is how do you specify the startup page in Windows Phone. Most people are trying to use the MVVM pattern and by default the MainPage.xaml lives in the root folder as shown below:

Most MVVM purist wants this folder to be clean, and only have the App.xaml and App.xaml.cs left. All of the Views should be located in the Views folder.

SilverlightShow: Silverlight Community

Daily News Digest 5/23/2013

[Windows 8] Provide search suggestions based on local files

Getting the current system language

What Yahoo and Acer can teach Windows 8 app developers

Implementing the ISupportIncrementalLoading interface in a Windows Store app

Create location aware apps using geolocation and Bing Maps

Daily News Digest 5/22/2013

Basics of Caliburn Micro in WPF MVVM – Part II, Binding

Step-by-Step – Making Windows 8 Pong for a complete beginner

How to create custom XMLNS namespaces to keep your XAML clean?

Windows 8 XAML Tips - Peeking AppBar

Testing your Windows Phone app – Part 2

Daily News Digest 5/21/2013

NEW Article: 'WinRT Business Apps with Prism: PubSubEvents'

WinRT Business Apps with Prism: PubSubEvents

WinRT Business Apps with Prism: PubSubEvents

Introduction

Don't miss

Step 1: Set up an app with two decoupled ViewModels

Step 2: Grab the Prism Libraries through NuGet

Step 3: Add the EventAggregator

Step 4: Define an event class for the needed communication

Step 5: Publish

Step 6: Subscribe

Step 7: Define a background subscriber for showing weak references

Step 8: Leverage Thread Dispatching

Step 9: Leverage Filtering

Summary

About the Author:

Quick Tip: Processing HTML Content in Windows Store Apps

Pre-beta Windows 8.1 WinRT Developer APIs

Use your HTML5 skills, port your PhoneGap app to Windows Phone, and win prizes

Async Development in WinRT – Part I

Conference Buddy on WPF

Daily News Digest 5/20/2013

New Ebook Added to SilverlightShow Shelf: Windows Store apps with XAML and HTML

Windows Store apps with XAML and HTML: Ebook

Visit SilverlightShow Ebooks Market »

Using Viewbox for automatic control scaling

XAudio2 Performance and Battery Considerations for Windows Phone 8

How to Specify the Startup Page in Windows Phone