irritatedVowel.com

How to Resize a Silverlight 2 App and Keep the Same Aspect Ratio

Pete.Brown — Sat, 05 Jul 2008 03:28:50 GMT

A similar question just popped up on a list I’m on, so I thought I’d whip up a quick example on how to resize a Silverlight application while keeping the same aspect ratio and centering the content.

The key to resizing is to use a ScaleTransform on the LayoutRoot of your main page. Here’s the important part of the xaml for the page. The key part is the “Grid.RenderTransform” section and the RenderTransformOrigin for the grid. In the latter, 0.5, 0.5 tells the engine that any render transforms should originate in the center of the grid. The former we name “PageScale” to allow us to easily manipulate its ScaleX and ScaleY properties from code.

<UserControl x:Class="PeteBrown.SilverlightScalingExample.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    >
    
    <Grid x:Name="LayoutRoot" 
          Background="Cornsilk" ShowGridLines="True"
          Width="400" Height="300" 
          RenderTransformOrigin="0.5 0.5">
        
        <Grid.RenderTransform>
            <ScaleTransform x:Name="PageScale" ScaleX="1" ScaleY="1"/>
        </Grid.RenderTransform>
        
…
    </Grid>
</UserControl>

Note also in the markup that I have left the grid lines on. This helps you visualize and debug resizing behavior especially when working with complex layouts that combine true expanding grids along with transforms and combinations of other panels.

Here’s the code. It is pretty straight-forward. I set the desired aspect ratio as a constant and then resize against that using the new SizeChanged event.

public partial class Page : UserControl
{
    // this is the aspect ratio we want to maintain
    // you can specify this all sorts of ways, but the
    // easiest is to take the original size and divide
    // X by Y (4:3 or 1.333 in this case)
    private const double _originalWidth = 400;
    private const double _originalHeight = 300;
    private const double _originalAspectRatio = 
        _originalWidth / _originalHeight;

    public Page()
    {
        InitializeComponent();

        // wire up the event handler. This is a great addition
        // to silverlight, as you used to have to hook into the
        // browser event yourself
        SizeChanged += new SizeChangedEventHandler(Page_SizeChanged);
    }

    void Page_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (e.NewSize.Width < _originalWidth || 
            e.NewSize.Height < _originalHeight)
        {
            // don't shrink
            PageScale.ScaleX = 1.0;
            PageScale.ScaleY = 1.0;
        }
        else
        {
            // resize keeping aspect ratio the same
            if (e.NewSize.Width / e.NewSize.Height > _originalAspectRatio)
            {
                // height is our constraining property
                PageScale.ScaleY = e.NewSize.Height / _originalHeight;
                PageScale.ScaleX = PageScale.ScaleY;
            }
            else
            {
                // either width is our constraining property, or the user
                // managed to nail our aspect ratio perfectly.
                PageScale.ScaleX = e.NewSize.Width / _originalWidth;
                PageScale.ScaleY = PageScale.ScaleX;
            }
        }
    }
}

In this example, I decided to restrict the user from resizing to a size smaller than the original size of the application. That is often but not always desirable. The check is easy enough to remove should you wish to allow a tiny thumbnail application.

If you have bitmap assets, resizing may not be as fluid. Experiment with the largest version you can include in your xap while keeping a reasonable download size.

Full source code available here.

Running example here.

Are You Using WPF as Well? Let Me Know!

Pete.Brown — Tue, 01 Jul 2008 17:46:36 GMT

For those of you working with Silverlight 2, are you also working on WPF projects? If so, what types of things are you building in WPF? Are you sharing source and/or team talent across the two technologies? What about readers doing only one or the other?

Either way, drop me a note in the comments below. I’m interested in getting a feel for crossover between the two communities and reasons for targeting one or both technologies in order to help improve content.

Using Pub/Sub and the Observer Pattern in Silverlight 2 (Part 2 of 2) Navigation

Pete.Brown — Tue, 01 Jul 2008 03:26:45 GMT

In the previous two parts of this article (I had planned only 2 parts total, but this ended up a three-part article), I explained how to use Pub/Sub and the EventBus for chaining service calls in Silverlight 2 applications. You can access those articles here:

In this part, I'll cover how I use this same pattern for UI navigation in a Silverlight application.

Problem

You have multiple "screens" in the application and you can navigate to them in a variety of ways. For example, Screen 1 could contains links to screens 2, 3 and 4 and Screen 6 could contain a link back to Screen 3. Add to that the idea that a couple of the screens screens could, say, pop up a media player overlay and you see where the code could get messy quickly.

A Little Background

It may help visualize this a bit if I describe the UI in the application I'm building. The application has the following screens at this point:

Home Screen
- Subset of Events Listing and link to Events Page
- Subset of Blog Listing and link to Blogs Page
- Subset of Media List and link to Media Page
- Link to play a featured video (shows media player overlay)
Events Listing Page
- List of local events
Blog Listing Page (General Page)
- List of blog posts
Media Listing Page

Videos and screencasts
Link to show Media Player overlay

User Options Page

Various options the user can set

Media Player Overlay

Slides out over current content and plays a video.

Loading Screen

Last screen in the slider. Just contains a “loading” animation

The implementation of the screens is interesting. Home, Events, Blog, Media, Loading and Options are all contained in a single stack panel that slides right or left on the screen to bring the selected screen into focus. Think of it like a filmstrip, or a simple 2d carousel (but with hard stops at the end) containing screens.

When the application goes live, I’ll post a link here and you’ll be able to see the animation in action. It was pretty simple to do:

<UserControl x:Class="AppliedIS.PartnerHuddle.Screens.PageScroller"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:screens="clr-namespace:AppliedIS.PartnerHuddle.Screens"
    Width="640" Height="400">

    <UserControl.Resources>
        <Storyboard x:Name="ScrollToPageStoryboard">
            <DoubleAnimationUsingKeyFrames 
                BeginTime="00:00:00" 
                Storyboard.TargetName="PageContainer" 
                Storyboard.TargetProperty="(Canvas.Left)">
                <SplineDoubleKeyFrame 
                    KeyTime="00:00:00.8000000" 
                    Value="0" x:Name="ScrollToPageStoryboardTargetX">
                    <SplineDoubleKeyFrame.KeySpline>
                        <KeySpline ControlPoint1="0,0.009" 
                                   ControlPoint2="0,0.989"/>
                    </SplineDoubleKeyFrame.KeySpline>
                </SplineDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
        </Storyboard>
    </UserControl.Resources>

    <Grid x:Name="LayoutRoot">
        <Canvas Width="600" Height="400">
            <StackPanel Orientation="Horizontal" x:Name="PageContainer" 
                        Canvas.Left="0">
                <screens:HomePage x:Name="HomePage" />
                <screens:EventsPage x:Name="EventsPage" />
                <screens:MediaPage x:Name="MediaPage" />
                <screens:GeneralPage x:Name="GeneralPage" />
                <screens:UserSettingsPage x:Name="UserSettingsPage" />
                <screens:DataLoadingPage x:Name="DataLoadingPage" />
            </StackPanel>
            
            <Canvas.Clip>
                <RectangleGeometry Rect="0 0 600 400" />
            </Canvas.Clip>
        </Canvas>            
    </Grid>
