Jim O'Neil's Blog : Silverlight

Discovering Dallas: Part 3

joneil — Mon, 21 Dec 2009 11:17:00 GMT

This is the final post of a trifecta examining Microsoft “Dallas”, a marketplace for data services announced at PDC 2009. In my first post, I provided an overview of “Dallas”, including how to access various trial data services via the developer portal and in code.

I followed that up last week with a post that walks through modifying the auto-generated C# service proxy classes to provide asynchronous invocation capabilities, a must have for Silverlight client access and, in general, a good way to go to keep your application UI responsive in the face of slow or unpredictable network performance.

For this article, I’m going to leverage the code changes I made in the last article (to enable asynchronous access) to build a Silverlight application that accesses the same Data.gov crime statistics that the previous Windows Forms application did. As I mentioned in that post, Silverlight has two primary constraints in terms of accessing resources and services over the web:

Access must be asynchronous, and
Resources must be accessed from the point-of-origin of the Silverlight application (although there are options we’ll discuss next for working around this).

Handling Cross-Domain Access

Asynchronous access was addressed in the last post, so now we need to deal with enabling Silverlight applications downloaded from my web host to access services hosted on “Dallas”, namely the api.sqlazureservices.com domain. With Silverlight there are two ways to handle this:

Use a proxy; that is, set up a service hosted on the same domain as my Silverlight application that acts as a go-between to the “Dallas” service. The Silverlight application is talking to a service that’s at its point-of-origin, and that service is a simple client to the ultimate service hosted by “Dallas.” Although it forces an extra hop in the communication chain, it’s a fairly common pattern for handling the ‘point-of-origin’ constraint.
Set up a policy file on the service host, here api.sqlazureservices.com. Before attempting to access a non point-of-origin service, a Silverlight application will check to see if the targeted server has a clientaccesspolicy.xml file at the root of its domain. This file is an XML document containing information on what clients are allowed access to the server and what resources on the server they can access. If a clientaccesspolicy.xml file is not found, Silverlight will then look for a crossdomain.xml file, which is an XML file used for similar purposes by Adobe Flash applications.

“Dallas” has just recently setup up a clientaccesspolicy.xml file (below) to permit Silverlight application access, so that’s the route I’m going to pursue here. The complete format of the file is described in the MSDN documentation, but the salient features required for “Dallas” include:

Line 5 – specification of the request headers that are sent by the client. If the client includes headers not specified here, the request is rejected. The headers sent are, of course, the $accountKey and the $uniqueUserID.
Lines 6-7 – specification of the client URLs allowed access. Since “Dallas” is accessible only via HTTPS, the domain tags are necessary to enable a Silverlight application downloaded via HTTP to access the “Dallas” server.
Line 10 – specification of which resources (URIs) the client can access on the “Dallas” server; here, it’s everything below the domain root.

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <access-policy>

   3:    <cross-domain-access>

   4:       <policy>

   5:          <allow-from http-request-headers="$accountKey,$uniqueUserID">

   6:             <domain uri="http://*" />

   7:             <domain uri="https://*" />

   8:          </allow-from>

   9:          <grant-to>

  10:             <resource path="/" include-subpaths="true" />

  11:          </grant-to>

  12:      </policy>

  13:    </cross-domain-access>

  14: </access-policy>

A Few More Tweaks

At this point, you’d figure it would just work; we’ve got code to make an asynchronous call, and the cross-domain access issue is resolved via the policy file, right? Well, not quite.

Silverlight runs on the CLR, but it’s a subset of the full-blown .NET CLR (one that fits within a 5MB or so download). When I built the asynchronous invocation code in the previous post, I did so for a Windows Forms application, and when pulling that same code into my Silverlight application, I ended up with a few compilation issues.

