How to Deploy Silverlight Applications

You can deploy a Silverlight application to a Web site, as you would an ASP.NET MVC

application. However, you'll need to ensure the MIME type and policy is in place to

ensure the application will run outside of your development environment.

 

If you're running IIS 7, Silverlight will already be set up. However, if you're

deploying to an IIS 6 server, you must set the MIME type for *.xap files to application/

x-silverlight-app as described in the following steps:

 

1. Open Administrative Tools | Internet Information Services (IIS) Manager.

2. Under Web Sites, in IIS, right-click on the Web site for your Silverlight application and

select Properties.

3. Click the HTTP Headers tab, click MIME Types, and click New.

4. Type .xap as the Extension and application/x-silverlight-app as the MIME type.

Click OK three times to close all windows and close IIS.

Additionally, you must have a policy file in the root folder of your Web site. There

are two types of policy files you can use: crossdomain.xml or clientaccesspolicy.xml.

 

The crossdomain.xml policy was created for Adobe Flash applications and can be used

with Silverlight applications too. Here's an example:

 

<!DOCTYPE cross-domain-policy

SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">

<cross-domain-policy>

<allow-access-from domain="*" />

<allow-http-request-headers-from domain="*" headers="*" />

</cross-domain-policy>

 

When designing Silverlight, Microsoft recognized that the crossdomain.xml

file wasn't flexible enough and added support for another type of policy called

clientaccesspolicy.xml. Here's an example:

 

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

<access-policy>

<cross-domain-access>

<policy>

<allow-from http-methods="*">"

<domain uri="*"/>

</allow-from>

<grant-to>

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

</grant-to>

</policy>

</cross-domain-access>

</access-policy>

 

This clientaccesspolicy.xml listing allows all domains to access all site content that

isn't already secured by other means. You can restrict access by replacing the * in the

domain uri with an allowable domain. Further, you can replace the resource path with a

path on the site to restrict access to specific folders. Add more policy elements to this file

to add more domains and paths.

Running Silverlight Out-of-Browser (OOB)

A new capability of Silverlight 3 is running out-of-browser, meaning that users can load

your application onto their desktop without needing to visit the hosting site. To implement

OOB, open the Silverlight application properties by double-clicking the Properties folder

in Solution Explorer. You'll see a window similar to Figure 1.

Most of the properties in Figure 1 have been covered in previous chapters. What's

different is the section on Silverlight build options, which allows you to set the version

and check the box to reduce the size of the *.xap file through caching. However, leave the

option to reduce the *.xap file size unchecked if running OOB because it's not compatible

Figure 1 Silverlight properties

Figure 2 Out-of-browser settings

with OOB. The Manifest file describes the contents of the *.xap file. To enable OOB,

check the box "Enable running application out of the browser." Then click the Out-Of-

Browser Settings button to display the window shown in Figure 2.

The OOB settings in Figure 2 allow you to set information for the application,

the size it will take when running, and variously sized icons that Windows will display.

Setting GPU acceleration allows the application to take advantage of the local hardware to

optimize graphics.

After you save OOB settings and run the application, the user can right-click the

application running in the browser and select Install SilverlightDemoCSApplication Onto

This Computer, as shown in Figure 3.

Figure 3 Choosing OOB

The next window you'll see gives options for adding the application to the Start menu

and an icon on the desktop. Figure 3 shows that both options are checked.

When you click OK, Silverlight creates a Start menu item and adds the application

to the desktop, as shown in Figure 4. When you start the application, it will run in a

window rather than the browser.

Figure 4 Executing an OOB application

Silverlight in Visual Studio

Silverlight is a Web technology that allows you to add a rich user experience to Web

applications. It uses XAML, just like WPF applications, but runs in a Web page

supported by ASP.NET.

Other parts of this book prepare you for working with Silverlight. Since Silverlight

uses XAML, you can review XML and XAML articals  to get up-to-speed on XAML essentials.

Silverlight also has many features in common with WPF. Therefore, it would be useful to

review WPF article  before reading this article. What you'll learn in this article is how VS

helps you create a Silverlight project, how to add controls to the Silverlight designer, and