</UserControl>

Here’s a subset of the scroller code in the scrolling screen container/panel:

private void ScrollToPage(UserControl page)
{
    int i = PageContainer.Children.IndexOf(page);

    if (i < 0)
    {
        throw new ArgumentException("Specified page is not contained in the scrollable container.", "page");
    }
    else
    {
        double currentPosition = 
            (double)PageContainer.GetValue(Canvas.LeftProperty);
        double newPosition = i * page.Width *-1;    // ASSUMPTION: All pages are the same width


        if (ScrollToPageStoryboard.GetCurrentState() == ClockState.Active)
            ScrollToPageStoryboard.Stop();

        // build storyboard to scroll to that page
        ScrollToPageStoryboardTargetX.Value = newPosition;
        ScrollToPageStoryboard.Begin();

    }
}

My Solution - A Specialized Event Bus

I don't deal with data here at all, this is solely a navigation and screen presentation pattern, so I'm not offering up a full MVC (or MVP) solution. I have nothing against MVC, I just decided against building that type of framework for this application (and some others) I've built. Those patterns are also much more comprehensive than what I have here. That said, I certainly borrowed some concepts.

The other point I'd like to make is that this solution does not attempt to solve the "can screen x be shown now" problem yet.

In the diagram, I left out the lines connecting the scrolling screen container from the screens themselves, as that would just be clutter. Those lines will become more important in the future when I add in events to indicate when the screen is actually displayed, and when we are about to nav off the screen (for validation purposes)

// This enum needs to contain all possible nav targets for the application
public enum NavigationScreenTarget
{
    LoadingScreen,
    HomePage,
    EventsPage,
    MediaPage,
    GeneralPage,
    UserOptionsPage
}

// Event arguments for the navigation events
public class NavigationEventArgs : EventArgs
{
    private NavigationScreenTarget _target;
    private bool _instantaneous = false;

    public NavigationEventArgs(NavigationScreenTarget target, bool instantaneous)
    {
        _target = target;
        _instantaneous = instantaneous;
    }

    public NavigationScreenTarget Target
    {
        get { return _target; }
    }

    public bool InstantaneousNavigation
    {
        get { return _instantaneous; }
    }

}

// Navigation controller class
public static class NavigationController
{
    public static event EventHandler<NavigationEventArgs> NavigateToScreen;
    public static event EventHandler ShowMediaPlayer;
    public static event EventHandler HideMediaPlayer;


    // This tell the target to navigate to the screen using
    // the default behavior (animated, typically)
    public static void NotifyNavigateToScreen(NavigationScreenTarget target)
    {
        NotifyNavigateToScreen(target, false);
    }

    // this tells the target to navigate to the screen with no
    // transition animation
    public static void NotifyNavigateToScreen(
        NavigationScreenTarget target, bool instaneous)
    {
        if (NavigateToScreen != null)
            NavigateToScreen(null, 
                new NavigationEventArgs(target, instaneous));
    }


    // specialized navigation events

    public static void NotifyShowMediaPlayer()
    {
        if (ShowMediaPlayer != null)
            ShowMediaPlayer(null, new EventArgs());
    }

    public static void NotifyHideMediaPlayer()
    {
        if (HideMediaPlayer != null)
            HideMediaPlayer(null, new EventArgs());
    }


}

In this case, I called the class NavigationController. Other names like ScreenPresenter would certainly seem to fit. I haven’t come up with a reasonable name that doesn’t imply MVC/MVP, so if you come up with something, be sure to post it in the comments here.

I used the word “Notify” instead of “On” for the method names as this was an instructional event, as opposed to informational. I could have gone all old windows and called it “PostXEvent” or something, but that just didn’t feel right either.

I also included an example of a specialized event (NotifyShowMediaPlayer). I did that one differently from the normal navigation because it is an overlay “window”, not a real navigation target in the scrolling screen container.

When this project is complete, I’ll extract the interesting bits, like this, and post an end-to-end example that uses the Navigation, EventBus, Scroller, and other bits. In the mean time, I hope these three posts have given you some ideas for how to handle navigation and async communications in your own applications.

Silverlight DevNuggets Episode 2 is Now Up

Pete.Brown — Tue, 01 Jul 2008 01:31:35 GMT

Andrew Duthie just published my second DevNuggets episode. In this installment, titled Styling 101, I cover the basics of styling Silverlight controls. The videos are intended to be quick, short installments following a theme starting from the very basics and getting gradually more advanced.

You can view the video here. I hope you find it useful.

For the curious, I use the following tools when building these videos:

Camtasia 5.1 – this is the standard for screen capture software
Expression Encoder 2 – I use this and its new optimized Screen encoding settings in order to produce the best quality Silverlight video in the least amount of space. I also generate the player using one of the pre-defined templates.
Microsoft Silverlight Streaming by Windows Live – This is where the video is hosted, for free even.
Visual Studio 2008, Silverlight 2 Beta 2

I record and publish at 1024x768, so don’t be shy about hitting that full-screen button.

Silverlight Control Builder Contest ‘08

Pete.Brown — Sun, 29 Jun 2008 22:05:00 GMT

The Silverlight Control Builder Contest ‘08 has started! Build a compelling Silverlight 2 control and win some cool stuff! This is a great contest to see what you developers in the community can kick out in Silverlight 2.

Even if you can’t enter the contest, head on over to the contest FAQ and download a badge you can use to help promote the contest and Silverlight 2 control development.

I’m looking forward to seeing a lot of excellent entries. Time is limited, so step away from the lawnmower, get those creative juices flowing and submit something we’ll all want to use.

Prizes

1st Place