In the code that converts the XML (Atom format) response stream into the data transfer object class (DataGovCrimeByCitiesItem), the static method Convert.ChangeType is frequently invoked. In Silverlight, that method has fewer overloads than in the full .NET Framework, so I had to add a final parameter value (null) to each of the calls. That parameter is a IFormatProvider, which in this case is inconsequential since we are not presenting the data in this step.

Now, that same issue exists in the auto-generated code for the synchronous invocation as well (along with some additional issues). In Silverlight though, the synchronous invocation is not an option, so you’ll need to comment out or otherwise remove the Invoke and InvokeWebService methods that are part of the C# code generated when you select the Download C# service classes… option on the “Dallas” Developer Portal.
The code that assigned the $accountKey and $uniqueUserID to the HTTP Request header looks like this in my first attempt:

request.Headers.Add("$accountKey",this.AccountKey);

request.Headers.Add("$uniqueUserID", 
                                this.UniqueUserID.ToString());

Unfortunately, Silverlight does not support the Add method on a WebHeaderCollection, but the remedy is rather simple:
request.Headers["$accountKey"] = this.AccountKey;
request.Headers["$uniqueUserID"] = this.UniqueUserID.ToString();

With that, the code compiles just fine, but at runtime you’ll get a System.NotSupportedException with the less than helpful message that “Specified method is not supported” and pointing to the line:

HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(ar);

Using the Silverlight Client stack

Well, certainly EndGetResponse is supported in Silverlight – after all MSDN says so, and it would be tough to make asynchronous calls (the only type allowed) if it weren’t. What’s happening here is that restrictions in the browser HTTP stack, which Silverlight leverages by default, prevents the call from succeeding. The reason is somewhat buried in the MSDN documentation:

You can send headers, if they are allowed per the client access policy file, by setting the HttpWebRequest.Headers property. If you are sending headers on anything other than POST requests, you must use Client HTTP handling.

While we took care of the client access policy file, the existing code to create the request

HttpWebRequest request =

    (HttpWebRequest) HttpWebRequest.Create(new Uri(builder.ToString()));

request.Headers["$accountKey"] = this.AccountKey;

request.Headers["$uniqueUserID"] = this.UniqueUserID.ToString();

defaults to browser HTTP handling, and since the default HTTP verb here is a GET and we’re setting headers to pass in the $accountKey and $uniqueUserID, we’re doomed to failure.

You might be inclined to change the request type to a POST via the request.Method property, but that will result in an HTTP 405 (Method not allowed) error since the “Dallas” service is not configured to accept POST requests. That leads to the only other option here, using Client HTTP handling.

Client HTTP handling was introduced with Silverlight 3 and provides additional HTTP support over the default browser handling, including REST service calls, use of HTTP verbs other than GET and POST, and support for additional status codes. To opt in to client HTTP handling, you create the WebRequest using the ClientHttp property of the WebRequestCreator static class, so the HttpWebRequest instantiation code directly above would be modified to

HttpWebRequest request = (HttpWebRequest)

    System.Net.Browser.WebRequestCreator.ClientHttp.Create(

        new Uri(builder.ToString()));

With that last change, the Silverlight example executes successfully:

Code Reuse

With the modification of the code above to use the Silverlight Client HTTP stack, I’ve now complicated my code base. The non-Silverlight scenarios (WPF, Windows Forms, etc.) can’t use this code – they won’t even compile – because the System.Net.Browser namespace is Silverlight only. As a result I need two different calls to instantiate the request depending on the runtime context of the application.

One option to resolve this is compiler directives, where the HttpWebRequest creation depends on the compilation environment. This works fine for Silverlight 3 since Silverlight and non-Silverlight assemblies are not binary compatible – meaning you need to recompile the code anyway.

#if SILVERLIGHT

    HttpWebRequest request = (HttpWebRequest)

        System.Net.Browser.WebRequestCreator.ClientHttp.Create(

            new Uri(builder.ToString()));

#else

    HttpWebRequest request = (HttpWebRequest)

        WebRequest.Create(new Uri(builder.ToString()));