how to deploy Silverlight applications.

Starting a Silverlight Project

As when starting other projects, you can select File | New | Project or press CTRL-SHIFT-N;

you then select a Silverlight application in the New Project window. After you set up

the project with a name and folder, VS will display another window for configuring the

Silverlight application, shown in Figure 1.

Silverlight gives you the option to create a Web site at the same time as you create the

Silverlight application. You can opt not to create the Web site, but ultimately, you'll need

to host your Silverlight application on a Web page. There is an alternate Web technology

based on ASP.NET Web forms, but this book concentrates on the ASP.NET MVC Web

development model, discussed in MVC article, which is why you see the New Web project

type set to ASP.NET MVC Web Project. Click OK to create the Silverlight application,

shown in Figure 2. You'll also see a screen asking if you want to create a unit test

project, which is the same window discussed in mvc article. Click OK to continue.

Figure 1 Creating a new Silverlight application

Figure 2 A new Silverlight project

Similar to WPF applications, Silverlight applications start with a MainPage.xaml file

and an App.xaml file, where App.xaml runs to initialize the application and MainPage

.xaml contains the display page. The Web site is a typical ASP.NET MVC application,

except that it does have a test page that hosts the Silverlight application, SilverlightDemo

CSTestPage.aspx (SilverlightDemoVBTestPage.aspx for VB). There's also a Silverlight

DemoCSTestPage.html (SilverlightDemoVBTestPage.html for VB), which performs the

same function as the SilverlightDemoCSTestPage.aspx (SilverlightDemoVBTestPage

.aspx for VB) hosting Silverlight, except that the *.html version uses JavaScript and the

HTML object tag to host Silverlight. Listing 1 shows the contents of the test page and

how it hosts the Silverlight application. There is no C# or VB version of Listing 1

because the code is XAML, which works exactly the same with either language.

Listing 1 Hosting a Silverlight application on a Web page

<%@ Page Language="C#" AutoEventWireup="true" %>

<!DOCTYPE html PUBLIC

"-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >

<head runat="server">

<title>SilverlightDemoCS</title>

<style type="text/css">

// css styles omitted

</style>

<script type="text/javascript" src="Silverlight.js"></script>

<script type="text/javascript">

function onSilverlightError(sender, args) {

// error handling code omitted

}

</script>

</head>

<body>

<form id="form1" runat="server" style="height:100%">

<div id="silverlightControlHost">

<object data="data:application/x-silverlight-2,"

type="application/x-silverlight-2"

width="100%" height="100%">

<param name="source"

value="ClientBin/SilverlightDemoCS.xap"/>

<param name="onError" value="onSilverlightError" />

<param name="background" value="white" />

Designing Silverlight Applications 289

<param name="minRuntimeVersion" value="3.0.40818.0" />

<param name="autoUpgrade" value="true" />

<a

href="http://go.microsoft.com/fwlink/?LinkID=149156&v=3.0.40818.0"

style="text-decoration:none">

<img src="http://go.microsoft.com/fwlink/?LinkId=161376"

alt="Get Microsoft Silverlight"

style="border-style:none"/>

</a>

</object>

<iframe id="_sl_historyFrame"

style="visibility:hidden;height:0px;width:0px;border:0px">

</iframe>

</div>

</form>

</body>

</html>

Listing  1 contains an object tag that hosts the Silverlight application. This object

tag has various parameters, which are described in Table 10-1.

You can run the application and view the Web page, but there isn't much to see yet.

The next section starts you in the direction of making something useful happen with

Silverlight by reviewing the Designer.

Navigating the Silverlight Designer

The underlying technology for displaying the UI is XML Application Markup Language

(XAML), pronounced "Zamel." Appendix A contains an introduction to XML, and

Appendix B contains an introduction to XAML if you need to obtain a basic understanding

of these two technologies. It would really be helpful for you to review Chapter 8 because

you'll find many of the same controls for layout and display in both Silverlight and WPF.

The Silverlight Designer is very similar to the WPF Designer in how you work with

controls. Drag and drop from the Toolbox, configure Grids, interact with XAML, and set

properties in exactly the same way with Silverlight as with WPF. Since there are so many