1-Year MSDN Premimum Subscription (Not for Resale)
Contributed by Dave Campbell
Practically every piece of software that Microsoft makes, available for download for 1-year.
Your choice of one book from the entire O'Reilly catalog
Contributed by O'Reilly Media
Choose from a huge selection of books in the O'Reilly catalog!

2nd Place

Microsoft Visual Studio 2008 Standard Edition
Contributed by Page Brooks
As a Silverlight developer, you probably already have access to this, but it never hurts to have a backup or personal copy!
Your choice of one book from the entire O'Reilly catalog
Contributed by O'Reilly Media
You know, the books that have funny looking animals on the cover!

3rd Place

Essential Silverlight 2 Up-to-Date from O'Reilly
Contributed by O'Reilly Media
Get free PDF updates to this book as they become available!
Your choice of one book from the entire O'Reilly catalog
Contributed by O'Reilly Media
Choose from a huge selection of books in the O'Reilly catalog!

Who are the organizers of this contest?

This event was organized by Page Brooks and Dave Campbell. With additional assistance from Brian Hitney, Tim Heuer, Adam Kinney, Shawn Wildermuth, and Pete Brown, this event was organized in just a few short weeks. A special Thanks goes out to all of the contributors who help to make this contest possible!

Judges

Page Brooks (www.PageBrooks.com)

Pete Brown (www.irritatedVowel.com)

Dave Campbell (www.wynapse.com)

Shawn Wildermuth (www.wildermuthconsulting.com)

(all information above valid at the time of this writing. Nothing here alters or supersedes the official rules. Please refer to official rules for details)

Technorati test post, please ignore

Pete.Brown — Sat, 28 Jun 2008 05:00:00 GMT

Please ignore

Marc Schweigert on WPF and Virtual Earth

Pete.Brown — Fri, 27 Jun 2008 20:06:00 GMT

For the WPF/VE fans in the house, Marc Schweigert has a post and demo showing how to use the new web browser control in .NET 3.5 SP1 to host Virtual Earth. Web meets desktop.

Marc's post is here.

Using Pub/Sub and the Observer Pattern in Silverlight 2 (Part 1.5 of 2) More on Service Call Chaining

Pete.Brown — Fri, 27 Jun 2008 15:05:00 GMT

In my previous post, I discussed how to chain service calls. One question I received on that was how to do the opposite: take an action after all the calls (or by extension, some logical groups of calls) have completed.

This is one of the challenges with working with async service calls. Rather than have a single function that makes a bunch of inline service calls one after the other, you need to fire off a bunch of calls, which will probably return out of order, and make some decision only after all have completed.

Making async calls is recommended for most client applications. A WPF application, for example, could fire off a bunch of calls and get a response to the user more quickly than it could if it chained the calls inline in a single function. In Silverlight 2, however, it is not only a good idea, it is a mandate due to the architecture of the network client.

So, how do you handle making a number of service calls and then taking an action when they've all completed? There are a few ways to do this, one of which (option 2 below) I'm using in the Silverlight 2 Beta 2 application I'm writing right now.

Option 1: Combined Observer and Data Loading Class

This is the simplest option, but doesn't scale out well when working with multiple disparate data sources. The advantage here is simplicity in initial coding. In this case, the DataLoadingPublisher (which is likely but not necessarily what is both making the service calls and containing the properties which hold the data) gets all the data and then publishes an event indicating that all the data is loaded. The subscriber listens for that specific event and takes action when it catches it.

You'd still publish the Data1Loaded and Data2Loaded events in the event bus, but I left them out to keep the diagram uncluttered.

The code for this is pretty straight-forward, but I'm not going to include it here, as I personally feel Option 2 is the better option in almost all cases.

Option 2: Use Dedicated Observer Class

This option injects another class into the mix, but provides the ability to have a loosely-coupled observer outside the data sources. This option is good if you have multiple sources of data coming from multiple interfaces to the outside world.

As before, the Event Bus is our common publish/subscribe location.

The various publishers publish DataXLoaded events as shown in the previous post. The Data Watcher listens for those events and keeps track internally of which data has been loaded and which hasn't. Once it identifies that all data has been loaded, it publishes its own AllDataLoaded event, which other classes (pages etc.) can subscribe to.

Here's what the code might look like:

public static class DataWatcher
{

    public static DataWatcher()
    {
        EventBus.ConfigurationLoaded += new EventHandler(SomeDataLoaded);
        EventBus.EventPageContentLoaded += new EventHandler(SomeDataLoaded);
        EventBus.GeneralPageContentLoaded += new EventHandler(SomeDataLoaded);
        EventBus.MediaPageContentLoaded += new EventHandler(SomeDataLoaded);
        EventBus.UserInformationLoaded += new EventHandler(SomeDataLoaded);
    }

    static void SomeDataLoaded(object sender, EventArgs e)
    {
        if (ApplicationData.Current.Configuration != null &&
            ApplicationData.Current.EventPageContent != null &&
            ApplicationData.Current.GeneralPageContent != null &&
            ApplicationData.Current.MediaPageContent != null &&
            ApplicationData.Current.UserInformation != null)
        {
            OnAllDataLoaded(ApplicationData.Current, new EventArgs());
        }

    }

    private static void OnAllDataLoaded(object sender, EventArgs e)
    {
        EventBus.OnAllDataLoaded(sender, e);
    }

I'm not using dedicated flags in this case; I'm using the fact that data values are null to indicate loaded/not loaded state. As that is not always practical, here's another approach that uses dedicated flag variables to indicate progress. This is a more robust as it doesn't require knowledge of the internal operations of the ApplicationData class, but instead relies only on its notification events.

public static class DataWatcher
{
    private static bool _configurationLoaded = false;
    private static bool _eventPageContentLoaded = false;
    private static bool _generalPageContentLoaded = false;
    private static bool _mediaPageContentLoaded = false;
    private static bool _userInformationLoaded = false;

    public static DataWatcher()
    {
        EventBus.ConfigurationLoaded += new EventHandler(EventBus_ConfigurationLoaded);
        EventBus.EventPageContentLoaded += new EventHandler(EventBus_EventPageContentLoaded);
        EventBus.GeneralPageContentLoaded += new EventHandler(EventBus_GeneralPageContentLoaded);
        EventBus.MediaPageContentLoaded += new EventHandler(EventBus_MediaPageContentLoaded);
        EventBus.UserInformationLoaded += new EventHandler(EventBus_UserInformationLoaded);
    }

    #region Event Subscriptions

    static void EventBus_UserInformationLoaded(object sender, EventArgs e)
    {
        _userInformationLoaded = true;
        CheckForAllDataLoaded();
    }