#endif

In Silverlight 4 though, Microsoft announced binary compatibility of Silverlight with non-Silverlight assemblies, so the compiler directive isn’t as attractive a feature.

Other alternatives exist though, such as using the WebRequest.RegisterPrefix method to map some or all Silverlight requests to the Client HTTP stack. This initialization need be made only once (say in the constructor of the service class) and then the WebRequest.Create code will automatically use the Client versus the Browser HTTP stack. Then, there’s no longer a need for the compiler directive in the code above (although a similar scenario arises when calling RegisterPrefix).

You could probably obviate the use of the compiler directive using reflection too. Additionally, Dependency Injection (say using Unity) is perhaps a more elegant option, but certainly adds more complexity to the application. Given that “Dallas” is still a work in progress, and it’s likely that the release version will have a more robust implementation for the service classes, I’ll resist the temptation to over-engineer and leave it to the real developers in Redmond to work it all out for the public release!

Sample Code

I’ve posted the code discussed above, along with the updated version of the Windows Forms example that uses the same service class implementation. Of course, to run it you’ll still need to get your own Dallas token.

PDC: Pretty Darn Cool!

joneil — Sat, 21 Nov 2009 18:18:00 GMT

I got back from PDC yesterday and have managed to (mostly) make up for my sleep deficit. Undoubtedly you’ve heard by now some of the major announcements at the conference (including the free multi-touch laptop that all the paying attendees received!):

Silverlight 4

Windows Azure availability

“Dallas”

Office 2010 Beta

If you haven’t already, be sure to listen to the two keynotes (Day 1 and Day 2) to see how far things have come since PDC 08 (as well as where we’re headed). The sessions are also available on demand, so you can experience all of the content from the comfort of your own living room as well!

See the (Silver)Light

joneil — Fri, 10 Jul 2009 20:30:00 GMT

Today marks the release-to-web (RTW) of Silverlight 3 as well as the release candidate of Expression Blend 3.

You’ve heard of the cool and innovative new features and maybe even caught our recent Roadshow where Chris demonstrated many of them – smooth streaming, SketchFlow, out-of-browser applications, communications between Silverlight applications, and more.

Now follow the launch activities or check out the links below for more information on how to take your applications to the next level!

Silverlight blog

Expression newsletter

Summer of Silverlight – Win $10K

joneil — Tue, 07 Jul 2009 17:00:00 GMT

I missed the mark on this one, but thanks to a recent posting from Dino Esposito, I just became aware of ComponentArt’s 2009 Summer Silverlight Coding Competition.

The best application (as selected by the panel and community votes) will win $10,000, and two-runners up will receive ComponentArt licenses. Use of ComponentArt products is NOT required. Applications will start appearing for community voting today, but you have through September 22 to submit your entries.

Awesome WPF/Silverlight Guidance

joneil — Fri, 12 Jun 2009 21:38:45 GMT

I don’t casually throw around words like ‘awesome', but this is indeed it. If you’re building applications for WPF and/or Silverlight, you’ve certainly become XAMLized, since XAML (eXtensible Markup Language) is the “common” user-interface description markup. Well, more-or-less “common”. Both technologies use XAML, but the level of support has subtle nuances, and things that are supported on WPF may not be supported on Silverlight (though 99% of Silverlight is supported by WPF). It’s not always obvious what the nuances are, and like me, you may have discovered them empirically – and uttered a few words of frustration not printable here.

The good news is that WPF and Silverlight are aligning, so “we feel your pain,” and the development process and support will continue to converge. Until we reach that nirvana though, the WPF-Silverlight Comparison Whitepaper is a MUST read for anyone embarking on (or currently developing) WPF and Silverlight applications. It’s a comprehensive 69-page document on just those nuances between the technologies that we prefer to know about before designing and coding – versus after!

The document was produced by our friends at Wintellect at the behest of Microsoft, and is, well, an awesome reference for developers in this space.