similarities, I won't repeat the material covered in WPF article but will build upon previous

material, showing you what is special about Silverlight.

Using Silverlight Controls

Silverlight has strong multimedia support through streaming audio and video. In fact,

the Toolbox has controls that make it easy to host your own videos and control the user

experience for playing videos. The following steps show how to design a screen that

shows a video, as shown in Figure 3.

1. Your project starts out with a page named MainPage.xaml, which you should open so

the designer is showing. If the XAML editor is showing, click on the Design tab at the

bottom of the designer window.

2. You'll have a default Grid, which you can work with in exactly the same way as

the designer for WPF, discussed in previous article . You need to ensure the Grid has two

rows, with the top row being large enough to fit the MediaElement and the bottom

large enough to fit a single button. Hover over the left margin of the window until

you see a grid line appear on the window. Move the grid line vertically until you've

created two rows, where the bottom row is large enough to hold a button, as shown

in Figure 3. Click on the window margin when you have the grid line positioned

where you want.

3. Find the MediaElement in the Toolbox and drag it onto the top row of the Window in

the designer. If you find that you haven't made the top row large enough, grab the grid

line arrow in the left margin and drag it down some more.

4. Set the Name property of the MediaElement control to VideoPlayer.

5. The MediaElement control has a Source property that you can set with the URL of

a movie. Set the Source property of the MediaElement control to http://mschnlnine

.vo.llnwd.net/d1/ch9/8/3/7/0/7/4/OfficeVS10SC1_2MB_ch9.wmv, which is a video

that introduces VS 2010.

6. Drag a Button from the Toolbox to the bottom row of the Window in the designer.

7. Set the Name property of the Button to StartStopButton and set the Content property

of the Button to Start.

In Figure 10-3, you can see a Grid with two rows. The top row holds a MediaElement

control and the bottom row holds a button. The name of the Video control is VideoPlayer

and the name of the button is StartStopButton.

Figure 3 Playing Silverlight videos

Listing 2 Playing and stopping a video

C#:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

namespace SilverlightDemoCS

{

public partial class MainPage : UserControl

{

public MainPage()

{

InitializeComponent();

VideoPlayer.AutoPlay = false;

}

private bool m_isPlaying = false;

private void StartStopButton_Click(

object sender, RoutedEventArgs e)

{

if (m_isPlaying)

{

VideoPlayer.Stop();

StartStopButton.Content = "Start";

m_isPlaying = false;

}

else

{

VideoPlayer.Play();

StartStopButton.Content = "Stop";

m_isPlaying = true;

}

}

}

}

By default, the MediaElement starts playing the Source video as soon as the application

loads, so I set AutoPlay to false in the code-behind constructor. The m_isPlaying field

keeps track of whether the MediaElement is playing or not. The Click event handler uses

m_isPlaying to toggle between playing and stopped.

This is a quick demo of how to work with the MediaElement control, but there's much

more you can do, such as pausing, tracking buffering, checking video position, and more.

All you need to do is either capture events of the MediaElement control or use controls like

buttons and sliders to interact with MediaElement, as the example shows in Listing 2. It

would be good practice for you to take what you've learned here and add more functionality

to the MediaElement control.

XAML in WPF and Silverlight

XML Application Markup Language (XAML), pronounced "Zamel," is an XML based language for building user interfaces. You'll find XAML being used in both Windows Presentation Foundation (WPF) and Silverlight applications. WPF is for desktop application development, and Silverlight is for Web-based development. Both WPF and Silverlight have much in common through programming with XAML. Therefore, this article provides an introduction to XAML and shows you how to perform layouts, which are common to both WPF and Silverlight. This Article can be useful before start learning the WPF and Silverlight chapters so that you can get the most out of what is specific to each technology. For simplicity, I'll demonstrate concepts by using a WPF application, but what you learn will be applicable to both WPF and Silverlight. Before reading this Article, you might want to read or review XML Article for an introduction to XML, which will provide you with familiarity of basic XML syntax.

Starting a WPF Project

