I also received a few questions at MIX from customers about my office… I guess thanks to Twitter it has a reputation.

In the world of Microsoft buildings, I have always tried for a rather eccentric one. I like nice things and am not a fan of boring carpet. Afraid of the wrath of building maintenance, I customize the interiors without painting the walls or making any crazy modifications.

This means hardwood flooring to help brighten the space, custom furniture, and personal hardware (known as the Jeff Hardware Budget).

Current office

Customizations: Hardwood flooring. Plants. Glass desk. Speakers. 30” LCD. Lamps. Hanging art. Beer fridge. Color changer. Large chair and storage ottoman.

Corporate furniture: Guest chair. Hanging bookcase. Development workstation. Whiteboards.

Construction

Thanks to power tools, this took only about 3 hours of time one Saturday afternoon. These are IKEA “Tundra” floorboards, and once you get the hang of it, go in pretty easy. I decided not to finish the edges with molding, however – it’s just a temporary office adornment.

Hammering boards into place.

Past offices

To see the progression over time… here are some past offices.

Simple office in building 42, nothing but a notebook:

How do Microsoft offices work?

Many of the buildings on the Microsoft campus have been designed from the start to optimize for windows, as opposed to cubicles and enclosed spaces. More recent buildings do tend to have more interior space, but still a sufficient amount of corners in the building to offer windows to many.

If you take a printout of an organization and order by “service award date” (the starting date of employment), you get the office seniority list.

As many as can at the top, will receive their own window offices. After that, interior but still private offices. And finally, the remainder will typically be “doubled up” in offices. For the record, I was tripled up when I first started at the company… that was fun.

Turns out it’s not always that simple, but in a perfect world that would be it … sometimes your organization may ‘hold’ office space; you can’t always be moving, so often smaller moves just go into ‘available’ space instead of displacing other workers; and people managers, even recent hires, need private space to hold candid conversations.

Anyway, hope you had fun reading about my office. RIP!

New infrastructure & test tools ship in the Silverlight Toolkit

There is a lot in the release that is joining publicly for the first time, based on some of the internal tools and utilities that we use in building and testing the Silverlight Toolkit, plus things we’d like to have as typical Silverlight developers.

These tools join in the Experimental quality band, and over the next few posts, I’ll dig into the details. This post is a literal walkthrough of how you could go about seeing all the utilities in the meantime.

One important thing to call out is that, as an initial release, there are definitely some rough edges: the test tools are centered around Microsoft Build (msbuild) integration, instead of Visual Studio integration; there’s no add-in or nice right-click project support to use these tools today.

We’ll be collecting feedback along the way and making changes in future releases. Until then, hopefully some of you will find the infrastructure useful, if only to peak behind the curtain. We’re also shipping the full source to these tools, you’ll find an Infrastructure.zip file inside the toolkit install folder.

What we’ll do in this walkthrough

This walkthrough uses Silverlight 4, though the instructions are virtually identical if you’re using Silverlight 3.

• Install the Silverlight Toolkit
• Create a new Silverlight class library with a simple business object
• Add a Silverlight Unit Test Application using the new templates found in the Silverlight Toolkit
• Run the tests in Visual Studio
• Run the tests from the command line in various browsers
• Collect block-level code coverage information for the build

This is screen-shot heavy, as future posts will dig into the details. I appreciate your patience!

Requirements:

• Latest Silverlight Toolkit
• For test automation:

• MSBuild on the machine

• Visual Studio 2010 Beta 2 Ultimate

Installing the tools

When you install either Silverlight Toolkit drop from November, you’ll see that there’s a new feature listed in the setup: the Tools & Templates feature. It’s selected by default, and adds Visual Studio templates, installs the tools, and prepares the tools if your machine has the proper dependencies on it.

Create a Silverlight Class Library

Open Visual Studio 2010 Beta 2, after installing the toolkit. Create a new Silverlight Class Library project, we’ll store a simple business object in it.

Whichever flavor of Silverlight you use, remember to use the same flavor while creating future projects in the same solution!

Create a new Person.cs type, with a few properties and a method. Here’s the source:

using System;

namespace MyApplication
{
    public class Person
    {
        public string First { get; set; }
        public string Last { get; set; }

        public string FullName { get { return First + " " + Last; } }

        public bool MightBe(string substring)
        {
            return FullName.Contains(substring);
        }
    }
}

Add a Silverlight Unit Test Application

Right-click on the solution in the Solution Explorer and select Add New Project. Under the Visual C# (and also Visual Basic) languages node, select the Silverlight subgroup. You’ll see a Silverlight Unit Test Application project template.

You now have two projects:

Next up, we want to add a reference to the class library, so that the unit tests can access the library. Right-click on the new test project and then select the Add Reference option. Under the Project tab, choose the class library you created earlier.

Now, let’s add some unit tests. Clear out the content in the created Tests.cs file and drop this in:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using MyApplication;

namespace PersonTestProject {
    [TestClass]
    public class Tests
    {
        [TestMethod]
        public void TestCtor()
        {
            Person p = new Person();
        }

        [TestMethod]
        public void TestSetName()
        {
            Person p = new Person { First = "Scott", Last = "Guthrie" };
            Assert.AreNotEqual(p.First, p.Last);
        }

        [TestMethod]
        public void TestGetFullName()
        {
            Person p = new Person { First = "Steve", Last = "Ballmer" };
            StringAssert.Equals("Steve Ballmer", p.FullName);
        }
    }
}

The tests are pretty simple, and exercise various simple PMEs on the type.

Run the unit tests from Visual Studio

Right-click on the test project and select Set as StartUp Project from the menu. Then, press F5 or click the Run button to begin execution.

The default web browser will open up, the tests will run, and the window will stay open. When you are satisfied, close the browser. You’ve just run some simple tests!

Running unit tests from the Visual Studio command line

More interesting is being able to automate the tests: through MSBuild, we’ve added a task that can control the browser and save out the log file(s) from the unit tests when they run.

To do this, you need a few things:

• The Visual Studio command prompt open.
• The full path to the test project.

Open the command prompt

Personally, I always pin the Visual Studio 2008 tools command prompt next to my Visual Studio taskbar icons.

You can start it from the Start Menu, under the tools for the Visual Studio version you are using.

Alternatively, make sure MSBuild is in your path.

Or, start a command prompt and then move to your 32-bit Program Files, then ‘Visual Studio 9.0’, then VC. Run ‘vcvarsall.bat x86’

Note: all these command prompts should be 32-bit, even on a x64 machine. Silverlight is a 32-bit world today.

Move to the test project

To get the full path to the test project, I just right-click on the test project in Visual Studio, then Open Folder in Windows Explorer. I copy the path from the resulting Explorer dialog’s crumb navigation bar.