Atta Boy, Andy

joneil — Fri, 29 May 2009 07:31:30 GMT

Congrats to the Northeast’s own Andy Beaulieu (MVP and leader of the Central New York .NET Developer Group) for winning the ServerQuest II Silverlight game competition, with his entry Boss Launch

And from the “great timing department”, my colleague, Glen Gordon, and I had the privilege of chatting with Andy just yesterday about Silverlight gaming on GeekSpeak; you can download the recorded session here.

You can check out other bits of Andy’s work at http://www.spritehand.com… but don’t let the boss catch you!

NERD to Host XAML Fest - May 27th - 28th

joneil — Tue, 12 May 2009 01:04:53 GMT

My colleague, John Pelak, is bringing another edition of the XAML Fest series to the Boston area, this time to Microsoft’s New England Research and Development Center (aka NERD) in Cambridge. The past several sessions in this area filled to capacity quickly, and like those sessions we’re limiting attendance to provide an effective hands-on learning experience… in other words, don’t delay in signing up!

By the way, this is revamped content in light of announcements at MIX 09, so content now includes Expression Blend 3, Silverlight 3, and other cool features that were announced in March. John has all the details, agenda, and a FAQ at his blog post, but here are the particulars on registration and venue.

Date:	Wed. May 27 and Thur. 28, 2009
Time:	9 a.m. – 5 p.m.
Place:	Microsoft NERD 1 Memorial Drive Cambridge, MA
Cost:	Free (vouchers available for on-site parking)
Register:	e-mail xamlfest-boston@live.com (include name and e-mail of attendees)

If you can’t make the live edition, then you’re still in luck. XAMLFest online, a combination of live and recorded content, hits the airwaves from June 1st through the 5th. You can read more about the scheduling and registration here.

RIA = Developer + Designer

joneil — Mon, 20 Apr 2009 23:39:08 GMT

That’s an equation you’ll typically hear us evangelists espouse, with XAML (eXtensible Application Markup Language) being the lingua franca of the developer/designer relationship, and Visual Studio and Expression Studio the tools of choice. It’s a compelling story and one that’s easy to talk about, but face it, in my role, I mostly talk-the-talk, and it’s you guys that have to walk-the-walk.

Well, if anyone walks-the-walk, it’s Cynergy Systems, whose hallmark is RIA, whether it be with WPF and Silverlight or those other guys. A recent Forrester Research Case Study profiles Cynergy’s roots and approach to building software in this emerging space.

In a pretty amazing move, Cynergy announced it is providing the seven-page report free to the community (details in Dave Wolf’s blog post). It’s a great read, and technology-agnostic, so focuses on how to approach developing RIA solutions versus the specific tools and technologies that you might employ to deliver them.

Silverlight 3 Emerges from the Shadows

joneil — Wed, 18 Mar 2009 20:10:00 GMT

Scott Guthrie gave a bit of a teaser in a blog post last November, but today Silverlight 3 is a significant step closer to reality through the official announcement of a beta release at MIX 09 in Las Vegas. Coinciding with the beta is the availability of a preview of Expression Blend 3.

So what’s coming down the pike in Silverlight 3? Well, the big news is the availability of Silverlight outside of the browser. This means you’ll be able to deploy Silverlight applications to the desktop without need for an additional runtime or download. Add to that over 50 new features and productivity improvements, including