As you are reading a book about VS, it's only natural that you would want to experience XAML from within the VS IDE. As stated earlier, we'll use a WPF Application project for describing XAML because it has fewer files and is simpler than a Silverlight application. To create the WPF Application project, select File | New | Project and select WPF Application in the New Project window. Name the application anything you like and click OK. What you'll see is a new project that has Window1.xaml file open in VS with contents similar to Listing B1.

Listing B-1 A new XAML file

<Window x:Class="WpfApplication1.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="MainWindow" Height="350" Width="525">

<Grid>

</Grid>

</Window>

In VS, the default layout for Window1.xaml is to have a visual designer on the top half of the work window and XAML in the lower half. You can view the full XAML document by grabbing the top edge of the XAML half and dragging it to the top of the screen so that you are only looking at the XAML editor. The first thing you should notice about Listing B-1

Elements as Classes

For XAML to be meaningful as code, elements must be associated with classes. The Window element in Listing B-1 is associated with a class named WpfApplication1 .MainWindow, specified by the x:Class attribute. The x prefix aliases the http://schemas .microsoft.com/winfx/2006/xaml namespace, where the Class attribute is defined. By mapping the element to a class, you allow VS to compile the XAML into code that runs. Notice that the default namespace is http://schemas.microsoft.com/winfx/2006/xaml/ presentation, which defines how each of the elements without prefixes will be compiled to code. The important fact to realize here is that when writing XAML, you are creating a document that will be translated into executable code for you at compile time.

Attributes as Properties

Title, Height, and Width are attributes of the Window element in Listing B-1. When VS compiles the XAML, each of the attributes of elements will be translated to properties of the class that the element is translated to. More specifically, the WpfApplication1. MainWindow class will have Title, Height, and Width properties. Each of the properties will be set with the value assigned to their corresponding attributes.

Executing the XAML Document

Remember that this is not a tutorial on WPF and that the focus needs to be on understanding how XAML works. Nevertheless, it's informative to see what happens when XAML is compiled and executed. Press F5 or click the Start Debugging button on the toolbar to run this program. What you'll see is a window similar to Figure B-1.

Figure B-1 shows how the Window element executed, creating an application window with normal title bar, minimize and close buttons, and borders. You can also see the results of applying the attributes of the Window element where MainWindow appears on the title bar and the dimensions are set by Height and Width.

This illustrates the power of XAML, where you can produce sophisticated results without writing a line of C# or VB code yourself. Of course, all of the XAML translates to code, but the declarative nature of XAML lets you say what you want without having to specify how it's done. XAML saves you from writing a lot of code to produce equivalent results. The code that actually runs is generated for you.

Figure B-1 Executing XAML

Property Elements

You've seen how attributes translate to properties. In addition to attributes, XAML has property elements, which are child elements where one or more other elements become assigned to a property. An example of a property element would be the Content property of a Button. A Button is a class in both WPF and Silverlight that a user can click to produce some action in your program. The Content property of the Button determines what the user sees. To describe the difference between a property attribute and a property element, I'll show you an example of both with the Content property of the Button class. Listing B-2 shows a Button with its Content set as an attribute.

Listing B-2 A Button with Content set as an attribute
 

<Window x:Class="WpfApplication1.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="MainWindow" Height="350" Width="525">

<Button Content="Click Me" />

</Window>

Figure B-2 A Button with its Content attribute set as Text

 A powerful feature of XAML is property elements that allow you to add sophisticated markup that will be assigned to a class property. In the case of the Button, we'll enhance the Content property as a property element in XAML to show how to add content other than text. The following markup is the Button from Listing B-2, enhanced to hold an image instead of text. For readability, I added a line break for the value of the Source attribute:

<Button>

<Button.Content>

<Image Source=

"C:\Users\Public\Pictures\Sample Pictures\Penguins.jpg" />

</Button.Content>

</Button>

Instead of setting the Content attribute, the preceding example uses property element syntax, where the child element is named <parentElementName.attributeName>. The benefit of property element syntax shown in the preceding code is that the Content property will now be set to an image. With attribute syntax, you were limited to text, but with property element syntax, you can put anything in a button. Of course, instead of what I did with the image, you would want to use common sense and only add content that is meaningful for the application.

Figure B-3 Button with Content property element set to Image