Now, inside the command prompt window, move to that path:

pushd (PASTE PATH HERE) <enter>

To run the unit tests in the default browser, simply type

msbuild /t:test

and press Enter.

You’ll see the browser open, quickly run some tests, and then close. Here’s what it looks like, captured in the middle of the 5-second test run:

And afterwards, you’ll see that Msbuild reports success, and you can read the test to see that 3 passing tests were reported, out of 3 total tests.

Running tests in Google Chrome

It’s easy! Just set the browser property to Chrome.

msbuild /t:test /p:browser=chrome

And just like that, Chrome opens up and runs the tests.

Running tests in Mozilla Firefox

Just set the browser to Firefox.

msbuild /t:test /p:browser=firefox

Tag Expressions

A nice feature to help select a subset of tests is the Tag Expression syntax. By specifying a tag expression at the command prompt, you can include and exclude tests that are marked with the Tag attribute found in Microsoft.Silverlight.Testing.

Also, tags implicitly exist for all test method names, short and full.

So, let’s run the test called TestSetName from our project.

msbuild /t:test /p:tagexpression=TestSetName

You may briefly see indication in the test UI in the browser that a ‘Tag expression’ is in use.

And the build results show that just one test ran:

If you want to run all tests except that one, use this tag expression:

msbuild /t:test /p:tagexpression=!TestSetName

Cool, and easy!

Test results files

Another nice feature of running the tests through MSBuild is that you’ll see test result files (end in *.trx) inside the same folder as the test page for the application.

Similar and conformant to the Visual Studio *.trx format, you can parse and work with this data to understand execution times, results, and read other information. Unfortunately, you cannot open these files in Visual Studio 2010 Beta 2, but they do open in Visual Studio 2008. Note that there isn’t any real test integration with VS here: this is just an informative display.

Here’s a directory with several test result files (plus some coverage stuff we’ll get to later):

You can open up the TestResults trx file and see what kind of information is in it:

And here’s the results file opened in Visual Studio:

Preparing for Code Coverage

Ripe for a Visual Studio add-in, this process requires us modifying the test project’s .csproj file some. Instructions are the same for Visual Studio.

We need to manually select the assembly to be instrumented by setting a property. The assembly to be instrumented must not be signed, and not have a strong name. In this example, the assembly is SilverlightClassLibrary3.

To make changes to the test project, to specify this, first unload the project by right-clicking on the test project and selecting the Unload option:

Then, right-click the project file that is ‘(unavailable) and select ‘Edit’.

Now you’ll see the XML data for the project. Scroll down in the template to where there is a commented out ItemGroup, and some comments about the code coverage support. Remove the comments from the ItemGroup:

And now, change the Include statement from SilverlightClassLibrary1 to whatever your assembly to instrument is called. In our example here, it is called SilverlightClassLibrary3.

Now, that’s it. Let’s close the file and then right-click the project again and select Reload Project:

Now we’re ready to go!

Running Silverlight Code Coverage

Just like the msbuild /t:test from above, we have a similar target named CoverageTest and CoverageView. CoverageTest collects the data, while CoverageView collects the coverage data and then shows the results in an application that explores the hit and not hit portions of your source code.

Let’s collect coverage!

Note: This is assuming that you have a high-level SKU of Visual Studio 2010 Beta 2 installed. The coverage tools depend on the Static Analysis Tools that ship in the beta. You will receive an error if you run this on a machine without those tools. We’ll look for a better experience in the future.

Remember, the same properties from above – browser and tag expression – still can apply and work in the coverage targets.

msbuild /t:coveragetest

Here is what it will look like if everything line up. Unfortunately, the coverage experience is a very early preview and very flaky in some situations due to the dependency on beta components. We also haven’t had I admit enough time to iron out all the issues customers may experience.

You see the Instrumentation messages come out, then the RunTests target, then the coverage data is merged and things should be successful.

If that worked, it is safe to assume that the view target will also work. It will re-run all the tests and instrument again as well.

msbuild /t:coverageview

Now you’ll see the viewer popup, that lets you drill into types and methods to see what is hit (cyan) or not hit (red), to spot code that your tests are missing:

You’ll find a Coverage.xml file in the same directory where the test results go. This is the data that is used by the viewer application. You’ll see in the XML file a set of ‘visited’ blocks, and other information, in the file:

More to come soon!

Download the Silverlight Toolkit November 2009 Release Today

The Silverlight Toolkit is a collection of Silverlight controls, components and utilities that help make Silverlight development a little easier, more fun, and add value outside the regular Silverlight release cycle.

The sixth release of the Silverlight Toolkit, the November 2009 release targets Silverlight 3. There is also a release available that targets the new Silverlight 4 Beta for developers.

Resources of note:

• Learn more about the Silverlight Toolkit
• Download the November 2009 Release
• Get started with Silverlight development
• Participate in the controls community at Silverlight.net
• Check out questions and answers on Stack Overflow using the ‘silverlight-toolkit’ tag
• The Issue Tracker can be used to report issues, add to the feature wish list, and vote on the work to be done by the Microsoft team

Hope you enjoy our new release!

The Silverlight Control Browser is a one-stop resource for learning about the core controls in Silverlight, the controls in the Silverlight SDK (like DataGrid), and of course the value-add controls and features that are found in the extra Silverlight Toolkit download.

By installing the app on your machine, you can learn about the controls even when offline. Perfect for those long holiday flights that are coming up this next month, when your airline doesn’t provide wireless Internet. (Aside: I recently flew Delta and the wireless in-flight Internet rocked. Big time. I’ve never had a flight home to Seattle go by so quickly)

Another scenario: the infamous hipster coffee shops in Seattle whose wifi routers go down and never come up again. This morning I was in such a coffee shop without Internet, but was still able to fire up the sample app and grab a screen shot for the new BusyIndicator control that’s in the Silverlight Toolkit now.

Any interest in an Out of Browser Helper Control?

One thing I’ve been wondering if whether an ‘OutOfBrowserHelper’ control would be a useful, and quick, control for us to turn around inside the Silverlight Toolkit: something that has a very small scope, specific purpose, and will save developers time.

I’m imaging that this would wrap up the update logic, potentially offer the Install button, and other core services. I don’t know how practical it is, but I’d be interested in thoughts out there. Later in this post I talk about what all you need to do to enable the right Out of Browser update pattern in your apps.

I’ve created a Wishlist Feature request on the Silverlight Toolkit issue tracker to see if anyone else thinks it would be interesting…

A well-designed app that looks great in the browser looks great outside of it, too. What I like most about the Silverlight Out of Browser feature, compared to others, is that you don’t need to install anything else: no special runtime, no User Account Control permission, etc – since those apps run in the same security sandbox that Silverlight apps do while hosted in the Silverlight plugin.

