Wintellog

Silverlight 4's New INavigationContentLoader Interface

jprosise — Mon, 08 Feb 2010 13:37:00 GMT

One of the extensibility points added to the run-time in Silverlight 4 is the new INavigationContentLoader interface, which allows applications that use Silverlight's navigation framework to take control of page loading. In Silverlight 3, navigation URIs had to target XAML files containing Silverlight pages. In Silverlight 4, a navigation URI can target anything—a class name, a Web service that provides page content dynamically, or a XAML file contained in a remote XAP, for example—as long as an INavigationContentLoader implementation is present to support it.

David Poll has blogged extensively about INavigationContentLoader and about the different scenarios in which it can be used. Here, for example, is a great post on using a custom content loader to load pages from XAPs that are downloaded on demand. Here's another that demonstrates how to use a custom content loader to authorize access to a page before navigating to it. It seems there is no end to the purposes that INavigationContentLoader might serve.

To demonstrate the bare-bones basics of INavigationContentLoader, I implemented one that serves a simple purpose: it appends ".xaml" to the file names of the pages targeted by navigation URIs. Rather than declare your Frame control and URI mappings this way:

<nav:Frame x:Name="Main" Source="Home">

<nav:Frame.UriMapper>

<map:UriMapper>

<map:UriMapping Uri="" MappedUri="/Index.xaml" />

<map:UriMapping Uri="Home" MappedUri="/Index.xaml" />

<map:UriMapping Uri="Detail/{id}" MappedUri="/Detail.xaml?id={id}" />

</map:UriMapper>

</nav:Frame.UriMapper>

</nav:Frame>

With my CustomContentLoader class, you do it this way instead:

<nav:Frame x:Name="Main" Source="Home">

<nav:Frame.UriMapper>

<map:UriMapper>

<map:UriMapping Uri="" MappedUri="/Index" />

<map:UriMapping Uri="Home" MappedUri="/Index" />

<map:UriMapping Uri="Detail/{id}" MappedUri="/Detail?id={id}" />

</map:UriMapper>

</nav:Frame.UriMapper>

<nav:Frame.ContentLoader>

<local:CustomContentLoader />

</nav:Frame.ContentLoader>

</nav:Frame>

Note the new ContentLoader property on the Frame control, which allows you to replace Silverlight's default content loader with a custom content loader. The default content loader is an instance of PageResourceContentLoader, which loads pages from local XAML files. My CustomContentLoader wraps an instance of PageResourceContentLoader and appends ".xaml" to target URIs before delegating to PageResourceContentLoader to do the actual loading. Here's the source code:

public class CustomContentLoader : INavigationContentLoader