TIP

VS provides XAML editor support by allowing you to place your cursor between begin

and end tags, pressing ENTER, and indenting the start position of the cursor on the new

line between the start and end tags. From that point, you can type < and begin working

with Intellisense to select the element and attribute you need to implement with property

element syntax.

Markup Extensions

Another extensibility point in XAML is markup extensions, which allow you to set an attribute to reference another value. Common uses of markup extensions include data binding and resource usage. Data binding is the practice of associating data with a user interface control. For example, if you needed to show a customer record on the screen, you would bind each property of the customer object to parts of the screen, such as binding a customer name to a TextBox on the screen. Right now, it's important to concentrate on what a markup extension is, and you'll see an example that applies a resource to an element.

A resource is some type of object or value that can be used by multiple controls. For example, you can define a special color for buttons on your screen in one place and then use a markup extension to point all of these buttons to the same resource. That way, you can change the color resource in one place and all buttons referring to that color resource will change automatically. Listing B-3 defines a brush resource of a specific color and shows how to reference that brush from multiple buttons using a markup extension.

Listing B-3 Markup extension for using resources

<Window x:Class="WpfApplication1.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="MainWindow" Height="350" Width="525">

<Window.Resources>

<SolidColorBrush x:Key="ButtonBrush" Color="Yellow" />

</Window.Resources>

<StackPanel>

<Button Background="{StaticResource ResourceKey=ButtonBrush}"

Content="Button One" />

<Button Background="{StaticResource ResourceKey=ButtonBrush}"

Content="Button Two" />

</StackPanel>

</Window>

The Window.Resources element in Listing B-3 is a property element of Window. It contains a SolidColorBrush with Color set to Yellow. Everything in WPF and Silverlight is drawn with brushes, which define colors, gradients, images, media, or patterns. In this case, we'll keep it simple with a single color, which is what SolidColorBrush is good for. The point here is not what a brush is, but the fact that the brush is a resource that will help demonstrate how to use a markup extension to access that resource. It's important to assign a key to every resource because that key is what resource markup extensions use to identify the resource.

You can see the markup extension assigned to the Background attributes of the Button elements in Listing B-3. Markup extensions are surrounded by curly braces. Within the curly braces are the extension type and attributes associated with the extension. In Listing B-3, the extension type is StaticResource, which allows you to refer to a resource. The ResourceKey attribute of the StaticResource extension specifies the particular resource to use. The value, ButtonBrush, matches the key of the SolidColorBrush resource. So, the value of the BackGround attribute of the Button elements is a StaticResource for a SolidColorBrush that has its color set to Yellow. This effectively means that the Buttons will have Yellow backgrounds.

To see the value of using resources, consider the situation you would be in if you set the BackGround attribute of each button directly to Yellow instead of using the

Figure B-4 Two Buttons using the same resource via a markup extension

StaticResource markup extension. Further, think about the amount of work you would need to do if you wanted to change the background color of all buttons, resulting in recoding each individual button. However, with the StaticResource markup extension, you can change the color in the SolidColorBrush resource, and the BackGround of all buttons will change without any additional work. Figure B-4 shows each of the buttons. Though you can't tell the background color in the gray scale of this book, I promise that they are yellow.

Silverlight 5 What's New?

Silverlight 5 is coming next year (2011) and this blog post will tell you what you need to know before the beta ships. First, let me address people saying that it is dead after PDC 2010. I believe that it's best to see what the market is doing, not the vendor. Below is a list of companies that are developing Silverlight 4 applications shown during the Silverlight Firestarter. Some of the companies have shipped and some haven't. It's just great to see the actual company names that are working on Silverlight instead of "people are developing for Silverlight".

The next thing that I wanted to point out was that HTML5, WPF and Silverlight can co-exist. In case you missed Scott Gutherie's keynote, they actually had a slide with all three stacked together. This shows Microsoft will be heavily investing in each technology. Even I, a Silverlight developer, am reading Pro HTML5.