This post is specific to that nice, simple Out of Browser support in Silverlight 3. For the hardcode developers out there, and some very interesting scenarios, Silverlight 4 adds a special elevated trust mode. That mode is outside the scope of this post.

Enabling Out of Browser for your own applications

A key feature in Silverlight 3, it takes about half an hour to enable Out of Browser if you’re a developer and looking to create your own graphics for the experience. Your users will notice that you have no design talent, but that is half the fun. Also, this is why “battleship gray” is so prevalent in Windows today.

If you have graphic assets from your designers, you can add the feature in about 2 minutes.

Here’s the technical set of hoops you need to do to define the Out of Browser metadata for your app.

Using Visual Studio 2008 or Visual Studio 2010 Beta 2

• First off, once you have the Silverlight Tools installed, just right-click on the project file in the Solution Explorer.
• Then, navigate to the Silvelright tab.
• Check the ‘Enable running application out of the browser’ option. This option will not be available if the ‘Reduce XAP size by using application library caching’ option is checked, fyi.
• Click the ‘Out-of-Browser Settings’ button.

This window will then allow you to set the Out of Browser information, such as a nice quick blurb about the app, the application title, and other basics. This data is all stored in the .\Properties\OutOfBrowserSettings.xml in your project directory structure.

You’ll need to have those icons ready at this point.

Click OK, and that is it: your application can now be taken out of the browser!

OutOfBrowserSettings.xml

This file should be placed inside your Properties folder of the Silverlight application project. Visual Studio will create it for you when you enable the experience, and in fact the Silverlight Tools even offer tooling to easily modify these properties. If you author it by hand, the file is of build type ‘None’, and hooked up inside the .csproj or VB project through these properties:

    <EnableOutOfBrowser>true</EnableOutOfBrowser>
    <OutOfBrowserSettingsFile>Properties\OutOfBrowserSettings.xml</OutOfBrowserSettingsFile>

Here’s what it looks like for the Silverlight Toolkit. We’ve defined the expected 16×16, 32×32, 48×48, and 128×128 brand icons. The icons are included in the project and marked as ‘Content’ in the Visual Studio properties dialog, so that they are in the Xap at the end of the build process.

<OutOfBrowserSettings ShortName="Silverlight Controls Browser" EnableGPUAcceleration="True" ShowInstallMenuItem="True">
  <OutOfBrowserSettings.Blurb>Sample explorer for the controls and features found in the Silverlight Toolkit and Silverlight SDK.</OutOfBrowserSettings.Blurb>
  <OutOfBrowserSettings.WindowSettings>
    <WindowSettings Title="Silverlight Controls Browser" />
  </OutOfBrowserSettings.WindowSettings>
  <OutOfBrowserSettings.Icons>
    <Icon Size="16,16">Toolkit16.png</Icon>
    <Icon Size="32,32">Toolkit32.png</Icon>
    <Icon Size="48,48">Toolkit48.png</Icon>
    <Icon Size="128,128">Toolkit128.png</Icon>
  </OutOfBrowserSettings.Icons>
</OutOfBrowserSettings>

Other options

There are several additional Out of Browser options to chose from. The Silverlight 4 Beta also adds the elevated trust option here.

Use GPU Acceleration: Check this to enable acceleration if your application will benefit from this.

Show install menu: By default selected, this adds the option to Install the app (and take it Out of Browser) to the right-click menu for your Silverlight application.

If you decide not to show the install menu, you’ll need to implement your own user interface to show an Install button or other experience.

The one included in the Silverlight Toolkit sample app is a good example – implemented in Welcome.xaml and Welcome.xaml.cs, it is aware of the state of the running application and whether to offer the install option or not.  

Implementing all the necessary things to make Out of Browser shine

Tim Heuer offers important information about making the Out of Browser experience world-class. For instance, you need to actually have you app asynchronously check for updates, and offer information about the availability of any updates.

• You need to call CheckAndDownloadAsync and react to that in your user interface
• You should check the InstallState if you want to offer different user interfaces depending on the Out of Browser state

Tim also has a recommended pattern for effectively forcing an app to only be available Out of Browser, similar to the experience you might find with other popular apps that live outside of the browser.

Here’s the App.xaml.cs file from the Silverlight Toolkit controls sample browser, to give you an idea of what we do. We’re only showing a MessageBox when an update becomes available, but you can make the experience a little richer if needed (see father down the post for that).

// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Public License (Ms-PL).
// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
// All other rights reserved.

using System;
using System.Windows;
using System.Collections.Generic;
using System.Linq;

namespace System.Windows.Controls.Samples
{
    /// <summary>
    /// System.Windows.Controls samples application.
    /// </summary>
    public partial class App : Application
    {
        /// <summary>
        /// Initializes a new instance of the App class.
        /// </summary>
        public App()
        {
            if (App.Current.InstallState == InstallState.Installed)
            {
                App.Current.CheckAndDownloadUpdateCompleted += OnCheckAndDownloadUpdateCompleted;
                App.Current.CheckAndDownloadUpdateAsync();
            }

            Startup += delegate
            {
                RootVisual = new SampleBrowser(SampleTreeItems);
            };
            InitializeComponent();
        }

        /// <summary>
        /// Checks for the update completed event.
        /// </summary>
        /// <param name="sender">The source object.</param>
        /// <param name="e">The event arguments.</param>
        private void OnCheckAndDownloadUpdateCompleted(object sender, CheckAndDownloadUpdateCompletedEventArgs e)
        {
            if (e.UpdateAvailable)
            {
                MessageBox.Show("An application update has been downloaded and "
                              + "will be available the next time you start the "
                              + "sample application.");
            }
            else if (e.Error != null)
            {
                MessageBox.Show("While checking for an application update, the "
                              + "following message was encountered:"
                              + Environment.NewLine
                              + Environment.NewLine
                              + e.Error.Message);
            }
        }
    }
}

Offering a button experience for taking the app Out of Browser

Although you could just offer the experience in the right-click context menu of your Silverlight app in the browser, that’s not a very well-advertised and visual feature. For the samples app, we expose a button to “Install” the app on the machine.

We want to be able to update that offering UI in real-time, so once the user takes the app out of browser, the Install button is no longer visible.

We do this by subscribing in the Welcome.xaml.cs page to the OnInstallStateChanged event of the Application:

// Make sure that we are connected to the installation state change
// at least once.
Application.Current.InstallStateChanged += OnInstallStateChanged;

And our Button has an event handler attached to start the actual install. The install call needs to happen in a user-initiated action: you can’t just call it whenever you like, but instead it needs to be placed somewhere in response to the user making a conscious installation decision:

/// <summary>
/// Installs the application.
/// </summary>
/// <param name="sender">The source object.</param>
/// <param name="e">The event arguments.</param>
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Event connected in XAML.")]
private void InstallSamplesClick(object sender, RoutedEventArgs e)
{
    Application.Current.Install();
}

When they click that button, they’ll see the Consent Experience for the app. The clear and concise consent dialog is powered by Silverlight, but you’re able to customize the graphic displayed with your own designer brand asset:

And then we are able to react to that by manually changing text, enabled status, visibility, etc. I’m sure a data binding expert would be able to make this example a little more attractive looking, but the code works!

/// <summary>
/// Shows or hides the installation button.
/// </summary>
/// <param name="sender">The source object.</param>
/// <param name="e">The event data.</param>
private void OnInstallStateChanged(object sender, EventArgs e)
{
    switch (App.Current.InstallState)
    {
        case InstallState.Installing:
            InstallButton.Visibility = Visibility.Visible;
            InstallButton.IsEnabled = false;
            InstallButton.Content = "Installing...";
            break;

        case InstallState.Installed:
            InstallButton.Visibility = Visibility.Collapsed;
            InstallText.Text = "The samples have been installed on this computer.";
            break;

        case InstallState.NotInstalled:
            InstallButton.Visibility = Visibility.Visible;
            InstallButton.IsEnabled = true;
            break;

        case InstallState.InstallFailed:
            InstallButton.Visibility = Visibility.Collapsed;
            InstallText.Text = "The Out of Browser installation failed.";
            break;
    }

    InstallApplicationPanel.Visibility = App.Current.IsRunningOutOfBrowser ? Visibility.Collapsed : Visibility.Visible;
}

A smoother notification method

Since most users aren’t going to immediately want to close the app they are working with, when an update becomes available, you’ll realize that the MessageBox.Show(…) route for the notification is jarring and rather inappropriate.

If you instead embed that information inside of your user interface, it can be simple “FYI” that is not as abrupt.

Here’s a simple use: if your root visual for the app contains a DockPanel, you could have a collapsed user interface element for displaying important messages, such as the availablility of an update.

Here’s what my UI might look like when a new version is available:

This user interface is accomplished with the toolkit’s DockPanel control, plus a little code behind. Here is the main application XAML:

<controlsToolkit:DockPanel Background="White">
    <!-- Out of Browser Notification -->
    <Border Height="32"
            BorderBrush="#b4a555"
            BorderThickness="1"
            x:Name="OutOfBrowserNotification"
            Visibility="Collapsed"
            controlsToolkit:DockPanel.Dock="Top">
        <Grid>
            <Grid.Background>
                <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
                    <GradientStop Color="#fff6bd" Offset="0" />
                    <GradientStop Color="#ffec82" Offset="1" />
                </LinearGradientBrush>
            </Grid.Background>
            <Grid.ColumnDefinitions>
                <ColumnDefinition />
                <ColumnDefinition Width="24" />
            </Grid.ColumnDefinitions>
            <StackPanel Orientation="Horizontal">
                <TextBlock FontWeight="Bold"
                           VerticalAlignment="Center"
                           Text="Update Notification:"
                           Margin="5" />
                <TextBlock VerticalAlignment="Center">The next time you use
                    this app, you'll be on the hot new version.
                </TextBlock>
            </StackPanel>
            <TextBlock Grid.Column="1"
                       HorizontalAlignment="Center"
                       VerticalAlignment="Center"
                       FontWeight="Bold"
                       Text="X"
                       Padding="6"
                       MouseLeftButtonDown="OnCloseUpdateNotification"
                       />
        </Grid>
    </Border>

    <Grid x:Name="LayoutRoot">
        <Button Content="Your Application Goes Here"
                Opacity=".4"/>
    </Grid>
</controlsToolkit:DockPanel>

So, except when an update is available, the top notification section would not even be taking up any space. So here’s the code that responds to the application’s CheckAndDownloadUpdateCompleted event:

private void OnCheckAndDownloadUpdateCompleted(object sender, CheckAndDownloadUpdateCompletedEventArgs e)
{
    if (e != null && e.UpdateAvailable)
    {
        OutOfBrowserNotification.Visibility = System.Windows.Visibility.Visible;
    }
}

Behind the scenes, I’ve wired up a fake close button, so users can dismiss the window at their leisure:

private void OnCloseUpdateNotification(object sender, MouseButtonEventArgs e)
{
    OutOfBrowserNotification.Visibility = System.Windows.Visibility.Collapsed;
}

For more information about the Silverlight Out of Browser feature, please check out the official MSDN Library documentation, “Out-of-Browser Support”.

Out of Browser and Application Library Caching: Mutually Exclusive

You may have also read that we’re finally shipping the application library cache support files in the November 2009 release of the Silverlight Toolkit. Unfortunately, we haven’t enabled library cache support for the samples application, because we feel the value provided by Out of Browser trumps the cached library scenario.

When you setup Out of Browser support, you cannot enable Application Library Caching. The Visual Studio project properties are good about enforcing this.

The reason is that the Out of Browser experience requires that the entire Xap be self-contained, and when you enable application library caching for a project, it drops a bunch of .Zip files (zipped up versions of those dependent libraries) alongside the main app’s .Xap file. When Out of Browser, you may not always be able to download or grab those files.

Consider a Splash Screen if you have a large app that is Out-of-Browser enabled

I created a custom splash screen experience for the controls sample app that is hosted up on Silverlight.net, since the application is several megs. Your grandmother’s probably not interested in the control browser app, so don’t worry about those 14.4k modem users. My grandmother isn’t even interested, and she knows I work on this stuff!

The splash screen for the Silverlight Toolkit consists of a Silverlight Toolkit brand logo, a ton of TextBlocks, and I’m also using the native Grid to center the entire experience within the plugin. There’s a little JavaScript to update the text block with the percents, and the rest of the cycling animation is powered by several Storyboards that start when the page is initally loaded.

This is a good alternative to application library caching in some situations. Do remember to keep the splash screen small – users are much more interested in your app. Hopefully.

Download the Silverlight Toolkit November 2009 Release Today

The Silverlight Toolkit is a collection of Silverlight controls, components and utilities that help make Silverlight development a little easier, more fun, and add value outside the regular Silverlight release cycle.

The sixth release of the Silverlight Toolkit, the November 2009 release targets Silverlight 3. There is also a release available that targets the new Silverlight 4 Beta for developers.

Resources of note:

• Learn more about the Silverlight Toolkit
• Download the November 2009 Release
• Get started with Silverlight development
• Participate in the controls community at Silverlight.net
• Check out questions and answers on Stack Overflow using the ‘silverlight-toolkit’ tag
• The Issue Tracker can be used to report issues, add to the feature wish list, and vote on the work to be done by the Microsoft team