Support for H.264 video and AAC audio playback
Perspective 3D – Via an extension of the 2D API already in Silverlight 2, you’ll now be able to add perspective to your visual presentations to provide a near-3D experience.
Built-in and custom shader effects – As in WPF, you’ll be able to provide effects like blur and drop-shadow as well as custom effects that utilize Microsoft’s High Level Shader Language (HLSL).
GPU acceleration – Through caching of the visual tree as a bitmap, Silverlight 3 will be able to make better use of the GPU for certain effects, thus freeing up the CPU for other work.
Element name binding – This brings the binding model of Silverlight more in line with that of WPF by allowing the property of one UI element to be bound to the property of another.
Styling improvements – With Silverlight 3 you can now build styles that are based on other styles as well as reset styles at runtime (both are options that are also available now in WPF).
Binding validation – With Silverlight 3, validation is now available in two-way binding scenarios for data entered via the UI before it is transmitted to the binding source. As in WPF, UI validation templates will also be provided.
Multi-select list box – This control is but one of 60+ fully customizable controls available across nine professionally designed themes (complete with source code to use as is or modify to your heart’s content).
Application library caching – Framework assemblies are cached on the client and reused across application invocations or instances, thus improving performance and reducing the collective application footprint.
Local connections – Silverlight applications running on the client can communicate with each other without requiring a server round-trip.

That’s just a quick-and-dirty list, there’s definitely more, including extensible logging, more options for From-To animations (like spring and bounce), deep linking, improved text rendering and font support, and a File Save dialog.

By the way, the NCAA has chosen Silverlight 2 to provide the high quality, on-demand coverage for March Madness. And you don’t have to wait until tomorrow – there’s some historical highlights as well, including Laettner’s amazing last second shot in the 1992 East regional final versus Kentucky… not that I’m a Dukie or anything!

Get into the MIX09

joneil — Wed, 04 Mar 2009 18:43:37 GMT

It’s exactly two weeks until MIX09, and here’s the scene from my home office window juxtaposed with one of the MIX09 venue. Vegas is looking pretty good, huh?

Weather aside, there’s a lot of other great things in store at this year’s edition of *the* conference focused on next generation web, rich internet applications, and the collaboration between developers and designers.

There’s nearly 30 sessions on Silverlight alone, including not one, not two, but three on what’s in store with Silverlight 3. There’s quite a few on ASP.NET MVC as well (for which RC2 was made available last night). Add to that Azure, Live Services, UI/UX, and you’ve got about 10 dozen sessions to choose from.

Check out the MIX09 site and schedule your ~~vacation~~ training now! And if you can’t be there, join Chris, Bob, and me on the Northeast Roadshow. We’ll actually be in Hartford and Augusta while MIX is going on.

I is for… Isolated Storage

joneil — Mon, 02 Mar 2009 08:00:00 GMT

Isolated storage is a pretty nifty concept that’s actually been part of the .NET Framework since version 1.1 but is getting a bit more attention these days with the adoption of Silverlight and the desire to leverage the client machine for a better user experience. Since Silverlight is a browser-based technology, you can’t just do things like access the file system, because that would break the “sandbox” model.

Enter isolated storage. In a nutshell, you can think of it as your own private (well, relatively) virtual file system. An IsolatedStorageFile instance is essentially a container for directories and files associated with the current user and Silverlight application (or, optionally, web site). It’s intended as a way to store small bits of non-vital information associated with the application, like user-preferences.

Note, isolated storage is also part of the full .NET framework (to support Click-Once applications, for instance). The implementation for Silverlight, which is the focus of this post, is a subset of that functionality. Consult the MSDN documentation if you want more insight into capabilities of isolated storage on the full .NET Framework. Documentation on the Silverlight-specific implementation of isolated storage can be found on MSDN here.

Here are some of the key characteristics of isolated storage:

It’s managed by the .NET runtime. You don’t specify where the isolated file store is stored on the disk; the runtime handles it, but it is part of the file system, typically under the AppData folder of your user profile, and so is discoverable. Hence, you don’t want use isolated storage for information that is required for your application to operate or thast contains sensitive information.

There’s a 1MB default limit, although this can be increased if the client allows it. See how here.

Storage is always associated with a particular user, and an application run by one user cannot access another’s storage. A given user, however, can be outfitted with unique isolated storage instances for each application (GetUserStoreForApplication) and a separate store shared by all applications served from a given site (GetUserStoreForSite).