    static void EventBus_MediaPageContentLoaded(object sender, EventArgs e)
    {
        _mediaPageContentLoaded = true;
        CheckForAllDataLoaded();
    }

    static void EventBus_GeneralPageContentLoaded(object sender, EventArgs e)
    {
        _generalPageContentLoaded = true;
        CheckForAllDataLoaded();
    }

    static void EventBus_EventPageContentLoaded(object sender, EventArgs e)
    {
        _eventPageContentLoaded = true;
        CheckForAllDataLoaded();
    }

    static void EventBus_ConfigurationLoaded(object sender, EventArgs e)
    {
        _configurationLoaded = true;
        CheckForAllDataLoaded();
    }

    #endregion

    #region Checks for All Data Loaded

    private static void CheckForAllDataLoaded()
    {
        if (_configurationLoaded &&
            _eventPageContentLoaded &&
            _generalPageContentLoaded &&
            _mediaPageContentLoaded &&
            _userInformationLoaded)
        {
            OnAllDataLoaded(Application.Current, new EventArgs());
        }
    }

    private static void OnAllDataLoaded(object sender, EventArgs e)
    {
        EventBus.OnAllDataLoaded(sender, e);
    }

    #endregion

}

While this works well, what this doesn't do is allow for later clearing and updates to the data. To support that in the previous example, the ApplicationData class would simply null out all existing data and start reloading. The check for null would work as it should, but would require cooperation from the ApplicationData class - coupling we probably shouldn't have.

Instead, in this new example, the ApplicationData class could publish a DataCleared event when it clears its data in order to reload, and the DataWatcher would subscribe to that and set the flags appropriately. If the ApplicationData class simply overwrites the data and never provides any indication that the checks need to be reset, the model breaks. That is the one bit of cooperation that this still requires, and is reasonable IMHO.

You can extend this example to include classes of data or groups of data which should be loaded as a whole, and notify based on that. Instead of AllDataLoaded, you might have UserDataLoaded and AllPageDataLoaded etc.

The async service model presents some challenges in Silverlight, but the advantages are numerous, and the patterns you follow to work with it are pretty well-understood.

I hope this helps you out with your current and future Silverlight projects. Look for another post soon on using the patterns in these two posts to handle UI navigation.

Using Pub/Sub and the Observer Pattern in Silverlight 2 (Part 1 of 2) - Async Service Call Chaining

Pete.Brown — Fri, 27 Jun 2008 01:41:00 GMT

The Publish and Subscribe pattern (which uses the Observer Pattern in .NET - more info here) is one of those patterns we use all the time while thinking nothing of it. In .NET, we get the concrete implementation via events and delegates.

By abstracting it out just a little and applying concepts from other bus patterns, we gain a ton of flexibility and can use it for more specialized messaging than button click events. In Silverlight applications, in the client code, I tend to use it for two things:

Providing a means by which different parts of the application can notify each other of changes without requiring tight coupling
Providing a centralized mechanism for controlling navigation. This is really a variation on the first, but I break it out as I usually do when implementing. I'll post about this topic in the follow-up post

The first one is usually handled by a class named EventBus or similar. (EventBus is a well-known name used by technologies in the java world, biztalk etc., so I recommend that. I was encouraged to see a colleague at another firm used the same name in an application we did for a demo, so it's likely a pretty common name and pattern.)

Here's a simple example from my current project. This part is used for notifying various parts of the application that data has been loaded from async calls to web services:

public static class EventBus
{
    public static event EventHandler ConfigurationLoaded;
    public static event EventHandler MediaPageContentLoaded;
    public static event EventHandler EventPageContentLoaded;
    public static event EventHandler GeneralPageContentLoaded;
    public static event EventHandler UserInformationLoaded;

    #region Event Raising

    public static void OnConfigurationLoaded(object sender, EventArgs e)
    {
        if (ConfigurationLoaded != null)
            ConfigurationLoaded(sender, e);
    }

    public static void OnUserInformationLoaded(object sender, EventArgs e)
    {
        if (UserInformationLoaded != null)
            UserInformationLoaded(sender, e);
    }

    public static void OnMediaPageContentLoaded(object sender, EventArgs e)
    {
        if (MediaPageContentLoaded != null)
            MediaPageContentLoaded(sender, e);
    }

    public static void OnEventPageContentLoaded(object sender, EventArgs e)
    {
        if (EventPageContentLoaded != null)
            EventPageContentLoaded(sender, e);
    }

    public static void OnGeneralPageContentLoaded(object sender, EventArgs e)
    {
        if (GeneralPageContentLoaded != null)
            GeneralPageContentLoaded(sender, e);
    }

    #endregion

...
}

I store all the loaded data in a singleton ApplicationData class which serves both as the local data cache and the interface to the data web service. Here's the code in that class:

public void LoadUserInformation(string platformSpecificSessionKey)
{
    ConfigurationServiceClient client = new ConfigurationServiceClient();
    client.GetUserInformationCompleted += 
        new EventHandler<GetUserInformationCompletedEventArgs>(client_GetUserInformationCompleted);
    client.GetUserInformationAsync(platformSpecificSessionKey);
}

void client_GetUserInformationCompleted(object sender, GetUserInformationCompletedEventArgs e)
{
    _userInformation = e.Result;

    ((ConfigurationServiceClient)sender).CloseAsync();

    EventBus.OnUserInformationLoaded(this, new EventArgs());
}

(In woodworking magazines, they often write "safety guards removed for clarity" in articles where someone is doing something dangerous. I'll say the same here, just don't call me on it :) "Exception Handling Removed for Clarity")

If you're struggling with a way to chain your async service calls and want to do the right thing by not using WaitOne or otherwise blocking the UI thread, this is one way that can help you out. Have your client-side service interface class be both a publisher and a subscriber and chain your web service calls via event handlers. You could, of course, just chain inside the same functions, but that gets ugly once you have more than a couple levels.

Here's the code that chains the remaining data calls that are dependent on the call to load the user information. The three calls in here all need the information from the user data web service before they can proceed.

EventBus.UserInformationLoaded += new EventHandler(EventBus_UserInformationLoaded);

...

void EventBus_UserInformationLoaded(object sender, EventArgs e)
{
    // we can only get the other information once we have the user
    // information available

    ApplicationData.Current.LoadEventsPageData();
    ApplicationData.Current.LoadMediaPageData();
    ApplicationData.Current.LoadGeneralPageData();
}

Note that I don't use this architecture for everything - just information the rest of the application is interested in. I also make sure to translate the events into something meaningful before publishing. For example, the rest of the application is probably not interested in the click event of the "ApplyOptions" button, but it very likely is interested in an OptionsChanged event.

Now, there are lots of other things you may want to notify the rest of the application about. One is the example above where options are changed by the user and you need to do something like change screen colors or font size. Another is when you want to navigate from one page to another. I'll cover using this pattern for navigation in the next post.

One last note: this is by no means specific to Silverlight. I've used this on Windows Forms and other client technologies in the past. It just happens that Silverlight is my newest toy :)

Software Development Meme - Pete's Response

Pete.Brown — Thu, 26 Jun 2008 21:20:41 GMT

Fellow Silverlight enthusiast (and great author) Chad Campbell called me out on this, so now it's my turn :)

How old were you when you first started programming?

That was either 6th grade or 7th grade, so I was around 12. I often question the people who tell you they were hacking systems at the age of 6, but who knows? :)