Hope you enjoy our new release!

It’s important to provide the user feedback that the UI is not hung, or crashed, but is in fact processing. This fills that void, and is really easy to get going with.

After some initial meetings with David, it became clear that the control would make a nice addition to the portfolio of valuable controls that are inside of the Silverlight Toolkit, so thanks to everyone who came together to get this added to the November release.

Quick guide to using the control

IsBusy

The key dependency property on the BusyIndicator control is the IsBusy bool property. It’s easy to data bind to your data model, or programmatically toggle on and off.

When toggled to true, the actual content of the BusyIndicator control (which itself is a ContentControl) will no longer be enabled.

Place your content inside the control

In the most simple use case, just place your content inside the control and bind to the model. When IsBusy is set to true, you’ll see the waiting user interface appear.

Your controls that are wrapped by the BusyIndicator control will not be enabled during the busy time, preventing the user from inadvertently altering the data state during the operation.

<Grid x:Name="LayoutRoot" Background="White">
    <controlsToolkit:BusyIndicator IsBusy="{Binding DataServicesAreBusy}">

        <!-- This button will not be enabled when IsBusy is set to True -->
        <Button Content="This is a button" HorizontalAlignment="Center"  VerticalAlignment="Center" Padding="8"/>

    </controlsToolkit:BusyIndicator>
</Grid>

Customizing the busy content

The entire thing is very customizable, you can use data templates and even retemplate the control. David Anson covered this in his post yesterday on the topic.

Here’s a quick example of changing the text that is displayed – the Content property can take any kind of content, so you could even put a quick game in there if you wanted to go overboard.

<Grid x:Name="LayoutRoot" Background="White">

    <controlsToolkit:BusyIndicator IsBusy="{Binding DataServicesAreBusy}">
            <controlsToolkit:BusyIndicator.BusyContent>
                <TextBlock Text="Reticulating Splines..."
                           FontSize="18"
                           FontWeight="Bold" />
            </controlsToolkit:BusyIndicator.BusyContent>

                <!-- This button will not be enabled when IsBusy is set to True -->
        <Button Content="This is a button" HorizontalAlignment="Center"  VerticalAlignment="Center" Padding="8"/>

    </controlsToolkit:BusyIndicator>
</Grid>

And here’s what that looks like in a real application when IsBusy is true:

Find out more in the Silverlight Controls Browser

Just like all other controls in the Silverlight core runtime, SDK, and the Silverlight Toolkit, you’ll find the Activity Control in the Silverlight Controls Browser. It is under the Toolkit tree view item, near the bottom of the list on the left part of the app.

Silverlight 3 samples are here.

Silverlight 4 Beta samples are here, if you’re a developer and have the Silverlight 4 Beta on your machine.

Where to find the control

You’ll find the BusyIndicator control in the System.Windows.Controls.Toolkit.dll assembly, documentation in the Silverlight Toolkit docs, a few unit tests, and yeah it’s in the sample browser as well. It lives in the System.Windows.Controls namespace.

Hope you enjoy having this control available in the Silverlight Toolkit!

Download the Silverlight Toolkit November 2009 Release Today

The Silverlight Toolkit is a collection of Silverlight controls, components and utilities that help make Silverlight development a little easier, more fun, and add value outside the regular Silverlight release cycle.

The sixth release of the Silverlight Toolkit, the November 2009 release targets Silverlight 3. There is also a release available that targets the new Silverlight 4 Beta for developers.

Resources of note:

• Learn more about the Silverlight Toolkit
• Download the November 2009 Release
• Get started with Silverlight development
• Participate in the controls community at Silverlight.net
• Check out questions and answers on Stack Overflow using the ‘silverlight-toolkit’ tag
• The Issue Tracker can be used to report issues, add to the feature wish list, and vote on the work to be done by the Microsoft team

Hope you enjoy our new release!

Kidding aside, yes, you can finally enable library caching when using the latest release. Since our installations are always side-by-side friendly, you should get this support immediately after installing the latest release that pairs with your Silverlight development environment.

Note that the Out of Browser feature of Silverlight is unavailable for your application if you use this feature, since key libraries need to be contained inside your Out of Browser Xap file.

Previously available only by blog, the application library cache files sit alongside the control, feature, and theme binaries for the Silverlight Toolkit and enable the Silverlight SDK to package up those components separately, improving application download and startup time in some situation for application users starting the second time they use your app.

Toolkit Libraries Supported

• Microsoft.Silverlight.Testing.dll
• Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll
• System.ComponentModel.Composition.Packaging.Toolkit.dll (Silverlight 4 Toolkit Only)
• System.Reactive.dll (Note: This is a pre-release version of the Reactive Framework at this time and supports the Drag and Drop features introduced in the last release)
• System.Windows.Controls.Data.DataForm.Toolkit.dll
• System.Windows.Controls.Data.Toolkit.dll
• System.Windows.Controls.DataVisualization.Toolkit.dll
• System.Windows.Controls.Input.Toolkit.dll
• System.Windows.Controls.Layout.Toolkit.dll
• System.Windows.Controls.Theming.Toolkit.dll
• System.Windows.Controls.Toolkit.dll

Toolkit Themes Supported

• System.Windows.Controls.Theming.BubbleCreme.dll
• System.Windows.Controls.Theming.BureauBlack.dll
• System.Windows.Controls.Theming.BureauBlue.dll
• System.Windows.Controls.Theming.ExpressionDark.dll
• System.Windows.Controls.Theming.ExpressionLight.dll
• System.Windows.Controls.Theming.RainierOrange.dll
• System.Windows.Controls.Theming.RainierPurple.dll
• System.Windows.Controls.Theming.ShinyBlue.dll
• System.Windows.Controls.Theming.ShinyRed.dll
• System.Windows.Controls.Theming.TwilightBlue.dll
• System.Windows.Controls.Theming.WhistlerBlue.dll

Size differences

Here’s a simple application with a chart, you can see that the .Xap file weighs in around 345 KB:

After enabling the application library cache support, check it out:

The core .Xap is now 41 KB. Of course, there are no time savings on the first download: all those other .Zip files with the extensions are downloaded as well. But if you update your .Xap file, you likely do not need to refresh the .Zip files with the cached libraries. So your users only download the new 41 KB on next visit after a change, instead of hundreds of kilobytes.

Sorry!
In retrospect, I admit that it’s quite embarrassing that we didn’t offer application library caching support right off-the-bat alongside the Silverlight 3 release. Having limited time and resources to deliver for each release, we’re not always able to get it all done.

Keep letting us know what you want us to work on by voicing your opinion on our blogs and by voting on the CodePlex Work Item Tracker (it tracks both feature requests and bugs).