Unlike the browser cache, isolated storage is persistent. The application can delete files or directories via methods of IsolatedStorageFile, and of course, the storage file could be removed by the user directly, via File Explorer for instance.

You can use streams and serialization techniques to read and write data just as you do for a conventional file system.

Let’s work through a (contrived) sample, and you’ll get an idea of how easy it really is. I have a Silverlight application with two buttons which change the foreground color and background color respectively. Here’s a ‘before-and-after’ picture.

The code for this application is pretty simple:

public partial class Page : UserControl

    public Page()

        InitializeComponent();

        cbBackground.Click += new RoutedEventHandler(cbBackground_Click);

        cbForeground.Click += new RoutedEventHandler(cbForeground_Click);

    void cbForeground_Click(object sender, RoutedEventArgs e)

        txtHello.Foreground = new SolidColorBrush(GetRandomColor());

    void cbBackground_Click(object sender, RoutedEventArgs e)

        gridLayout.Background = new SolidColorBrush(GetRandomColor());

    private Color GetRandomColor()

        Random r = new Random((int)System.DateTime.Now.Ticks);

        Color c = new Color();

        c.A = 255;

        c.R = (byte)r.Next(255);

        c.G = (byte)r.Next(255);

        c.B = (byte)r.Next(255);

        return c;

The default experience is black text and a white background, but I want repeat visitors to retain their last set of color choices when they re-launch the application.

To save the color choices, I’ll make use of isolated storage. In the ‘real’ world, I’d probably use XML serialization to save my preferences, but here I’m taking the easy way out, and will store the colors as two hex strings representing the foreground color and background colors, respectively. For instance, the following contents would indicate opaque red text on a blue background:

    FFFF0000    
    FF0000FF

Reading from Isolated Storage