Microsoft said that according to the Silverlight Feature Voting site, 21k votes were entered. Microsoft has implemented about 70% of these votes in Silverlight 5. That is an amazing number, and I am crossing my fingers that Microsoft bundles Silverlight with Windows 8.
Let's get started… what's new in Silverlight 5? I am going to show you some great application and actual code shown during the Firestarter event.
Media

• Hardware Video Decode – Instead of using CPU to decode, we will offload it to GPU. This will allow netbooks, etc to play videos.
• Trickplay – Variable Speed Playback – Pitch Correction (If you speed up someone talking they won't sound like a chipmunk).
• Power Management – Less battery when playing video. Screensavers will no longer kick in if watching a video. If you pause a video then screensaver will kick in.
• Remote Control Support – This will allow users to control playback functions like Pause, Rewind and Fastforward.
• IIS Media Services 4 has shipped and now supports Azure.

Data Binding

Layout Transitions – Just with a few lines of XAML you can create a really rich experience that is not using Storyboards or animations.

?

1 2 3 4 5 6 7

<VisualStateManager.LoadTransition> <LoadTransition StartXOffset="300" GeneratedDuration="0:0:1.0" StartOpacity="0.2"> <LoadTransition.GeneratedEasingFunction> <CircleEase/> </LoadTransition.GeneratedEasingFunction> </LoadTransition> </VisualStateManager.LoadTransition>

RelativeSource FindAncestor – Ancestor RelativeSource bindings make it much easier for a DataTemplate to bind to a property on a container control.

?

1 2	<ComboBox ItemTemplate={StaticResource BookItemTemplate} ItemsSource="{Binding DataContext.Book, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=UserControl}"/>

Custom Markup Extensions – Markup extensions allow code to be run at XAML parse time for both properties and event handlers. This is great for MVVM support.

?

1	<ListBox SelectionChanged="{MyTestMethodBinding:Invoke Method=OnSelectCategory}"/>

Changing Styles during Runtime By Binding in Style Setters – Changing Styles at runtime used to be a real pain in Silverlight 4, now it's much easier. Binding in style setters allows bindings to reference other properties.

?

1 2 3

<Style x:Key="AccentBlocks" TargetType="Rectangle"> <Setter Property="Fill" Value="{Binding MyBrush, Source={StaticResource MyColorSettings}"/> </Style>

XAML Debugging – Below you can see that we set a breakpoint in XAML. This shows us exactly what is going on with our binding.

WCF & RIA Services

• WS-Trust Support – Taken from Wikipedia: WS-Trust is a WS-* specification and OASIS standard that provides extensions to WS-Security, specifically dealing with the issuing, renewing, and validating of security tokens, as well as with ways to establish, assess the presence of, and broker trust relationships between participants in a secure message exchange.
• You can reduce network latency by using a background thread for networking.
• Supports Azure now.

Text and Printing

• Improved text clarity that enables better text rendering.
• Multi-column text flow, Character tracking and leading support, and full OpenType font support.
• Includes a new Postscript Vector Printing API that provides control over what you print .
• Pivot functionality baked into Silverlight 5 SDK.

Graphics

• Immediate mode graphics support that will enable you to use the GPU and 3D graphics supports.

Take a look at what was shown in the demos below.
1) 3D view of the Earth – not really a real-world application though.

A doctor's portal. This demo really stood out for me as it shows what we can do with the 3D / GPU support.


Out of Browser

• OOB applications can now create and manage childwindows as shown in the screenshot below.
• Trusted OOB applications can use P/Invoke to call Win32 APIs and unmanaged libraries.
• Enterprise Group Policy Support allow enterprises to lock down or up the sandbox capabilities of Silverlight 5 applications.

In this demo, he tore the "notes" off of the application and it appeared in a new window. See the black arrow below.

In this demo, he connected a USB Device which fired off a local Win32 application that provided the data off the USB stick to Silverlight.

Another demo of a Silverlight 5 application exporting data right into Excel running inside of browser.

Testing

• They demoed Coded UI, which is available now in the Visual Studio Feature Pack 2. This will allow you to create automated testing without writing any code manually.

Performance:

• Microsoft has worked to improve the Silverlight startup time.
• Silverlight 5 provides 64-bit browser support.
• Silverlight 5 also provides IE9 Hardware acceleration.