Download the Silverlight Toolkit November 2009 Release Today

The Silverlight Toolkit is a collection of Silverlight controls, components and utilities that help make Silverlight development a little easier, more fun, and add value outside the regular Silverlight release cycle.

The sixth release of the Silverlight Toolkit, the November 2009 release targets Silverlight 3. There is also a release available that targets the new Silverlight 4 Beta for developers.

Resources of note:

• Learn more about the Silverlight Toolkit
• Download the November 2009 Release
• Get started with Silverlight development
• Participate in the controls community at Silverlight.net
• Check out questions and answers on Stack Overflow using the ‘silverlight-toolkit’ tag
• The Issue Tracker can be used to report issues, add to the feature wish list, and vote on the work to be done by the Microsoft team

Hope you enjoy our new release!

Here’s a link to the installer, if you don’t already have it on your system: http://www.microsoft.com/web/downloads/platform.aspx

Jump right to the toolkit install here: http://www.microsoft.com/web/gallery/install.aspx?appid=SilverlightToolkit
Or, a Twitter-friendly link: http://bit.ly/3eaT68

Simple installation experience

It’s quick and easy now to use the Silverlight Toolkit – no need to jump over to the CodePlex site.

Once starting the Web Platform Installer, you’ll find the Silverlight Toolkit under the ‘Web Platform’ tab, in the ‘Tools’ section:

The installation should only take a few seconds. Afterwards, you’ll find the controls inside Expression Blend 3, Visual Studio 2008 SP1 with the Silverlight Tools installed, and Visual Studio 2010 Beta 2.

About the Silverlight Toolkit

In case you’ve never used the Silverlight Toolkit, it’s never too late to start. The following controls have been part of the Silverlight Toolkit development process. You can find out more about the quality bands here.

Mature/SDK/Runtime AutoCompleteBox Calendar ChildWindow DataGrid DataPager DatePicker GridSplitter HeaderedItemsControl TabControl TreeView	Stable DockPanel Expander HeaderedContentControl Label NumericUpDown Viewbox WrapPanel
Preview Accordion Charting DataForm DomainUpDown ImplicitStyleManager LayoutTransformer Rating TimePicker TimeUpDown 11 designer visual themes	Experimental GlobalCalendar TransitioningContentControl TreeMap Drag and Drop support for items controls

More resources:

• You can also find the source code online here.
• Check out the Silverlight.net discussion forums for the controls
• There is an issue tracker page on CodePlex for reporting and voting on issues
• Read the changes between the July 2009 and October 2009 releases

You can also find out more about the Web Platform here and here. Hope this helps!

Here’s what you need to get going:

Download the Silverlight Toolkit installer for Silverlight 3 (source code included in the installer, or online here)
Silverlight.net discussion forums for the controls
Issue tracker page on CodePlex
Changes between the July 2009 and October 2009 releases

Our installations are side-by-side friendly, so even if you have a previous release, you’ll want to install this one for sure.

Here are a few highlights from this release:

Awesome Visual Studio 2010 design experience

The fully interactive design surface in Visual Studio 2010 really completes the Silverlight development experience. The Silverlight Toolkit contains a rich set of metadata that makes the controls even easier to use.

Drag & Drop

A set of drag and drop targets for ListBox, DataGrid, charts, etc., allows you to add drag & drop support to these controls in a single line of XAML (by enclosing them in a <toolkit:ListBoxDragDropDecorator /> element). Rich LOB-style apps are even easier to build now! Find out more here.

Charting improvements

Continued advancement of the charting APIs, optimized for extensibility and performance. Details.

About the Silverlight Toolkit

In case you’ve never used the Silverlight Toolkit, here’s what you’ll find inside:

Hope you enjoy the new features!

NBC has really made a great call here to use Silverlight, paired with Smooth Streaming technology. The rich Silverlight app is very nice, Vertigo did a great job building it to tie everything together.

Accordion control for the win!

One thing that I was really happy to notice in the player app was one of the Preview controls from the Silverlight Toolkit, so I just wanted to take a minute to point that out…

Here’s a screen shot of the player. On the far right corner, the “Stats” tab contains team stats and other information. The user interface control that lets you decide between the sets of data in this example is the Silverlight Toolkit’s Accordion control.

It’s a nice vote of confidence, seeing this control in use – as a Preview control (quality band definitions here), it is intended to meet basic usage scenarios, has been released to get feedback, and can be considered an ‘Alpha’ quality control. Maybe we’ll need to prop that up a level with the next release, it looks to be working great!

If you’ve used the control before, you’ll probably recognize that there are two AccordionItems: one with the header ‘Offensive Leaders’, another with the header ‘Team Stats’. The developers at Vertigo have done a great job of re-templating the control to make it look really nice, plus setup data binding all these fields inside the content of the accordion items.

The Accordion control was developed by Ruurd Boeke, a member of the Silverlight team. He’s created a great set of guides on the control, I invite you to check them out:

• Part 1 – accordion
• Part 2 – accordion item
• Part 3 – expandable content control
• Part 4 – retemplating, real world example
• Part 5 – accordion button

To get the control, download and install the latest Silverlight Toolkit release. The Accordion control is available for both Silverlight 2 and Silverlight 3 development.

Next game is 9/20 at 8:00 PM ET

Tune in for the next football game, where the New York Giants will play the Dallas Cowboys. Watch it here.

Learn more about the Vertigo player

To learn more about the awesome set of features in this online football experience, check out Bob Cowherd’s blog post that goes through the special features. The devs at Vertigo are top-notch and have done an amazing job pulling this all together.

I really would like to thank each and every person who’s been able to use the tool. I really appreciate the feedback and conversations many of us have had to work to make improvements over the years (Wow, has it been so long?!).

What’s this all about?

Each year, Microsoft holds an Engineering Forum, jam-packed with sessions and talks much like an industry conference, focusing on everything from the core engineering disciplines to trustworthy computing and everything inbetween.

During the forum, a select set of awards are given out to a select innovations, recognizing teams and individuals for their successful engineering feats helping the company to ship safer, quicker, and better all-around software to the world. The criteria is challenging, nomination count very high, and the selection process intense.

Although the test framework wasn’t selected as a finalist, it did receive honorable mention, which is enough to make me happy.

It was also great hearing a little bit from some of the senior engineering leaders inside the company, including Ray Ozzie and Jon DeVaan.

A lot of great tools, processes, and accomplishments have been recognized over the years, and the bar is high, with great tools like Script#, Nikhil Kothari’s famous C#/JavaScript tool, as well as Brad, Krzysztof, and Michael’s FxCop (now built into Visual Studio).