How did you get started in programming?

The first time I ever wrote any BASIC statements I was using a DEC Robin. Digital had a computer bus that toured various schools and parked in the playground for a day. The math classes would then take their students out to the bus and let them poke around with the computers.

In 7th grade I wrote a BASIC program on the CP/M Robin. All the program did was draw a rocket ship and "launch" it up the screen by printing out a bunch of blank lines. With the display set to smooth scrolling, it was convincing to me anyway.

The computer room had Commodore VIC-20 computers as well, but the huge letters on those just looked cumbersome to me. Soon, the school received a shipment of Commodore 64s, and I was hooked. I used to stay in for recess and stay after school until the room closed.

It wasn't until highschool that I got a computer of my own - a Commodore 128 with all the trimmings.

What was your first language?

I wrote a couple programs in MBasic on the Robin, and then a ton in Commodore 64 basic. I didn't get into Pascal at all until highschool, and into C/C++ until college..

What was the first real program you wrote?

Real is hard to define here. I'll take it to mean something rather functionally complete. I wrote some D&D helpers - programs that rolled dice - on the Commodore. My friend at the time also wrote some of those (a very popular "killer app" of the day :) )I also wrote a boatload of games and utilities that were somewhere between 10% and 75% complete. Of course, I did also write the "Would you like to play a game?" WarGames emulator.

The first "real" program, meaning I got paid for it and it worked and provided some business value is down below under professional gig.

What languages have you used since you started programming?

Learned and did Academic Projects: COBOL, x86 assembly, VAX Pascal, Apple II Pascal, MSIL, VAX DCL

Used to Actually do Something: Basic (Visual Basic, VBScript, QBasic), C, C++, C#, Delphi (Pascal), PowerBuilder, XBase (dBase, FoxPro), Gupta SQLWindows (I forget the language there), and probably a bunch I've forgotten about.

Still use: C# and once in a blue moon I do something in VB.NET, but that is rare.

What was your first professional programming gig?

When I was in college, I worked part-time at the Medical Bureau of Economics in Worcester, MA. My job was to do data entry, which I found boring but it paid well - and I was a decent typist. It didn't take me long to realize that the unix app we were all using on those terminals was written in basic and that I could list/modify the source code if I wanted (I limited myself to just looking). What tipped me off was a syntax error I got while using it one day.

Anyway, shortly afterwards I was moved downstairs because the new director saw that I was working on a CS degree and she realized I was as close to an IT person as that place had. That company had close to 100 employees, but the only IT was one person who used to come in and wire new terminals to the unix server, and replace faulty boards. No programming support at all.

Besides all the other admin stuff I did, I wrote my first business application: a DOS database and windowed UI in C++. I wasn't aware of dBase or anything at that point in time, but I knew about bTrees and I knew C++. Using the big blue box Borland C++, and some information from some books, I wrote a database to track payments for one of their hospitals. I wrote later versions of it in dBase and even later upgraded that to FoxPro.

If you knew then what you know now, would you have started programming?

Absolutely. While it has had its ups and downs, I can't think of any other career that would provide me the combination of things I need to keep me happy.

If there is one thing you learned along the way that you would tell new developers, what would it be?

User Experience is king, raw functionality is often secondary and great architecture a distant third. Users know this when they see it, but don't get it when gathering requirements. IT departments rarely get this. As the UI/UX bar goes up, professional design firms are going to eat the lunch of those who don't. Remember, a user isn't going to see the great SOA backend you built, and more often than not, they won't care. Build something that scales to the requirements, works well, and is both easy and a pleasure to build.

Show the users progress early and show it often. A prototype UI is often one of the easiest way to walk through requirements and functionality.

Note I'm not suggesting that pretty front ends with crappy back ends is a good pattern. We can certainly argue the general points here, but if you find yourself really disagreeing with this point, you might find that you're going to get run over in the RIA/rich revolution going on.

Oh, and one other point: Spelling and Grammar do Count :)

What’s the most fun you’ve ever had … programming?

That's hard to say. I've had lots of different kinds of fun, and I've had some real drudge work too. Staying up 20 hours a day coding that first Silverlight 1.1 alpha application was actually a ton of fun. So was doing my first sprite graphics on the C64. I've had lots of fun over time, but the most fun tends to be the little side projects I get to do in emerging/new technology.

Who are you calling out?

How to Retrieve and Process an RSS Feed in Silverlight 2

Pete.Brown — Fri, 20 Jun 2008 16:21:18 GMT

For the Facebook Silverlight 2 Beta 2 application I'm writing, I need to be able to process a number of RSS feeds. In Silverlight 2 Beta 2, processing RSS is, well, really simple :)

Here's a class and associated event and exception classes I wrote to handle downloading the feed, and loading it into the RSS objects:

#region Support Classes (exception, eventargs)

public class FeedException : Exception
{
    public FeedException()
        : base("Exception retrieving or processing feed.")
    {
    }

    public FeedException(string message)
        : base("Exception retrieving or processing feed. " + message)
    {
    }

    public FeedException(string message, Exception innerException)
        : base("Exception retrieving or processing feed. " + message, 
                innerException)
    {
    }

}

public class FeedRetrievedEventArgs : EventArgs
{
    private SyndicationFeed _feed;

    public FeedRetrievedEventArgs(SyndicationFeed feed)
    {
        _feed = feed;
    }

    public SyndicationFeed Feed
    {
        get { return _feed; }
    }

}