{

private PageResourceContentLoader _loader = new PageResourceContentLoader();

public IAsyncResult BeginLoad(Uri targetUri, Uri currentUri,

AsyncCallback userCallback, object asyncState)

{

return _loader.BeginLoad(AddFileNameExtension(targetUri),

currentUri, userCallback, asyncState);

}

public bool CanLoad(Uri targetUri, Uri currentUri)

{

return _loader.CanLoad(AddFileNameExtension(targetUri), currentUri);

}

public void CancelLoad(IAsyncResult asyncResult)

{

_loader.CancelLoad(asyncResult);

}

public LoadResult EndLoad(IAsyncResult asyncResult)

{

return _loader.EndLoad(asyncResult);

}

private Uri AddFileNameExtension(Uri uri)

{

int index = uri.OriginalString.IndexOf('?');

if (index == -1) // No query string; append extension

return new Uri(uri.OriginalString + ".xaml", UriKind.Relative);

else // Insert extension before query string

return new Uri(uri.OriginalString.Insert(index, ".xaml"), UriKind.Relative);

}

Note the asynchronous design of INavigationContentLoader. When you implement it, you often have to implement IAsyncResult, too. I didn't have to in CustomContentLoader because I used the IAsyncResult returned by PageResourceContentLoader. While the asynchronous design complicates matters when writing a synchronous loader, it's perfect for content loaders that load pages using Silverlight's asynchronous networking stack.

This is a trivial example, but it still demonstrates the power of INavigationContentLoader. The upshot is that in Silverlight 4, navigation URIs no longer have to target local XAML files, but can be virtualized instead. Look for this to come in handy not only for application developers, but for future versions of Silverlight as well.

A Fluent RSS Reader for Silverlight Part 1: Proof of Concept

C#er : IMage — Sun, 07 Feb 2010 12:53:04 GMT

One of the most common examples to help learn a language or framework is an RSS Reader. This is an ideal mini-project because it includes networking, parsing XML, and binding to data elements such as lists. I wanted to provide an example that shows some more interesting solutions that are possible using C# in Silverlight. This is the first part in a series. By the end of this post, we'll have a working reader. What I'll then do is add some more detailed error handling, provide unit tests, tackle...(read more)

Using Moq with Silverlight for Advanced Unit Tests

C#er : IMage — Tue, 02 Feb 2010 15:10:00 GMT

Moq is a library that assists with running unit tests by providing easily mocked objects that implement interfaces and abstract classes. You can learn more about Moq on their website . There is a distribution for Silverlight, and in this post I'll focus on some ways to use Moq for some more involved testing scenarios. Download the source code for the example project I started with the Simple Dialog Service in Silverlight and extended the example a bit. In the post, I promised that abstracting the...(read more)

Microsoft Online Services: Very Cool (and Cheap!)

jrobbins — Sat, 30 Jan 2010 23:57:13 GMT

This is not a technical post, but one that bumps into business. Yes, occasionally us software developers have to lift our heads up and see that there's more to life than hacking code. This is especially true at small companies, such as Wintellect, were the effort to do business means you can't just hide in your office and forget about everything else.

As we had started the company near ten years ago, we made the traditional decision back then of running our own Exchange Server and had set up VPN so those of us outside the Knoxville, TN home base could get to our servers when necessary. The only "cloud" that people talked about in 2000 were those floating puffy things made of water in the sky. Exchange, as everyone knows, worked great but the VPN (as all VPN's are) was a nuisance. However, for the most part everything "was good enough." As Wintellect has grown over the years, I was getting more paranoid about backups and we were really starting to pay some serious money for our infrastructure. I also had a nagging question in the back of my mind if we were set up to handle future growth.

With employees and contractors scattered around the US and the type of work we do, our infrastructure needs were very similar to that of a company many times our size. As we were working through setting up SharePoint servers and all the rest (especially those backups!), it was obvious that doing it ourselves was going to cost us obscene amounts of money.

I started doing some research and it was clear that Microsoft Online Services (MOS) was the way to go. We priced out our needs and I got ready to present it to our executive team figuring it was a slam-dunk decision. We were going to be cutting our IT bills by 40%-50% and I could sleep at night that our backups and restores would be rock solid. With the Business Productivity Online Suite (BPOS), we'd get Exchange, SharePoint, Office Communicator, and LiveMeeting for employees and Exchange Online for contractors. The day before I was going to make my proposal, Microsoft handed me a wonderful gift of cutting the price for BPOS by 33% (now $10 per user per month) and Exchange Online by 50% ($5 per user per month). It felt wonderful to plug in the new numbers and say we were going to cut costs by 50%-60%.

We planned the transition over the end of 2009 and it went extremely well. By the way, we didn't use a MOS partner we did everything on our own. Microsoft provided a great migration tool that seamlessly moved mail from our internal Exchange server to MOS. Since we have people all over the US, I also wrote an extremely detailed document on exactly how individual users were to do the transitions. That helped immensely as we had everyone from super technical to non-technical users we had to transition and we just couldn't walk over to their computer to fix anything. We tested that document with some of the technical users first so that it was bulletproof. Most people were up and running within 10-15 minutes of logging after their mail was moved over to MOS.

The only problem we had with the transition was with Outlook. Since we were moving from one Exchange Server to another with everyone using their existing user accounts, we found out that Outlook is kind of dumb on how it caches email addresses. Outlook caches those addresses globally and not with the profile. For whatever reason, Outlook caches more than just the email address, so if you had sent a mail to "Bob Smith" it would pick up the "Bob Smith" from our old Exchange server and bounce the mail. Fortunately, all you had to do was delete the cache files according the Knowledgebase article: How to reset the nickname and the automatic completion caches in Outlook.

MOS is not a direct replacement for having your own servers, as you obviously don't get the same level of control and extensibility. For example, with SharePoint Online, you can't run any custom code today. We were willing to trade off those limitations for three reasons. The first is because Microsoft will automatically update MOS to Exchange 2010 and SharePoint 2010 when released. Secondly, based on what Microsoft announced at the SharePoint Conference, we're going to have more than 90% of Microsoft SharePoint 2010's features this year. Finally, everything on MOS is backed up with a wonderful Service Level Agreement (SLA).

Another thing I'm hoping to see in the next iteration of MOS is more automation for administration purposes. Today they have PowerShell scripts to add users, which are nice, but to add them to Exchange Distribution Lists and SharePoint you have to go into the web-based user interface. It's not too onerous, but it would be nice to be able to completely automate adding users to everything in MOS.

I thought it'd be worth sharing our experiences with MOS in case others were interested in hearing a real story. If you're running your own Exchange and SharePoint servers, you owe it to your sanity to check out MOS.

Programmatically Accessing the Live Smooth Streaming API

C#er : IMage — Fri, 29 Jan 2010 18:35:04 GMT

Live Smooth Streaming is a Microsoft technology that allows you to take a live, encoded, incoming video stream and rebroadcast it using Smooth Streaming technology. This technology multicasts the video stream in segments of varying bandwidths. This can then be played with a Silverlight-based client like the built-in MediaElement or more advanced player like the Silverlight Media Framework . The incoming streams could be from your web cam or third party sources, or even from a file encoded on disk...(read more)

Introduction to Debugging Silverlight Applications with WinDbg

C#er : IMage — Sun, 24 Jan 2010 14:04:00 GMT

I've had a few users ask me about finding memory leaks and understanding what happens with references in Silverlight. One very powerful tool to use when debugging Silverlight applications is the Windows Debugging Tools. You can download the 32-bit (x86) version side-by-side with the 64-bit (x64) version . Both WPF and Silverlight ship with an extension DLL you can load called SOS. This extension contains many powerful commands . In the video, Silverlight Debugging with WinDbg (30 minutes long), I...(read more)

Simple Dialog Service in Silverlight

C#er : IMage — Sat, 23 Jan 2010 09:34:04 GMT

I noticed on the forums there are a lot of users not comfortable with asynchronous programming who struggle a bit in Silverlight with getting their arms around the concept of a dialog box. In other environments, you can simply shoot out a dialog, wait for the response, and continue. In Silverlight, of course, the action is asynchronous. I would argue it should be this way most of the time. The problem is that many people tend to take the approach of trying to force the process into a synchronous...(read more)

Amazing .NET Reference Visualizations

jrobbins — Fri, 22 Jan 2010 23:19:39 GMT

Half the battle when tracking down memory problems in a .NET application is seeing the reference chain so you can see why an object is still in use. You can use SOS and its !gcroot command to track them down, but that can bring new definitions to tedious. If there were only away to see all the data that !gcroot pumps out graphically….

Chris Lovett had a brilliant idea: why not use the cool new Directed Graph Markup Language (DGML) to show the output of !gcroot? Chris recorded a video to show you how to use his GCRootToDGML tool. Being able to see your references opens up all sorts of interesting analysis you can do as to who's holding onto your objects. Not only does DGML make things simple, they are artistic. The last view in Chris' video has a Zen quality to it.

Now my mind is spinning on all sorts of other analysis tools we can do with DGML.

Hat tip to Rick Byers for letting me know about Chris' idea.

My CLR via C# book is at the printer. The source code and Introduction are available now!

JeffreyR — Fri, 22 Jan 2010 16:53:00 GMT

Hello all, I just wanted to tell everyone that my book, CLR via C# 3rd Edition, went to the printer this week and should be in stores in early February!
The book has been updated for Visual Studio 2010, CLR 4.0 and C# 4.0.
The source code for the book is available now and can be downloaded from here: http://wintellect.com/Books.aspx
Also, an excerpt from the book's Introduction can be found here: http://blogs.msdn.com/microsoft_press/archive/2010/01/21/rtm-d-today-clr-via-c-third-edition.aspx

New Silverlight 3 Version Released (3.0.50106.0)

C#er : IMage — Wed, 20 Jan 2010 05:59:04 GMT

A new version of Silverlight 3 has been released. You can download the latest control here . If you are a developer, then you'll want to use the developer installer that is available here . This version fixes some issues related to hardware acceleration in the graphics processing unit (GPU), certain cases that cause Deep Zoom to take on high CPU, and issues with downloads from Silverlight applications. Read Microsoft's Knowledge Base article for this release: Description of the update for Silverlight:...(read more)

Wintellect is Headed to Nashville to Boot Scoot with Microsoft’s “A Lap Around PDC Featuring Steve Ballmer”

bvananda — Tue, 19 Jan 2010 16:19:00 GMT

Wintellect is headed to boot scoot boogie in Nashville, Tennessee with “A Lap Around PDC Featuring Steve Ballmer.” Plus, our own Jeff Prosise will be presenting on Silverlight 4 as well. This one day event is shaping up nicely and we are excited to be a part of it as it hits the highlights from the PDC09 conference. This FREE event is almost completely full and will be covering the latest Microsoft technologies and exciting announcements from PDC09 complete with 16 sessions presented by Microsoft, Partners, MVPs and Community Leaders. With a keynote delivered by Microsoft CEO Steve Ballmer, this event promises to be music to your ears. ;) I'm a bit cheesy but it's true!

If you are planning to attend we hope that you will stop by and visit us in the Technology Showcase area. The Wintellect gang will be there, plus Jeff Prosise will be stopping by the booth to answer your pressing questions about Silverlight 4. Additionally, we will be raffling off a Virtual University and Devscovery 2010 pass so be sure to stop by and enter your name into a drawing to win. We hope that you all come prepared to wrangle the future of developer technology!

Stay tunned I will be posting pictures from the event this week!

Making Your Own 8K Homegrown Inversion of Control Container

C#er : IMage — Sat, 16 Jan 2010 07:54:03 GMT

If you develop software, chances are you you've worked with Inversion of Control containers and the Dependency Injection pattern. Many frameworks exist to address how to marry concrete implementations to abstract classes and interfaces. A few popular ones on the .NET platform include: Autofac Castle Windsor Managed Extensibility Framework (MEF) Ninject StructureMap Unity Download the Source for this Example There are a few reasons why I decided to play with the concept of building my own dependency...(read more)

Quick Tip: Embedding and Accessing Schemas in .NET

C#er : IMage — Tue, 12 Jan 2010 11:25:02 GMT

I have a project I'm working on that requires the use of some extensive XML manipulation. While XML can be very powerful, XML without a schema is like JavaScript objects: no strong typing and the wild west as far as standards are concerned. A good, solid XML document will have a valid schema to validate against. It's really not that difficult, either. There are several online tools that can help generate a template of the schema from a sample XML document, like this one . Visual Studio provides full...(read more)

Auto-Discoverable Views using Fluent PRISM in Silverlight

C#er : IMage — Mon, 11 Jan 2010 04:20:02 GMT

One reason a developer would use a technology like MEF is to, as the name implies, make an application extensible through a process called discovery. Discovery is simply a method for locating classes, types, or other resources in an assembly. MEF uses the Export tag to flag items for discovery, and the composition process then aggregates those items and provides them to the entities requesting them via the Import tag. Download the source code for this example It occurred to me when working with PRISM...(read more)

Silverlight 4's New Notification Windows

jprosise — Sat, 09 Jan 2010 13:44:00 GMT

Silverlight 4 includes a slew of features designed to make out-of-browser applications richer. One of those features is notification windows, also known as “toast” windows. This feature is available to all OOBs, regardless of whether they are trusted. It is not available to applications that run inside the browser.

A notification window is one that pops up in the lower right corner of the screen, similar to the ones that Outlook uses to notify users about incoming e-mails. (On the Macintosh, notification windows appear at the top of the screen rather than the bottom.) Notification windows are normally used to let the user know something important has happened. A classic use for them is to inform the user that an updated version of an out-of-browser application is available when the OOB is launched from the desktop or Start menu:

This notification window was created by first declaring a user control named UpdateNotification that contained the following content:

<Border.Background>

<LinearGradientBrush StartPoint="0.5,0.0"

EndPoint="0.5,1.0">

</LinearGradientBrush>

</Border.Background>

<Border.Effect>

<DropShadowEffect BlurRadius="4" ShadowDepth="4"

Opacity="0.4" />

</Border.Effect>

<TextBlock Text="Update Available" FontSize="12"

FontWeight="Bold" Foreground="White" Margin="4" />

</Border>

<Image Source="Images/Update.png" Width="32" Height="34"

Stretch="Fill" Margin="4" VerticalAlignment="Top" />

<TextBlock Width="240" Text="An updated version..."

FontSize="11" Foreground="#FF202020" TextWrapping="Wrap"

Margin="4" />

</StackPanel>

</Border>

</Grid>

Then it was displayed by creating an instance of System.Windows.NotificationWindow, instantiating the user control and assigning it to the NotificationWindow’s Content property, and calling NotificationWindow.Show:

NotificationWindow win = new NotificationWindow();

UpdateNotification un = new UpdateNotification();

win.Width = un.Width;

win.Height = un.Height;

win.Content = un;

win.Show(10000);

The parameter passed to NotificationWindow.Show is a time-out parameter that specifies how long the notification window will be displayed—in this case, 10 seconds. If desired, you can call NotificationWindow.Close to close the notification window early—for example, in response to a mouse click.

Another new feature available only to OOBs is the ability to interact with host windows. In Silverlight 3, out-of-browser applications had limited control over their environment. It was not possible, for example, for an OOB to resize the window in which it was hosted.

This changes in Silverlight 4 with the addition of the System.Windows.Window class and the new Application.MainWindow property. An out-of-browser application can get a reference to its window through the MainWindow property, and it can use Window properties and methods to interrogate and even modify the host window. The following code snippet resizes the host window programmatically:

Window win = Application.Current.MainWindow;

win.Width = 1024;

win.Height = 768;

The Window class also features properties named Left and Top for repositioning host windows, WindowState for minimizing, maximizing, and restoring host windows, and TopMost for controlling the host window’s topmost state. And it includes an Activate method for bringing a host window to the foreground and assigning it the focus.

Automated Silverlight Unit Testing Using StatLight

C#er : IMage — Sat, 09 Jan 2010 08:16:03 GMT

One concern with the Silverlight Unit Testing Framework is that it runs on a UI thread and requires a browser to function. This makes it difficult to integrate into automated or continuous integration testing. Difficult, but not impossible. A solution is provided by the project called StatLight which not only supports Silverlight testing automation, but actually integrates with several different unit test providers. I am focusing on the Silverlight UT for this post. The program is very flexible and...(read more)

RING IN THE NEW YEAR WITH OUR FREE TECH FOCUS SERIES

bvananda — Fri, 08 Jan 2010 16:31:00 GMT

I hope that everyone had a very happy holiday season! 2010 is underway and I wanted to let each of you know that Wintellect is launching its NEW Tech Focus segments. The goal of our Tech Focus segments is to provide developers, all of you, with exclusive, free content straight from Wintellect experts that will help you in your day-to-day work. Each Tech Focus segment will be offered in a bi-monthly format and will showcase a specific technology that is a core part our training and consulting services. Tech Focus members will have access to articles, blog posts, live/free webinars, technical tips via social media, discounts, and much more covering topics like - Silverlight, Azure, Debugging/Performance, Threading, WPF, and ASP.NET.

Our Silverlight Tech Focus series is underway and Jeff Prosise will be providing Silverlight 4 content this month. To learn more or to register simply click here.

Happy New Year!

Silverlight Unit Testing Framework: Asynchronous Testing of Behaviors

C#er : IMage — Thu, 07 Jan 2010 11:27:00 GMT

Last month, I bogged about Unit Testing ViewModels AND Views using the Silverlight Unit Testing Framework . I wanted to take that post a step further and talk about some more advanced testing scenarios that are possible. The site itself provides a lot of information about how to get started and what is available with the framework. One thing to keep in mind that is a radical shift from other testing frameworks is that the Silverlight testing framework runs on the UI thread. This means it does not...(read more)

Silverlight 4's New Managed Extensibility Framework

jprosise — Mon, 04 Jan 2010 14:46:00 GMT

One of the less-talked-about features of Silverlight 4 is the new Managed Extensibility Framework, or MEF. MEF has been evolving on CodePlex for a while now. It's slated to be integrated into .NET 4.0 and Silverlight 4, and as such is something with which developers should be familiar.

As its name implies, MEF is a framework for building extensible applications. It provides infrastructure for loose coupling between components and can be used to create composable applications—apps that pull together "parts" from various locations to compose an aggregate to present to the user. One of the key concepts in MEF is that of the catalog, which tells MEF where to look for parts that make up an application. An application can import parts from the catalog with [Import] attributes, and parts themselves can use [Export] attributes to expose themselves to importers. That's the big picture, and of course it ignores hundreds of little details, but understanding these core concepts is a big help in understanding MEF as a whole.

To demonstrate how Silverlight developers might use MEF in a somewhat real-world scenario, I built a sample application named MEFDemo, which you can download from Wintellect's Web site. MEFDemo is an extensible Silverlight 4 image editor. You load photos into it through an OpenFileDialog, and then you click buttons to apply filters of various types to the photos. Here's MEFDemo showing a photo I snapped in the Vatican a few years ago:

And here's how it looked after I clicked the Blur button a few times and then embossed the image:

Out of the box, MEFDemo offers three image filters: a grayscale filter, a blur filter, and an embossing filter. Because the filters are MEF plug-ins, you can easily write filters of your own and plug them into the application.

One of the filters—the grayscale filter—is embedded in the main application. It's found in GrayscaleFilter.cs and it implements an interface named IImageFilter:

public class GrayscaleFilter : IImageFilter

{

public string Label

{

get { return "Grayscale"; }

}

public void Execute(WriteableBitmap bitmap)

{

...

}

IImageFilter is defined a separate project named ImageFilterContract and is decorated with an [InheritedExport] attribute, which means all types that implement the interface should be exported by MEF:

[InheritedExport]

public interface IImageFilter

{

void Execute(WriteableBitmap bitmap);

string Label { get; }

}

The other two filters are exported from a separate project named ConvolutionFilters. Because the project type is Silverlight Application, not Silverlight Class Library, building the solution places two XAP files in the Web site's ClientBin folder: MEFDemo.xap, which contains the main application, and ConvolutionFilters.xap, which contains BlurFilter and EmbossFilter. These filters, too, implement IImageFilter and are automatically exported from the XAP as a result of the [InheritedExport] attribute.

In MEF terminology, the exported image filters are "parts." Which begs the question: how and where do the parts get imported?

Look in MainPage.xaml.cs and you'll find the following property declaration:

[ImportMany(AllowRecomposition = true)]

public ObservableCollection<IImageFilter> Filters { get; set; }

The [ImportMany] attribute tells MEF to look for all exported parts that implement IImageFilter and to populate the ObservableCollection with references to those parts. In MainPage's constructor, a single line of code binds the ObservableCollection to an ItemsControl to produce buttons representing the imported image filters. The ItemsControl uses the following item template to create the buttons:

<ItemsControl.ItemTemplate>

<Button Content="{Binding Label}" Width="96" Height="32"

Margin="0,12,12,12" Tag="{Binding}" Click="OnExecuteFilter" />

</DataTemplate>

</ItemsControl.ItemTemplate>

The text on the face of each button comes from the associated image filter's Label property, and the Tag property holds an IImageFilter reference to the filter itself. When a button is clicked, it's a simple matter to retrieve the IImageFilter reference and use it to invoke the filter:

IImageFilter filter = (sender as Button).Tag as IImageFilter;

filter.Execute(_bitmap);

With MEF, we can export parts and we can import parts. But how does MEF know where to look for parts to satisfy our imports? The answer is found in MainPage's constructor:

// Create a catalog and add this XAP to it

PackageCatalog catalog = new PackageCatalog();

catalog.AddPackage(Package.Current);

// Download additional XAPs and add them to the catalog

Package.DownloadPackageAsync(new Uri("ConvolutionFilters.xap", UriKind.Relative),

(s, p) => catalog.AddPackage(p));

// Pass the catalog to the MEF and compose the parts

var container = new CompositionContainer(catalog);

container.ComposeParts(this);

The first line creates a package catalog. The second line adds the current package (MEFDemo.xap) to the catalog, which allows MEF to find the GrayscaleFilter class exported from MEFDemo.xap. The third line initiates an asynchronous download of ConvolutionFilters.xap and adds it to the catalog when the download completes. This allows MEF to find the BlurFilter and EmbossFilter classes in that XAP. Adding image filters to the application is as simple as placing additional XAP files containing the filters in ClientBin and adding one line of code per XAP to download the package and add it to the catalog. Once filters are exported and added to the catalog, buttons representing them will automatically show up in the UI.

This example demonstrates the basics of MEF, but it could go even further. For example, MEF allows you to attach metadata to parts, and to read that metadata without instantiating the parts. Rather than use a Label property to expose text for buttons, image filters could use metadata instead. Glenn Block of Microsoft discusses metadata and lazy loading of imported types in Building Hello MEF Part II. Glenn's blog is a great source of information on MEF, as is Jeremy Likness's blog, which is currently exploring the integration of MEF and Prism. In addition, Mike Taulty has posted a great series of video tutorials on Silverlight MEF on Channel 9.

MEF makes composability a first-class citizen in Silverlight, and it's going to be interesting to see how much of an impact it has on Silverlight design and development. One thing's for sure: there has never been a more exciting time to be a Silverlight programmer!

PRISM, MEF, and MVVM Part 3 of 3: Dynamic MEF Modules in PRISM

C#er : IMage — Sun, 03 Jan 2010 08:08:03 GMT

Series recap: PRISM, MEF, and MVVM Part 1 of 3: Unity Glue PRISM, MEF, and MVVM Part 2 of 3: Making PRISM MEF Friendly PRISM, MEF, and MVVM Part 3 of 3: Dynamic MEF Modules in PRISM In the final part of this series, I will show a dynamically loaded module (using PRISM) that takes full advantage of MEF. Here is a preview of the final product, illustrating the different modules and areas I have pulled together to demonstrate (click for a full resolution view): Download the Source for this Example Why...(read more)

PRISM, MEF, and MVVM Part 2 of 3: Making PRISM MEF Friendly

C#er : IMage — Wed, 30 Dec 2009 06:46:00 GMT

In the first part of this series, we explored using the Unity container to bind the view model to the view. The next logical step is to explore how to use MEF. PRISM provides several useful mechanisms that relate directly to views and modules, such as the region manager and the module manager. This allows us to dynamically assign views to regions on the display and dynamically load modules. Logically, it seems we could create a MEF module, dynamically load it through PRISM, and glue its parts together...(read more)

Silverlight 4's New HTML Hosting Support

jprosise — Tue, 22 Dec 2009 17:12:00 GMT

Another of the new capabilities that Silverlight 4 brings to the platform is the ability to host HTML content inside a Silverlight control. This support isn't limited to static HTML content; the content can be interactive and can include script. It can even be Flash content or content that includes other Silverlight controls.

To host HTML content in Silverlight, you can use either a WebBrowser control or an HtmlBrush. One way to display HTML content is to fire up a WebBrowser control and point it to a URL:

Another way to do it is to call NavigateToString and pass a string of content to the WebBrowser control:

WebBrowserControl.NavigateToString("<h1>Hello, Silverlight</h1>");

HTML hosting is not available to in-browser apps (it applies to out-of-browser applications only), and if an OOB lacks elevated permissions, it can only display content that comes from the same domain as the Silverlight application. However, you can use a little trick to display cross-domain content in OOBs that run without elevated permissions—simply pass an IFRAME targeting the remote content to NavigateToString:

WebBrowserControl.NavigateToString("<iframe src=\"http://www.bing.com\" style=\"width: 100%; height: 100%\"></iframe>");

You can render HTML content with HtmlBrush, too. The following XAML snippet paints a Rectangle with content retrieved from Bing:

<Rectangle.Fill>

</Rectangle.Fill>

</Rectangle>

One difference between WebBrowser and HtmlBrush is that the former displays "live" content, while the latter does not. Another difference is that HtmlBrush can have transforms applied to it, while WebBrowser cannot. For snazzy visual effects involving HTML content like the HTML puzzle demoed at the PDC, you'll probably find yourself using HtmlBrush. To display live, interactive content, you'll find WebBrowser more useful instead.

One of the really cool things about the WebBrowser control is that you can use its InvokeScript method to call JavaScript functions in content hosted by the control. Conversely, JavaScript hosted inside a WebBrowser control can use window.external.Notify to raise ScriptNotify events that can be handled in C#.

To demonstrate why this might be useful (and how it works), I built a sample application that plays YouTube video using YouTube's API player and that uses the player's JavaScript API to drive the video playback from C#. The application runs as an OOB and requires elevated permissions:

The video that plays in the application is one I uploaded to YouTube; it shows one of my RC jets getting a workout at a recent jet meet near Atlanta, GA. You can download the app and install it on your PC to try it out. Don't forget that it has to run outside the browser.

The application uses a WebBrowser control to host the YouTube player. The content is stored in a text file packaged as a loose file inside the XAP file. It's extracted from the XAP with Application.GetResourceStream and passed to the WebBrowser control via NavigateToString:

// Read the HTML content from the XAP

StreamResourceInfo sri = Application.GetResourceStream

(new Uri("YouTubePlayer.txt", UriKind.Relative));

StreamReader reader = new StreamReader(sri.Stream);

string content = reader.ReadToEnd();

// Feed the content to the WebBrowser control

Player.NavigateToString(content);

The content itself includes a mix of HTML and JavaScript (mostly JavaScript). The script instantiates the YouTube player, forwards certain events from the player to the application so they can be handled in C#, and provides a thin JavaScript API layer that the application calls via InvokeScript to control playback of the video. For example, when the user clicks the Play, Pause, and Stop buttons, the application uses InvokeScript to call script funtions named play, pause, stop, and cue:

private void OnPlay(object sender, RoutedEventArgs e)

{

Player.InvokeScript("play");

}

private void OnPause(object sender, RoutedEventArgs e)

{

Player.InvokeScript("pause");

}

private void OnStop(object sender, RoutedEventArgs e)

{

Player.InvokeScript("stop");

Player.InvokeScript("cue", "df6x4U0u7iQ");

}

Similarly, when the state of the player changes—for example, when video playback begins or ends—script inside the control uses window.external.Notify to fire a ScriptNotify event in C# and activate a handler that updates the visual states of the buttons:

function onYouTubePlayerStateChange(state) {

// Ask the Silverlight control to update the YouTube video player

var state = document.getElementById("apiplayer").getPlayerState();

window.external.Notify('Update:' + state.toString());

}

The end result is an application that demonstrates key features of the WebBrowser control and does something interesting, too. Merry Christmas and Happy Holidays!

Receiving notifications when garbage collections occur

JeffreyR — Tue, 22 Dec 2009 03:58:00 GMT

While creating the 3rd Edition of my CLR via C# book (http://www.amazon.com/CLR-via-C-Third-Pro-Developer/dp/0735627045/ref=dp_ob_title_bk), I came up with a cool little class that will raise an event after a collection of Generation 0 or Generation 2 occurs. Here is the code for the class:

public static class GCNotification {
   private static Action<Int32> s_gcDone = null; // The event’s field
   public static event Action<Int32> GCDone {
      add {
         // If there were no registered delegates before, start reporting notifications now
         if (s_gcDone == null) { new GenObject(0); new GenObject(2); }
         s_gcDone += value;
      }
      remove { s_gcDone -= value; }
   }
   private sealed class GenObject {
      private Int32 m_generation;
      public GenObject(Int32 generation) { m_generation = generation; }
      ~GenObject() { // This is the Finalize method
         // If this object is in the generation we want (or higher),
         // notify the delegates that a GC just completed
         if (GC.GetGeneration(this) >= m_generation) {
            Action<Int32> temp = Interlocked.CompareExchange(ref s_gcDone, null, null);
            if (temp != null) temp(m_generation);
         }
         // Keep reporting notifications if there is at least one delegate
         // registered, the AppDomain isn't unloading, and the process
         // isn’t shutting down
         if ((s_gcDone != null) &&
            !AppDomain.CurrentDomain.IsFinalizingForUnload() &&
            !Environment.HasShutdownStarted) {
            // For Gen 0, create a new object; for Gen 2, resurrect the
            // object & let the GC call Finalize again the next time Gen 2 is GC'd
            if (m_generation == 0) new GenObject(0);
            else GC.ReRegisterForFinalize(this);
         } else { /* Let the objects go away */ }
      }
   }
}

And here is some code to see it in action:

public static void Main() {
   GCNotification.GCDone += g => Console.Beep(g == 0 ? 800 : 8000, 200);
   var l = new List<Object>();
   // Construct a lot of 100-byte objects.
   for (Int32 x = 0; x < 1000000; x++) {
      Console.WriteLine(x);
      Byte[] b = new Byte[100];
      l.Add(b);
   }
}

This gives you a very small taste of what you should expect to see in the next edition of my book. Hope you enjoy.

PRISM, MEF and MVVM Part 1 of 3: Unity Glue

C#er : IMage — Tue, 22 Dec 2009 03:15:00 GMT

PRISM, also known as Composite WPF , has established itself as a very popular framework for building modular, scalable Silverlight applications. A newer contender, the Managed Extensibility Framework (MEF) , has also grown in popularity. In fact, these two frameworks have left people scratching their heads wondering which one to use, when, how, and why. Download the source code for this project. Special note: the source won't run "as is." You need to take two steps: first, right click the PRISMMEF.Web...(read more)

Silverlight's Big Image Problem (and What You Can Do About It)

jprosise — Thu, 17 Dec 2009 17:46:00 GMT

Quick: Can you spot the problem with these three lines of code?

BitmapImage bi = new BitmapImage();

bi.SetSource(stream);

TheImage.Source = bi;

These statements create an image from a stream of PNG or JPG image bits and display the image by assigning it to a XAML Image object named TheImage. It's boilerplate code used to display images read from the local file system or obtained from a service. And while there's nothing inherently wrong with the code itself, you'll want to think carefully before including it in any Silverlight application.

I call it "Silverlight's Big Image Problem." Not the kind of image problem a movie star might suffer, but an inherent memory-consumption problem when dealing with large bitmap images in Silverlight.

The problem manifests itself when you handle large images in large numbers. The My Pictures Viewer that I blogged about yesterday is a case in point. When a user running the application selects a folder containing one or more image files, the viewer displays clickable thumbnail versions of the images. The problem is that because Silverlight's BitmapImage class consumes massive amounts of memory (up to 40 or 50 MB per image for a typical 2 to 3 MB digital photo), you simply can't have too many instances extant at once. But to create a thumbnail, you first need a BitmapImage that wraps the entire image. You might create a thumbnail by assigning the BitmapImage to an Image object that measures just 100 by 100 pixels, but if the original image measures 4,000 by 4,000 pixels, it's the latter figure you pay the price for.

To demonstrate, I wrote a simple test harness that you can easily duplicate yourself. I began with an app that pops up an OpenFileDialog and lets the user select an image file from his or her hard disk. Once the image file is selected, the application generates a thumbnail version of the image and adds it to the scene. Then it generates another thumbnail, and then another, and so on and so forth until Silverlight throws an out-of-memory exception. Here is the helper method that I initially used to generate the thumbnails:

private Image CreateThumbnailImage(Stream stream, int width)

{

BitmapImage bi = new BitmapImage();

bi.SetSource(stream);

double cx = width;

double cy = bi.PixelHeight * (cx / bi.PixelWidth);

Image image = new Image();

image.Width = cx;

image.Height = cy;

image.Source = bi;

return image;

}

And here's what happened when I ran the application and selected a 3,648 x 2,736 JPG with a file size of 2.1 MB:

So get this. The application created 26 thumbnails, each measuring a mere 100 x 75 pixels. But attempting to create a 27th thumbnail produced an out-of-memory exception. When the exception occurred, Task Manager showed that the process's working set size had grown from 30 MB to nearly 1.5 GB! It seems crazy on the surface, because a full-color 100 x 75 image should only require about 30K of memory. But it makes a lot more sense when you realize that underlying each thumbnail is a gigantic BitmapImage that retains the full fidelity of the 3,648 x 2,736 original.

The obvious question is what do you do about it? Is there a way to efficiently create thumbnail images from streams of image bits in Silverlight? It's a question that pops up time and again in discussion forums and on message boards. And the short answer is yes, there is a way. But the answer probably isn't the one you expect.

Developers commonly attempt a solution along these lines:

private Image CreateThumbnailImage(Stream stream, int width)

{

BitmapImage bi = new BitmapImage();

bi.SetSource(stream);

double cx = width;

double cy = bi.PixelHeight * (cx / bi.PixelWidth);

Image image = new Image();

image.Source = bi;

WriteableBitmap wb = new WriteableBitmap((int)cx, (int)cy);

ScaleTransform transform = new ScaleTransform();

transform.ScaleX = cx / bi.PixelWidth;

transform.ScaleY = cy / bi.PixelHeight;

wb.Render(image, transform);

wb.Invalidate();

Image thumbnail = new Image();

thumbnail.Width = cx;

thumbnail.Height = cy;

thumbnail.Source = wb;

return thumbnail;

}

The basic idea is that instead of creating a thumbnail by assigning a large BitmapImage to a small Image, you use WriteableBitmap.Render with a ScaleTransform to create a thumbnail, and then assign the WriteableBitmap to an Image. Meanwhile, the BitmapImage and the Image it was temporarily assigned to—the one passed to WriteableBitmap.Render—go out of scope and are eventually picked up by the garbage collector.

It works well in theory, but not so well in practice, thanks to an undocumented behavior of WriteableBitmap. In fact, when I plugged the revised CreateThumbnailImage method into my test harness, the application ran out of memory just as quickly as before.

The problem, it turns out, is that when you call WriteableBitmap.Render, WriteableBitmap apparently retains a reference to the XAML object passed in the first parameter. (I was stumped, too, until Jeffrey Richter and I did a little detective work and discovered what was happening under the hood. Jeffrey's my go-to guy for CLR issues, and I'm not sure I would have ever figured this out without him asking the right questions and suggesting solutions.) When CreateThumbnailImage returns an Image holding a reference to a WriteableBitmap, and the WriteableBitmap holds a reference to an Image, and the Image holds a reference to a BitmapImage, none of these objects gets garbage-collected. It seems that WriteableBitmap does nothing to solve the problem, especially given that there's no public method or property you can use to force the WriteableBitmap to release the reference.

But all is not lost. You can make a copy of the WriteableBitmap and assign it to the Image you return. And since you didn't call Render on the copy, it doesn't hold a reference to an Image that prevents the garbage collector from cleaning up the BitmapImage. Here is the fixed and final version of CreateThumbnailImage—this time, one that accomplishes what we set out to do:

private Image CreateThumbnailImage(Stream stream, int width)

{

BitmapImage bi = new BitmapImage();

bi.SetSource(stream);

double cx = width;

double cy = bi.PixelHeight * (cx / bi.PixelWidth);

Image image = new Image();

image.Source = bi;

WriteableBitmap wb1 = new WriteableBitmap((int)cx, (int)cy);

ScaleTransform transform = new ScaleTransform();

transform.ScaleX = cx / bi.PixelWidth;

transform.ScaleY = cy / bi.PixelHeight;

wb1.Render(image, transform);

wb1.Invalidate();

WriteableBitmap wb2 = new WriteableBitmap((int)cx, (int)cy);

for (int i = 0; i < wb2.Pixels.Length; i++)

wb2.Pixels[i] = wb1.Pixels[i];

wb2.Invalidate();

Image thumbnail = new Image();

thumbnail.Width = cx;

thumbnail.Height = cy;

thumbnail.Source = wb2;

return thumbnail;

}

When I plugged this implementation into my test harness, it successfully created hundreds of thumbnails (and could have created hundreds, perhaps thousands, more) without significantly increasing the working set size—and without throwing out-of-memory exceptions.

The moral is that you should be very careful about how you use BitmapImage in Silverlight. Even one of them can swell the working set size dramatically, but a couple dozen of them wrapping digital photographs is more than most PCs can handle. With a little care, however, you can scale down the impact of BitmapImage so that memory consumption is proportional to the sizes of the images you're displaying rather than the sizes of the original, unreduced images. And that, in the end, is a handy arrow to have in your arsenal.