I hope that, with some of the plans I have in place for the framework, that maybe someday it’ll be a finalist for a future award of this nature – there’s a nice shiny crystal award that would look great on the bookshelf!

What’s the Silverlight Unit Test Framework?

The Silverlight Unit Test Framework is a simple unit and functional test system specially designed for Silverlight, building on existing desktop unit testing knowledge and metadata. You’ll find the test framework inside of the Silverlight Toolkit’s source code package, and in use in a lot of places.

Thanks for everyone helping to make this a success!

It demonstrates simple concepts for linking files from a Silverlight to WPF project, using partial classes and partial methods, preprocessor directives, and other tools to create projects that work throughout the Microsoft Client Platform.

Silverlight sample application

WPF sample application -100% the same source

Download the samples – Zip, 596 KB
The Zip contains the following work:

• Toolbar control for Silverlight and WPF
• Sample application for the Toolbox
• Continuum application – same XAML and CS shared between a Silverlight and WPF application that uses the DataGrid, charting controls, and our custom Toolbar control
• Value-add code, Awesome.cs, that adds some simple functionality to the WPF application only

Hope this helps.

This provides a very nice experience when using Visual Studio 2008 and Expression Blend 3, since the Toolkit’s controls appear alongside all other Silverlight SDK controls now.

I wanted to take a few minutes and record a few questions and answers about the new experience. Let me know if there are some other questions you’d like answered.

Why are there two setup downloads for the March 2009 release?

The March 2009 release is available for targeting Silverlight 2 applications (recommended for most developers and designers working on current production Silverlight 2 apps), and a Silverlight 3 Beta release.

Since the target platform is important, you can make a choice. Of course, both the Silverlight 2 and Silverlight 3 Beta installs for the Silverlight Toolkit support side-by-side; however, the Visual Studio 2008′s Silverlight Tools do not support “multi-targeting,” so you really should decide and stick to a single target development environment for Silverlight coding today.

What are the system requirements?

The Silverlight Toolkit only requires a recent version of the .NET framework to install. However, for the best experience, you should have one of these development environments installed and configured:

• Visual Studio 2008 SP1 with the Silverlight Tools (Silverlight 2 or Silverlight 3 Beta)
• Visual Web Developer Express with the Silverlight Tools (Silverlight 2 or Silverlight 3 Beta)
• Expression Blend 2 SP1 with Silverlight 2
• Expression Blend 3 MIX ’09 Preview with Silverlight 3 Beta

More information about these tools and downloads is available at http://silverlight.net/getstarted/silverlight3/default.aspx.

You can install the Silverlight Toolkit before or after the Silverlight Tools installation.

What’s with the namespace change to System.Windows.Controls?

As the Silverlight Toolkit has begun delivering controls into the official Silverlight SDK, it became apparent that we should be consistent across the Silverlight platform with regard to the namespace used for the Microsoft controls. As a result, we decided to make this namespace change along with the new “.Toolkit” assembly name scheme.

Where’s the AutoCompleteBox control? How about TreeView?

Some of the “Stable” controls were moved to the official Microsoft Silverlight 3 Beta SDK, since they are trending towards the “Mature” quality band. As a result, the controls live in different assemblies depending on whether you are performing Silverlight 2 or Silverlight 3 Beta development.

In the Silverlight 2 Toolkit March 2009 release, AutoCompleteBox is in System.Windows.Controls.Input.Toolkit. TreeView is in System.Windows.Controls.Toolkit.

In the Silverlight 3 Toolkit March 2009 release, AutoCompleteBox is in System.Windows.Controls.Input. TreeView is in System.Windows.Controls. These assemblies are part of the Silverlight 3 Beta SDK and DO NOT require installation of the Silverlight Toolkit.

The Silverlight 2 controls are compatible with Silverlight 3, so existing applications will continue to work – but we do highly recommend that you update to the appropriate Silverlight Toolkit for your target Silverlight version, since we do add version-enhanced features, such as animation easing for the Silverlight Toolkit charts in the Silverlight 3 Beta.

More information about the assembly and namespace name changes is available in this post by Shawn Burke.

What is installed with the Silverlight Toolkit now?

You’ll find the same basics as before, plus some. You’ll find these in the “Microsoft Silverlight 3 Toolkit March 2009″ (or similarly named folder for the Silverlight 2 version) folder in your Start Menu.

• New “Welcome” page with general information about the release, plus a link to the breaking changes and release notes for the release.
• Links to the CodePlex site for the Toolkit, plus the Silverlight.net discussion forums
• A link to the sample application for the Toolkit, served from the local system
• Links to Zip files containing the control source code and/or the sample source code
• The documentation for the Toolkit controls in CHM format. The documentation file no longer requires the “Unlock” workaround step on Windows Vista and Windows 7. Do note that the documentation for former Silverlight Toolkit controls that now appear in the Silverlight 3 SDK, such as AutoCompleteBox, are now located in the official Silverlight documentation. An offline download of the SDK documentation is also available.

What rocked about the Zip?

Well, in my mind, it was:

• Transparent experience
• Nothing fancy
• Lightweight. Nothing to install, so if you didn’t want it anymore, you could just delete the files, for instance.

What was so bad about the Zip?

• No integration into Visual Studio or Expression Blend out-of-the-box, without doing some manual file copy or registry work
• Confusing to users used to a setup experience
• CHM documentation files downloaded in a Zip require “Unlocking” before they work. Until then, they appear broken.

Would you consider offering releases in a Zip file, optionally, still?

We’re open to the idea. Especially now that there’s an Eclipse Silverlight development experience, we do need to be mindful of the need to use the releases on other platforms.

Since our packaging infrastructure was initially designed to output these nice .Zip files, it wouldn’t be too tough for us to get this going. We’ll see what the customer requests look like.

How do I select whether I want to get the source code to the controls?

There is an installation option for a feature called “Source code,” you can click on the box to the left of the item and remove the component if you would not like to install the source package.

If you do select this feature (per the default), a .Zip file is placed on the system that contains the source code. You can extract the zip file into a location of your selection to build or view the source.

As always, the source is also available on the Silverlight Toolkit CodePlex site.

What about Microsoft Expression Blend integration?

The Blend 3 MIX09 Preview release includes support for having the Silverlight Toolkit appear in the “Custom Controls” tab of the Asset Library. This is only available for Silverlight 3 Beta, not the Silverlight 2 / Expression Blend 2 product.

There is some really great design time support in this release. For instance, if you just drop a “Chart” control onto your Blend design canvas, you’re greeted with a chart that has simple design time data! It might look a little like one of those “the most bars anywhere” cell phone commercials, but it is very helpful for styling.

What powers the installer?