public class FeedErrorEventArgs : EventArgs
{
    private Exception _exception;

    public FeedErrorEventArgs(Exception exception)
    {
        _exception = exception;
    }

    public Exception Error
    {
        get { return _exception; }
    }

}

#endregion

public class RssFeedGrabber
{
    public event EventHandler<FeedRetrievedEventArgs> FeedRetrieved;
    public event EventHandler<FeedErrorEventArgs> FeedError;

    private const string _nullResultErrorMessage = 
        "The returned stream was null. "+
        "The site may not have a valid client access policy in place.";
    private const string _parseErrorMessage = 
        "Unable to parse feed.";

    /// <summary>
    /// Makes an async call to return the feed data
    /// </summary>
    /// <param name="url">URL of the feed</param>
    public void RetrieveFeedAsync(Uri url)
    {
        WebClient client = new WebClient();

        client.OpenReadCompleted +=
            new OpenReadCompletedEventHandler(client_OpenReadCompleted);

        client.Encoding = System.Text.Encoding.UTF8;
        client.OpenReadAsync(url);
    }


    /// <summary>
    /// Event handler called when the WebClient returns the data from the call
    /// </summary>
    private void client_OpenReadCompleted(object sender, 
        OpenReadCompletedEventArgs e)
    {
        // process the feed

        if (e.Error == null && e.Result != null)
        {
            using (XmlReader reader = XmlReader.Create(e.Result))
            {
                try
                {
                    SyndicationFeed feed = SyndicationFeed.Load(reader);

                    FeedRetrievedEventArgs args = 
                        new FeedRetrievedEventArgs(feed);

                    OnFeedRetrieved(args);
                }
                catch (Exception ex)
                {
                    // the loader couldn't load the feed
                    FeedErrorEventArgs args = 
                        new FeedErrorEventArgs(
                            new FeedException(_parseErrorMessage, ex));
                    OnFeedError(args);
                }
            }
        }
        else
        {
            if (e.Error != null)
            {
                // there was an error returned from the call
                FeedErrorEventArgs args = new FeedErrorEventArgs(e.Error);
                OnFeedError(args);
            }
            else
            {
                // an empty stream. You get this silent failure when there 
                // is no crossdomain file in place (at least in beta2)
                FeedErrorEventArgs args = 
                    new FeedErrorEventArgs(
                        new FeedException(_nullResultErrorMessage));
                OnFeedError(args);
            }
        }
    }

    /// <summary>
    /// Internal method used to raise the feed event
    /// </summary>
    protected void OnFeedRetrieved(FeedRetrievedEventArgs args)
    {
        if (FeedRetrieved != null)
            FeedRetrieved(this, args);
    }

    /// <summary>
    /// Internal method used to raise the error event
    /// </summary>
    protected void OnFeedError(FeedErrorEventArgs args)
    {
        if (FeedError != null)
            FeedError(this, args);
    }

}

The class simply makes an async web call to retrieve the feed, then raises an event with the parsed feed. If you extend the feed formatter classes, you'll want to modify this code to use the appropriate one. If I end up extending anything, I'll write (and post) a templated version of this class.

Make sure you add a reference to System.ServiceModel.Syndication as well as add the appropriate using statement:

using System.ServiceModel.Syndication;

Keep in mind that the site hosting the rss feed will need to have an appropriate cross domain file in place, or you'll need to use a workaround like the ones described in Tim Heuer's blog post.

To use this class, simply call it from your code like this:

void Page_Loaded(object sender, RoutedEventArgs e)
{
    RssFeedGrabber grabber = new RssFeedGrabber();

    grabber.FeedRetrieved += 
        new EventHandler<FeedRetrievedEventArgs>(grabber_FeedRetrieved);
    grabber.FeedError += 
        new EventHandler<FeedErrorEventArgs>(grabber_FeedError);

    grabber.RetrieveFeedAsync(
        new Uri("http://feeds.feedburner.com/PeteBrown"));
}

void grabber_FeedError(object sender, FeedErrorEventArgs e)
{
    // there was an error with the feed. display appropriate
    // message or take action here
}

void grabber_FeedRetrieved(object sender, FeedRetrievedEventArgs e)
{
    foreach (SyndicationItem item in e.Feed.Items)
    {
        System.Diagnostics.Debug.WriteLine(item.Title.Text);
    }
}