To the program above, I’ve added some logic to read from the preferences file, colors.txt, in isolated storage. Then I’ve set the foreground and background colors to the values read in (lines 10-12, below):

   1:  public partial class Page : UserControl

   2:  {

   3:      Color foreColor;

   4:      Color backColor;

5:

   6:      public Page()

   7:      {

   8:          InitializeComponent();

9:

  10:          LoadColors(out foreColor, out backColor);

  11:          txtHello.Foreground = new SolidColorBrush(foreColor);

  12:          gridLayout.Background = new SolidColorBrush(backColor);

13:

  14:          cbBackground.Click +=

  15:              new RoutedEventHandler(cbBackground_Click);

  16:          cbForeground.Click +=

  17:              new RoutedEventHandler(cbForeground_Click);

  18:      }

Here’s my implementation of LoadColors.

   1:  public void LoadColors(out Color f, out Color b)

   2:  {

   3:      string foreStr = "00000000";

   4:      string backStr = "FFFFFFFF";

5:

   6:      using (IsolatedStorageFile isf =

   7:                IsolatedStorageFile.GetUserStoreForApplication())

   8:      {

   9:          try

  10:          {

  11:              using (IsolatedStorageFileStream str = isf.OpenFile

  12:                      ("colors.txt", FileMode.Open, FileAccess.Read))

  13:              {

  14:                  StreamReader reader = new StreamReader(str);

  15:                  foreStr = reader.ReadLine();

  16:                  backStr = reader.ReadLine();

  17:                  reader.Close();

  18:              }

  19:          }

  20:          catch (IsolatedStorageException)

  21:          {

  22:              ;

  23:          }

  24:      }

25:

  26:      f = ToColor(foreStr);

  27:      b = ToColor(backStr);

  28:  }

Let’s take a line-by-line look:

3-4: Initialize two color strings to a default, should something go wrong.

6-7: Get the isolated storage associated with this user and this application (defined by the XAP file’s URL). If I wanted to share preferences across a suite of applications on the same host, I could have used GetUserStoreForSite here.

11: Open a file with the name colors.txt in the isolated storage. If the file is not found, an exception will be thrown (and caught in Line 20). There is also a method I could have used to check for file existence instead of letting the exception catch it.

14-17: Use a stream reader to read the two lines of the file.

20: Handle an access exception, including file-not-found. Here, we just let the default colors take over.

26-27: Convert the hex strings to color objects using a simple utility routine (below).

private Color ToColor(string hex)
{
    if (hex == null) return Color.FromArgb(255, 0, 0, 0);

    return Color.FromArgb(
        (byte)(Convert.ToUInt32(hex.Substring(0, 2), 16)),
        (byte)(Convert.ToUInt32(hex.Substring(2, 2), 16)),
        (byte)(Convert.ToUInt32(hex.Substring(4, 2), 16)),
        (byte)(Convert.ToUInt32(hex.Substring(5, 2), 16)));
}

Writing to Isolated Storage

Now, for the other direction: writing modifications to the user preferences to isolated storage. For that I’ve created another method, SaveColors, which is called in each of the two button Click event handlers, after setting the new color to a randomly generated color. The implementation of SaveColors is as follows:

   1:  public void SaveColors(Brush fBrush, Brush bBrush)

   2:  {

   3:      using (IsolatedStorageFile isf =

   4:             IsolatedStorageFile.GetUserStoreForApplication())

   5:      {

   6:              using (FileStream str = isf.OpenFile("colors.txt",

   7:                     FileMode.OpenOrCreate, FileAccess.Write))

   8:              {

   9:                  StreamWriter writer = new StreamWriter(str);

  10:                  writer.WriteLine(

  11:                      FromColor(((SolidColorBrush) fBrush).Color));

  12:                  writer.WriteLine(

  13:                      FromColor(((SolidColorBrush) bBrush).Color));

  14:                  writer.Close();

  15:              }

  16:      }

  17:  }

3-4: Obtain the isolated storage for this user and application.

6-7: Open (or create) the colors.txt file for writing.

10-13: Write the new color strings to the file. FromColor is another utility routine to convert a color to its hex string equivalent. It’s implemented as a single line of code!
private String FromColor(Color c)
{
    return String.Format(
        "{0:x2}{1:x2}{2:x2}{3:x2}", 
        c.A, c.R, c.G, c.B);
}

Managing Isolated Storage Limits

The IsolatedStorageFile class has two properties to return the size of the store (Quota) as well as the available free space (AvailableFreeSpace). With that information you can test whether or not there’s sufficient space for whatever you’re planning to store next.

If there isn’t, you can call the IncreaseQuotaTo method to extend the amount of isolated storage space. There are a few caveats when using this method to be aware of

You can only call this method in response to a user action, like a button Click event; otherwise, as a security precaution, it’s ignored.

You can’t decrease the quota (without removing the store and recreating it).

You will get an exception if you try to increase the quota to a value smaller than the current size; therefore, use the Quota and AvailableFreeSpace properties to check before you ask!

Presuming the request is a valid one, the end user will be presented a dialog like the following:

The boolean return value of IncreaseQuotaTo is determined by the user’s response to this dialog.

You can also see how much isolated storage Silverlight has associated with the current user – across ALL of the Silverllight applications he or she has browsed – by viewing the Application Storage tab on the Silverlight Configuration dialog. You can get to this dialog by right-clicking on any web page currently hosting Silverlight content and selecting the Silverlight Configuration option from the context menu.

A couple of closing thoughts:

1. IsolatedStorageFile has a number of other methods to allow you to create, remove, and check for the existence of files and directories within the store.

2. The IsolatedStorageSettings class is a convenient way to store simple key-value pairs in isolated storage. For the example above, it would have been a very appropriate option (but less interesting to discuss!)

2. You can figure out where the actual file store is by setting a breakpoint in your code after the IsolatedStorageFile reference has been obtained. Look at the value of the RootDirectory property.

When I was running the sample above, here’s what mine was set to:

C:\Users\joneil\AppData\LocalLow\Microsoft\Silverlight\is \23zwbqug.imk\r3q1ieeo.odx\1\s\f2jzlyu1vrz2g5zcgk0moakn1 pdsiwrcpx22ardrblfykpxui4aaahba\f

Prism 2: Now With Silverlight

joneil — Thu, 19 Feb 2009 00:11:01 GMT

Back in the fall on our Northeast Roadshow, I presented on the various User ~~Interface~~ Experience options available for both smart client and browser-based applications. At the end of the discussion, I mentioned the Composite Application Guidance for WPF (also known by its code name of Prism). That body of work, the product of Microsoft’s patterns & practices team, was focused on helping you build enterprise-level, composite client applications, namely focusing on building loosely-coupled, pluggable components that can work together in the overall application.

While many of the ideas and techniques espoused by that guidance transcend WPF itself, there was obviously a “hole” in that Silverlight was not specifically addressed. At the time of my presentation, I mentioned a Silverlight version was ‘in the works’, and today the Composite Application Guidance for WPF and Silverlight 2.0 was announced:

offering insight on building modular and composite Silverlight applications,
simplifying the composition of the user interface, and
providing guidance and light tooling on reusing code between Silverlight and WPF.

I’ve bolded part of the last point because it’s the most compelling piece of this to me. It’s the first official recommendation I’ve seen for the oft-asked question of best practices for delivering WPF and Silverlight experiences from a common code-base. I'm hoping it will help ease some of that “analysis paralysis” that we all have when trying to best leverage a new technology (or in this case TWO new techologies!).

“In the box” (so to speak), you’ll find the following. Enjoy!

Composite Application Library,
Reference Implementation (Stock Traders application in WPF and Silverlight),
Quick starts (9),
How-Tos (26), and
Lots of documentation for everything you want to know about UI patterns and client architectures.

Are You Game to Win $5000?

joneil — Thu, 12 Feb 2009 20:06:43 GMT

Check out this new Silverlight developer competition in which you could pocket $5000 for showcasing your Silverlight skills. The contest rules aren’t that apparent from the site unless you register (or spot the tiny link in the footer), so I’m copying below what you’ll see on the Submit Game page, post-registration. The contest ends April 30th, with winners to be announced on May 25th.

It’s time to submit your finished game to Microsoft. When your game is placed in the gallery, everyone will have a chance to vote on it. The games with the highest amount of votes will be presented to a panel of Celebrity Geek Judges so they can vote on the best game. The winner’s game will be featured in Server Quest 2 and they will receive $5000.

When submitting an entry to the Server Quest 2 Silverlight contest, you must supply an archive (zip file) containing:

The main game XAP file named game.xap in the top level of the archive.

Your game should be formatted to fit a field of 800 px by 430 px.

In addition, you must supply a screenshot of your game, it must be in JPG format and should be sized for 200 px by 150 px.

The contest and its organizers are not responsible for games that are disqualified because of submissions which are of the wrong size, format, or file structure.

For a full list of rules and regulations, click here.

If you need a little help “getting your game on”, here’s a great post from Andy Beaulieu on some resources to get you started.

Silverlight Control Mega-List

joneil — Thu, 29 Jan 2009 03:01:22 GMT

If you’re working on or considering Silverlight for application development, then the sine quibus non of your daily blog reading should include both Tim Heuer and Jesse Liberty.

Tim just posted A Comprehensive List of Silverlight Controls for Developers, an awesome reference post definitely worth filing away, check it out!

I Hereby Resolve To ...

joneil — Sat, 27 Dec 2008 05:23:30 GMT

Having trouble figuring out how to fill in the blanks? Fret no longer; I found this link to a Resolution Randomizer on Brad Abrams's blog, and it's too fun not to forward on. Plus it's a Silverlight application and, therefore, legitimately work-related!