We leveraged the open source Windows Installer XML (WiX) toolset, an excellent and easy way to build Windows Installer packages. Kudos to Eric St. John, a Microsoft developer who contributes to WiX, for excellent advice, btw!

This was important to our small development team, since we wanted to spend time working on new features like awesome design-time integration and new controls like accordion instead of assigning a developer to the setup full-time.

Hope you like the new experience. Let us know!

One of the most important messages that I had during the talk is the flexibility that the Microsoft Client Platform enables: you can be a Rich Internet App developer today, and build an enterprise Line of Business app tomorrow, since so many of the concepts, APIs, and ideas are shared between these frameworks.

Download session deck (4.7 MB PowerPoint 2007)
View the session on the VisitMix.com site: http://videos.visitmix.com/MIX09/T87F

Check out other awesome Silverlight, WPF, and Expression. Hope this helps. Let me know what you think.

Part of the Silverlight SDK can be copied into your source tree to build projects on machines without requiring Silverlight or the SDK. This is great for continuous integration environments and build labs where having an independent build is key.

I’ve compiled a quick screencast (6:07) that demonstrates preparing a directory to check in the proper SDK components, updating a C# project file, and then proving the result by uninstalling the Silverlight SDK.

Walkthrough video

6:07, 60MB, HD 720p (Download WMV)

Properties respected by the Silverlight MsBuild targets

The Silverlight build system respects these build properties that can override the standard SDK locations:

The runtime version is used when generating the application manifest and HTML test page.

Preparing your source enlistment

On the Toolkit, we have a directory of external tools and engineering resources. One of these contains the Silverlight SDK’s assemblies, libraries, and build scripts, as shown in the video.

• Create a directory to store the MsBuild assets for Silverlight, and copy in the files from %programfiles%MSBuild\Microsoft\Silverlight\v2.0.
• Copy the “Reference Assemblies” directory from %programfiles%\Microsoft SDKs\Silverlight\v2.0\ into the tools directory.
• Copy the “Libraries” directory from %programfiles%\Microsoft SDKs\Silverlight\v2.0\ into the directory.

You can then use relative paths in your projects or custom build targets to get things rolling.

Updating projects

Depending on your build system, you’ll want to update your custom targets or project files. In the video I’m simply modifying the .csproj file to add the necessary properties and modify the import statement.

Add properties

I’d scroll through the .csproj and insert the new properties right before the Import statement that pulls in the Silverlight build targets. Here are the properties defined; the SilverlightBuildResources property is my own made-up name that I’m using to store the relative path to the new building bits:

  <PropertyGroup>
    <SilverlightBuildResources>..\Build\</SilverlightBuildResources>
    <TargetFrameworkDirectory>$(SilverlightBuildResources)Reference Assemblies\</TargetFrameworkDirectory>
    <TargetFrameworkSDKDirectory>$(SilverlightBuildResources)Libraries\Client\</TargetFrameworkSDKDirectory>
    <SilverlightRuntimeVersion>2.0.31005.0</SilverlightRuntimeVersion>
  </PropertyGroup>

Import the new Silverlight build target

Silverlight projects import the Silverlight MsBuild targets from the central MsBuild extensions directory, so we just need to update the import to instead come from the source tree:

  <Import Project="$(SilverlightBuildResources)Microsoft.Silverlight.CSharp.targets" />
  <!--
	This is the default provided for new Silverlight projects:
  <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight\v2.0\Microsoft.Silverlight.CSharp.targets" />
  -->

Build

You’re all set! And, for future reference: you can use this to build applications targeting multiple versions of Silverlight from the same tree. But more on that later.

I’ve compiled a quick screencast (6:07) that demonstrates preparing a directory to check in the proper SDK components, updating a C# project file, and then proving the result by uninstalling the Silverlight SDK.

Walkthrough video

6:07, 60MB, HD 720p (Download WMV)

Properties respected by the Silverlight MsBuild targets

The Silverlight build system respects these build properties that can override the standard SDK locations:

The runtime version is used when generating the application manifest and HTML test page.

Preparing your source enlistment

On the Toolkit, we have a directory of external tools and engineering resources. One of these contains the Silverlight SDK’s assemblies, libraries, and build scripts, as shown in the video.

• Create a directory to store the MsBuild assets for Silverlight, and copy in the files from %programfiles%MSBuild\Microsoft\Silverlight\v2.0.
• Copy the “Reference Assemblies” directory from %programfiles%\Microsoft SDKs\Silverlight\v2.0\ into the tools directory.
• Copy the “Libraries” directory from %programfiles%\Microsoft SDKs\Silverlight\v2.0\ into the directory.

You can then use relative paths in your projects or custom build targets to get things rolling.

Updating projects

Depending on your build system, you’ll want to update your custom targets or project files. In the video I’m simply modifying the .csproj file to add the necessary properties and modify the import statement.

Add properties

I’d scroll through the .csproj and insert the new properties right before the Import statement that pulls in the Silverlight build targets. Here are the properties defined; the SilverlightBuildResources property is my own made-up name that I’m using to store the relative path to the new building bits:

  <PropertyGroup>
    <SilverlightBuildResources>..\Build\</SilverlightBuildResources>
    <TargetFrameworkDirectory>$(SilverlightBuildResources)Reference Assemblies\</TargetFrameworkDirectory>
    <TargetFrameworkSDKDirectory>$(SilverlightBuildResources)Libraries\Client\</TargetFrameworkSDKDirectory>
    <SilverlightRuntimeVersion>2.0.31005.0</SilverlightRuntimeVersion>
  </PropertyGroup>

Import the new Silverlight build target

Silverlight projects import the Silverlight MsBuild targets from the central MsBuild extensions directory, so we just need to update the import to instead come from the source tree:

  <Import Project="$(SilverlightBuildResources)Microsoft.Silverlight.CSharp.targets" />
  <!--
	This is the default provided for new Silverlight projects:
  <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight\v2.0\Microsoft.Silverlight.CSharp.targets" />
  -->

Build

You’re all set! And, for future reference: you can use this to build applications targeting multiple versions of Silverlight from the same tree. But more on that later.

It’d be nice for us to offer samples, control examples, and other Silverlight content on the CodePlex site. Does that mean embedded Silverlight <object /> tags or iframes? Not sure, but it would be nice to have some option here.

I think this would be a nice feature for many more projects than just ours.

One of the fun things about CodePlex is that it is all about the entire community, and we ("Microsoft") don’t hold any special strings here. So, I’m asking for your assistance this holiday season!

If you’re a CodePlex user, it would rock if you’d just spend a minute and vote for the ‘Silverlight hosting’ feature request on the site at http://www.codeplex.com/CodePlex/WorkItem/View.aspx?WorkItemId=10303.

Thanks for your assistance, and happy holidays,
- Jeff