(as an aside, I don't usually break up my code lines as seen above, unless the lines are extremely long; I broke them up just so they fit in this post.)

Let me know if you have any questions or run into any issues, or if you've come up with an even simpler/cooler/more functional version of this class.

Silverlight 2 and Yahoo Pipes

Pete.Brown — Thu, 19 Jun 2008 21:00:24 GMT

Sometimes I hear about something for the first time and figure I must live under a rock. I make a point of keeping up on a number of new things, but it's hard to keep track of all the cool services and technologies available to you these days.

Tim Heuer just today turned me on to Yahoo Pipes when I asked about proxying some services to provide feed content to a Silverlight FaceBook app I'm developing for John McClelland and Chad Brooks through Applied Information Sciences.

MSDN doesn't yet have a ClientAccessPolicy.xml in place, so my only options to pull from blogs there are to proxy via my own local service - which will make scaling harder - or look to a third party.

Well, Yahoo Pipes is a lot more than a proxy. It lets you aggregate various feeds (and services and POX and more) filter, extract key bits of information etc. Not to mention it is one very cool ajax application.

Below is a screenshot of a pipe I designed to pull some event feed information from various developer evangelist blogs, and the awesome Community Megaphone site that Andrew Duthie set up.

You drag and drop the various components (sources, filters etc.) on to the design surface, and then connect them together. You can see in the above list, I have three blogs for testing feed pulls and event filters. To the right, I have Andrew's Community Megaphone. I don't need to filter that one for event information because that site only includes events.

For the Microsoft folks in the audience, John, Chad and I will be presenting about this application at TechReady 7 in July/August in Washington State.

Whether pipes makes it into the final product depends on how well it works for the various scenarios I have. However, it's very promising so far.

Look for more blog posts as I complete more interesting bits of this application. So far, it is shaping up to be one very cool mashup of a bunch of great technologies.

Nerdware: My Home Network, Rack Servers, CNC Machine

Pete.Brown — Mon, 16 Jun 2008 20:34:51 GMT

I like to mess around with computers. Every primary computer I've owned since my first 486 has been built by me (my previous computers, a 286 and a Commodore 128 were purchased). I also run a moderately complex network at my house which I realize I have never fully described anywhere. So, thought I'd tell you about it here.

Why

My first server was a linux box I had in our last apartment. It was running a commercial distribution that was optimized as a firewall. Back then, that was pretty necessary on a cable internet connection. (we were the first internet install the installer had ever performed, so that was a treat too - not to mention that the cable company was new to this whole broadband thing) I later replaced that with a linksys router+firewall that didn't take up so much room.

I like to tinker. Plus, the idea of having a rack of servers in my basement just did it for me. Originally, I started hosting my own server because my main site was going way over the quota of my ISP, and was about to cost me a ton of money. Either that, or I'd have to remove a good chunk of the desktop backgrounds I had made freely available. Since we had moved to a house with enough room for me and my computers, I repurposed an old PC as a web server and used Speakeasy DSL. That grew to include a file server and a mail server. Eventually, I got tired of having loose servers standing around, and wanted to put them all in a rack.

Wiring

When I first moved here in 2001, I went through and wired the whole house with CAT5e and coax. Fiber required special tools and skills and CAT6 wasn't as available back then. Our house was built in 1979 and cable added later. The cable was split in a million places. In addition, the phone wiring, while professionally done and all home-run to the outside of the house, couldn't keep up with DSL and actually had a fair amount of noise on the line during regular conversations. The problem mainly had to do with proximity to electrical wiring and lighting added later by the previous homeowner.

The runs (three cat5e and two coax to all plates; at least one per room) all terminate in a panel in the basement utility room. Those provide network, phone and tv as appropriate. (We only have one TV and we keep that in the basement TV room as we don't like TVs in bedrooms or family rooms, but I wired it because all rooms originally had cable and I didn't want to downgrade anything should we sell in the future). You can see that the majority of the coax cables just hang loose in the cabinet. I only connected the one that is in use as any other coax cables (even terminated as all ours are) can contribute to noise in the system. While the effect would likely be minimal, I left them disconnected anyway.

I didn't want to do wireless as I knew I'd run servers and I just like wired connections better for their performance, reliability and security. However, since I also like to work on the deck sometimes and also need to provide access to my wife's laptop, I installed a Netgear wireless access point upstairs. The signal from the ActionTec router in the basement was too weak and unreliable upstairs and out on the deck due to the interference in the utility room.

I really need to clean up the wiring in this room, as I added a bunch of things after the fact, but here's a photo to show what it looks like now. Professional installers may want to avert their eyes. :)

Internet Access

I used to use Speakeasy and found their service and offerings both to be excellent. My favorite thing about Speakeasy was that they treated you like you knew what you were doing.

That said, I eventually moved from Speakeasy to Verizon FIOS. The copper running to my house wasn't adequate for any higher DSL speeds, so I had to go with fiber or cable.

The FIOS install was far from painless, as I have the "business" FIOS at my house. As a side note: why are developers and technical people always left out? So many things (laptops, pcs, internet access, operating systems, etc.) are often categorized as "business" or "consumer". However, the "business" one is usually the one with more features like, oh, static IPs, that certainly are not used only by businesses.

You can read about the FIOS install here and here.

Servers and Server Rack

A while back, I bid on and won an APC server rack on ebay. Shipping on those things is pretty crazy, so I waited until I could find one that was relatively local (this one was north of Baltimore, close to White Marsh, as I recall). My father in law and I took his pickup truck up there and loaded it in the back.

After that, I purchased a couple used IBM x345 dual Xeon servers from eBay, and outfitted them with new drives, RAID controllers, and upgraded memory. Those are nice 24x7 server-class machines at a cheap price. Sure, the processors are way outdated, but they do just fine as web and database servers for me.

Finally, since all those machines took some real juice, I had to install a window rattler air conditioner in the window, and run a dedicated 20amp circuit over to the rack. Luckily the electrical panel, the rack and the wiring panel are all in the same room, so that wasn't a big deal at all.

I also converted a couple of my other stand-alone "servers" (repurposed desktop PCs) into rackmount servers. They run the mail server, the domain controller and the VOIP server.

I ended up retiring the VOIP server (it's still there, just switched off) as VOIP inside the house just wasn't practical. It was difficult for my wife to use, as you can't do things like just pick up any old extension to join a call, and the server itself had some issues that made it go down sometimes. The real deal-killer, though, was the inability to get rid of the echo on the line. The 3CX folks (makers of the Windows-based IP PBX) said it wasn't them, and the GrandStream folks (makers of the HandyTone 503), despite trying hard, couldn't get rid of it either.

The rack has the servers I mentioned, a 24 port 100mbps switch (will probably upgrade it to gigabit some day, but I haven't hit any real limit yet with 100mbps), a KVM and rackmount console display (also an ebay item) and several stand-alone old battery backup / UPSs that need to be replaced.

Due to how the rack is positioned in the room, it's hard to get a photo, but these photos show a bit of it at a time. In the first, you can see the wonderful AC on the left. The piece of masonite (hardboard) leaning against the rack on the right is a simple attempt at a baffle to keep the cool air in front of the servers.

CNC

The basement utility room / workshop also includes my CNC control computer, the CNC controller box, and the CNC-converted Sherline mill. You can read more about those on my site here and here. You can also see me making a part for the mill, using the mill, on my page here. Sadly, I haven't had any time to work with that since my son was born and we started our renovation, but I'll return to it someday. It's really amazing and thoroughly gratifying to see your ideas make it from the digital world to the physical world.

When I was working with that, I would do all my designs on my main PC, and then copy the resulting set of CNC instructions to a share on my server. From there, I'd go into the utility room and load the instructions up on the machine and queue up the material. Sure, I could remote desktop, but I'd still have to load the material and zero out the bits before running the program anyway :)

Future Direction

So, that's my home network - for now. When I redo the entry way in the house, I might install a network camera there. Plus, there's always the media center PC when we eventually go that route, and the kitchen PC (when it's back on after the remodel). Finally, when my kids are old enough, I'm sure the consoles of the day will end up on our network.

Space Shuttle is Huge!

Pete.Brown — Mon, 16 Jun 2008 15:07:31 GMT

The three of us (me, Melissa and Ben) all went to the National Air and Space Museum - Udvar-Hazy Center in Chantilly, VA (not the one in DC) this weekend. This is where the Smithsonian keeps all the really big things like the Concorde, the Enola Gay, and the Space Shuttle Enterprise.

It turned out to be less exciting for Ben than we thought (he's really into airplanes and spaceships, but only when they're moving and making lots of noise, it turns out), but we did all get to see something really cool - the space shuttle.

Let me say that the shuttle is much bigger than I ever thought it was. I mean, I knew it was pretty big, but I didn't quite grok just how ginormous this thing is.

It's pretty dark inside, so this is a terrible photo. However, it really does show the size compared to the people at the table right under the tail.

The other thing I found interesting was just how small the Lockheed Martin SR-71 blackbird is. I built a model of that when in highschool and always pictured it as this huge plane. Instead, it's pretty low and sleek, sized much more like a fighter jet than the giant plane it looks to be when scaled down.

Visual Studio 2008 and Silverlight 2 Beta 2 - Supported Versions

Pete.Brown — Mon, 16 Jun 2008 14:04:21 GMT

In response to a question at last Friday's Silverlight TechFest event, I said that I believed Beta 2 was supported even on Visual Studio Express.

I was incorrect. XNA supports Visual Studio Express (and I had been reading about XNA the night before), but Silverlight requires at least Visual Studio Standard. Standard is pretty reasonably priced at well under $300, but it isn't free.

For now, if you want to experiment with Silverlight, I suggest any of the following:

Purchase Visual Studio Standard or better
Download and use the 90 day trial of Visual Studio Standard or Professional

In addition, I recommend that you use the free Expression Blend 2.5 June preview. You don't get a code editor (which is necessary for any real work), but Blend can open and compile Silverlight sample applications that you download. Combined with the purchased or trial version of Visual Studio, you get a well-rounded design and development environment.

Scott Guthrie had the following to say regarding the eventual tooling support for Silverlight (emphasis mine):

"Today's VS Tools for Silverlight download requires VS 2008 Standard or higher, and doesn't work with the free VS express editions.

"Visual Web Developer 2008 Express SP1, though, will enable support for class library and web application projects. Once the final SP1 release occurs this summer we'll update the VS Tools for Silverlight download to work with it as well - which will provide you with free VS tool support for Silverlight development."

So there will be a free developer solution for Silverlight in the future. Given that Scott said SP1 will be out this summer, the free 90 day eval version should bridge most or all of that gap. Hope that helps clear up any confusion.

Silverlight DevNuggets Expisode 1 Up and Ready for Viewing

Pete.Brown — Thu, 12 Jun 2008 20:09:02 GMT

Silverlight DevNuggets #1 is up on Andrew Duthie's blog. Starting out simple, I put together a short screencast covering the concept of a content control in Silverlight 2.

The idea behind DevNuggets is to present very short videos on digestible topics. I expect to put a couple others out this summer to round out the series and cover some other interesting Silverlight 2 UI topics.

Silverlight TechFest on Friday - WCF, Astoria and More!

Pete.Brown — Wed, 11 Jun 2008 21:00:52 GMT

At the Silverlight TechFest on Friday, I'll cover the following topics in my afternoon session on Connecting Silverlight:

Silverlight 2 Beta 2 Networking Overview
WCF
Sockets and/or WCF Duplex Communications
ADO.NET Data Services (Astoria) and how I used it and the ADO.NET Entity Framework

I'll also cover background info like binding, dependency properties, some LINQ and so on.

In the afternoon, we'll have a panel discussion and open Q&A, so this is a great opportunity for you to ask whatever you want about Silverlight 2.

Registration is currently full, but if you show up, no one will turn you away. Just make sure you register/waitlist via the link on my post here (link also has the agenda, location etc.).

(hey, it's a Microsoft presentation, so you knew there had to be a cloud in there somewhere!)

Problems Uploading Videos to Windows Live Silverlight Streaming when Beta 2 Installed?

Pete.Brown — Wed, 11 Jun 2008 13:45:44 GMT

If you have Silverlight 2 Beta 2 Installed and enabled, you will not be able to upload videos to Silverlight streaming. That's because the upload component is written in Silverlight 2 Beta 1 and has not yet been upgraded to Beta 2. The problem manifests itself as a disabled Browse button on the "Upload Videos" page.

I was trying to upload some videos for the Silverlight TechFest this Friday and kept running into this issue. I figured out the solution by digging around in the JS and seeing that the field gets enabled only when the upload component init/create is successful. I also saw that there's a down-level uploader available.

The workaround is to disable Silverlight (temporarily!) in IE, by going into Tools-> Manage Add-ons -> Enable or Disable Add-ons

In the drop-down, select "Add-ons that have been used by Internet Explorer":

and disable Silverlight:

Then restart IE. When you've completed your uploads, remember to enable Silverlight.

The nag screens in Live get annoying, but this is a temporary solution just until they update to Beta 2.

irritatedVowel.com

How to Resize a Silverlight 2 App and Keep the Same Aspect Ratio

Are You Using WPF as Well? Let Me Know!

Using Pub/Sub and the Observer Pattern in Silverlight 2 (Part 2 of 2) Navigation

Problem

A Little Background

My Solution - A Specialized Event Bus

Silverlight DevNuggets Episode 2 is Now Up

Silverlight Control Builder Contest ‘08

Prizes

1st Place

1-Year MSDN Premimum Subscription (Not for Resale)

Your choice of one book from the entire O'Reilly catalog

2nd Place

Microsoft Visual Studio 2008 Standard Edition

Your choice of one book from the entire O'Reilly catalog

3rd Place

Essential Silverlight 2 Up-to-Date from O'Reilly

Your choice of one book from the entire O'Reilly catalog

Who are the organizers of this contest?

Judges

Technorati test post, please ignore

Marc Schweigert on WPF and Virtual Earth

Using Pub/Sub and the Observer Pattern in Silverlight 2 (Part 1.5 of 2) More on Service Call Chaining

Option 1: Combined Observer and Data Loading Class

Option 2: Use Dedicated Observer Class

Using Pub/Sub and the Observer Pattern in Silverlight 2 (Part 1 of 2) - Async Service Call Chaining

Software Development Meme - Pete's Response

How to Retrieve and Process an RSS Feed in Silverlight 2

Silverlight 2 and Yahoo Pipes

Nerdware: My Home Network, Rack Servers, CNC Machine

Why

Wiring

Internet Access

Servers and Server Rack

CNC

Future Direction

Space Shuttle is Huge!

Visual Studio 2008 and Silverlight 2 Beta 2 - Supported Versions

Silverlight DevNuggets Expisode 1 Up and Ready for Viewing

Silverlight TechFest on Friday - WCF, Astoria and More!

Problems Uploading Videos to Windows Live Silverlight Streaming when Beta 2 Installed?