tag. This tag would point to a .xap file, which is the compressed package containing all the application's code and assets. The browser's Silverlight plug-in would then be responsible for loading and running the application within the designated area of the web page.
One of the most significant features of Silverlight 4 was its enhanced out-of-browser support. With the user's permission, a Silverlight application could be "installed" onto the user's desktop. It would then run as a standalone application outside the browser's sandbox, with its own shortcut in the Start Menu. These trusted, out-of-browser applications could be granted elevated permissions to perform tasks that were not possible in the browser, such as interacting with local COM components.
Core Silverlight Concepts for the 70-506 Exam To build a solid foundation for the topics in the 70-506 Exam, a developer first needed to master the fundamental building blocks of the platform. This started with a clear understanding of Silverlight's role as a browser plug-in for building Rich Internet Applications. The absolute cornerstone of UI development was XAML, and a candidate needed to be proficient in using this declarative language to define the application's visual structure and controls.
Beyond the basics, a deeper architectural understanding of the Dependency Property system was essential, as it is the enabling technology for Silverlight's most powerful features like data binding and styling. Finally, a candidate needed to understand the application lifecycle, including how it is hosted within a web page and the powerful new capabilities offered by the out-of-browser execution mode. These core concepts were the prerequisite for tackling the more advanced topics on the exam.
The Power of Data Binding in Silverlight Data binding is one of the most powerful and important features of the Silverlight platform, and it was a major focus of the 70-506 Exam. Data binding is the process of creating a live connection between a property of a UI element (the target) and a property of a data object (the source). Once this connection is established, the Silverlight framework automatically keeps the two values synchronized, based on the configuration of the binding.
This declarative approach to data synchronization dramatically simplified application development. Instead of writing tedious boilerplate code to manually update the UI whenever the underlying data changed, a developer could simply declare the binding in XAML. This led to a significant reduction in code-behind, made the application easier to maintain, and was the key enabler for modern architectural patterns like Model-View-ViewModel (MVVM), which promotes a clean separation of concerns between the UI and the application's logic.
Implementing One-Way, Two-Way, and OneTime Binding The behavior of a data binding is controlled by its mode, and the 70-506 Exam required a developer to know when to use each of the different modes. The default mode was OneWay binding. In this mode, data flows from the source to the target. If the property on the source object changes, the UI element that is bound to it will be automatically updated. This is commonly used for displaying read-only data, such as a name in a TextBlock.
TwoWay binding, as its name implies, allows data to flow in both directions. If the user changes the value in the UI (for example, by typing in a TextBox), the source object's property is automatically updated. This is essential for creating data entry forms. The third mode, OneTime, is the most lightweight. It reads the value from the source when the application starts and then breaks the connection. This is useful for data that is known to be static and will not change during the application's lifetime.
The INotifyPropertyChanged Interface For OneWay or TwoWay binding to work correctly, the UI needs a way to know when a property on the source data object has changed. The mechanism for this, and a fundamental concept for the 70-506 Exam, is the INotifyPropertyChanged interface. This interface, which is part of the .NET framework, defines a single event called PropertyChanged.
For a data object to act as a proper binding source, it must implement this interface. In the setter of each property, after the value is changed, the object should raise the PropertyChanged event, passing in the name of the property that has changed. The Silverlight data binding engine automatically subscribes to this event. When it sees the event, it knows that it needs to re-read the value of the property and update the corresponding UI element.
Using Value Converters in Data Binding There are often cases where the data from the source object is not in the correct format to be displayed directly in the UI. For example, a data object might have a boolean property called IsActive, but you want to use this to control the visibility of a UI element, which requires a value from the Visibility enumeration (Visible or Collapsed). The solution for this, and a key tool for the 70-506 Exam, is a value converter.
A value converter is a small class that implements the IValueConverter interface. This interface has two methods: Convert and ConvertBack. The Convert method is called when data is moving from the source to the target, and it contains the logic to transform the value. The ConvertBack method is used for TwoWay bindings to transform the value back from the UI format to the data source format. Converters are a powerful way to decouple the data model from the specific display requirements of the view.
Binding to Collections with ObservableCollection A very common requirement is to display a list of items in the UI, for example, in a ListBox or a DataGrid. This is achieved by binding the ItemsSource property of the control to a collection property on the data source. For this to be fully dynamic, the UI needs to be notified not only when a property of an item in the collection changes, but also when an item is added to or removed from the collection.
The standard List class does not provide this notification. The solution, and a critical class to know for the 70-506 Exam, is the ObservableCollection. This special collection class implements the INotifyCollectionChanged interface. When an item is added to or removed from an ObservableCollection, it automatically raises an event that the data binding engine understands, causing the ListBox or DataGrid to update its display to reflect the change.
Consuming Data from Web Services Because a Silverlight application runs in a client-side browser plug-in, it does not have direct access to a database. All data must be retrieved from the server over the network, typically by calling a web service. The 70-506 Exam required developers to be proficient in this client-server communication. A key constraint of the browser sandbox is that all network calls must be made asynchronously. This means that when you make a call to a web service, your code does not wait for the response.
Instead, you provide a callback method that will be executed when the service call completes. This asynchronous programming model is essential to prevent the application's UI thread from freezing while waiting for a network response. Silverlight provided easy-to-use client proxy classes for consuming standard web services like ASMX and Windows Communication Foundation (WCF), which handled the complexities of making the asynchronous call and deserializing the results.
Working with WCF RIA Services To simplify the development of complex n-tier, data-driven applications, Microsoft created a framework called WCF RIA Services. This was a very important technology for the 70-506 Exam as it provided a complete solution for many of the challenges of client-server communication. RIA Services allowed a developer to define data and business logic on the server and then create a "projection" of that logic onto the Silverlight client.
It automatically generated a client-side proxy, called a DomainContext, which provided strongly-typed access to the server-side data and methods. It also provided built-in support for advanced features like change tracking, data validation, and authentication. A developer could write code on the client to query and modify data using this context, and the framework would handle the batching of changes, the communication with the server, and the processing of the results, dramatically reducing the amount of boilerplate code required.
Core Data Concepts for the 70-506 Exam The data handling domain of the 70-506 Exam was arguably one of the most important. Success required a developer to have a mastery of the data binding system. This meant not just understanding the XAML syntax for binding, but also the underlying mechanisms that made it work. A deep knowledge of the key interfaces, INotifyPropertyChanged and IValueConverter, and the essential collection class, ObservableCollection, was non-negotiable.
Equally important was a solid grasp of the client-server communication model. A candidate had to be completely comfortable with the asynchronous programming model that was required for all network calls. They needed to be able to consume data from standard WCF services and, for more advanced scenarios, understand the significant productivity benefits and architectural patterns provided by the WCF RIA Services framework. These concepts formed the backbone of any data-driven Silverlight application.
Rendering Graphics with Shapes and Brushes A key appeal of Rich Internet Applications was their ability to go beyond the limitations of standard HTML and create visually rich, dynamic user interfaces. The 70-506 Exam required a developer to be proficient with the 2D graphics system in Silverlight. This system was based on a library of vector graphics elements. The simplest way to draw on the screen was by using the built-in shape elements, such as Rectangle, Ellipse, and Line.
These shapes could be customized using a variety of properties. The appearance of the interior of a shape was controlled by its Fill property, while its outline was controlled by the Stroke and StrokeThickness properties. The value for these properties was an object that inherited from the Brush class. The most common was the SolidColorBrush, but Silverlight also supported more advanced brushes like LinearGradientBrush and RadialGradientBrush for creating smooth color transitions, and ImageBrush for using an image to fill a shape.
Geometries and the Path Element For drawing more complex or custom figures that could not be created with the basic shape elements, Silverlight provided the powerful Path element. This was a key graphics concept for the 70-506 Exam. A Path element is a versatile shape whose outline is defined by a Geometry object. The Path element's Data property is set to a geometry, which describes the series of lines, arcs, and curves that make up the figure.
Silverlight included several types of geometries, such as LineGeometry, RectangleGeometry, and the more complex PathGeometry, which could be used to define a figure composed of multiple segments. This geometry system allowed for the creation of intricate vector graphics. Furthermore, these geometries could be combined using a GeometryGroup, allowing a developer to create complex shapes by merging or excluding the areas of simpler geometries.
Applying Transforms to Elements In addition to drawing shapes, a key part of a dynamic UI is the ability to manipulate elements on the screen. The 70-506 Exam tested a developer's knowledge of the 2D transform system in Silverlight. Any UI element could have a transform applied to it through its RenderTransform property. A transform could be used to change the position, orientation, or shape of an element without affecting its layout.
There were four main types of transforms. A TranslateTransform was used to move an element horizontally or vertically. A ScaleTransform was used to make an element larger or smaller. A RotateTransform was used to rotate an element around a center point. Finally, a SkewTransform was used to slant or shear an element. These transforms could be combined using a TransformGroup, allowing for complex manipulations of UI elements.
The Silverlight Animation System The ability to create smooth, time-based animations was a hallmark of the Silverlight platform. The animation system, a core topic for the 70-506 Exam, was based on the concept of a Storyboard. A Storyboard is a timeline that acts as a container for one or more animations. Each animation is designed to change the value of a specific dependency property of an element over a set period of time.
For example, to make a rectangle fade out, you would create a DoubleAnimation that targets the Opacity property of the Rectangle element. This animation would be configured to change the Opacity value from 1.0 to 0.0 over a specified Duration. This animation would then be placed inside a Storyboard. The animation could be started and stopped from C# code, providing full programmatic control over the visual effects in the application.
Understanding Keyframes and Easing Functions While simple animations could change a property from a starting value to an ending value, the 70-506 Exam also covered more advanced animation techniques. For animations that did not follow a simple linear path, a developer could use keyframe animations, such as DoubleAnimationUsingKeyFrames. A keyframe animation allows you to define specific values (the keyframes) that the property should have at specific points in time along the animation's timeline. The system then interpolates the values between these keyframes.
To make animations appear more natural and less robotic, Silverlight provided a set of easing functions. An easing function controls the rate of change of the animation's value over time. For example, a QuadraticEase function could be used to make an object start slowly, accelerate, and then slow down again as it comes to a stop, mimicking the effect of real-world physics. These tools gave developers and designers a high degree of control over the look and feel of the animations.
Integrating Media with MediaElement Silverlight was originally conceived as a platform for delivering high-quality, streaming video, so its media capabilities were a central feature and an important topic for the 70-506 Exam. The primary tool for integrating audio and video into an application was the MediaElement control. This control could play standard media formats like WMV for video and WMA for audio.
The Source property of the MediaElement was set to the URI of the media file, which could be a local file within the application package or a streaming source from a media server. The developer had full programmatic control over the media playback. They could use methods like Play(), Pause(), and Stop(), and could set properties like Volume and Position. The control also exposed a rich set of events, such as MediaOpened and MediaEnded, allowing the application to react to changes in the media's state.
Working with Images and Deep Zoom For displaying static images, Silverlight provided the straightforward Image control, which could display common raster image formats like JPG and PNG. The Source property was simply set to the path of the image file. A much more advanced and unique feature of the Silverlight platform, and a potential topic for the 70-506 Exam, was Deep Zoom. Deep Zoom was a technology designed to allow users to interact with extremely high-resolution images over the web.
A special tool was used to slice a very large image into a pyramid of smaller image tiles at different zoom levels. The MultiScaleImage control in Silverlight would then intelligently download only the tiles that were needed for the current viewport and zoom level. This allowed for a remarkably smooth and responsive experience when panning and zooming on images that were gigapixels in size, something that was impossible with traditional web technologies at the time.
Key Graphics Concepts for the 70-506 Exam The graphics and media domain of the 70-506 Exam required a developer to have a creative and technical understanding of the platform's visual capabilities. The foundation of this was the 2D vector graphics system, and a candidate needed to be proficient in using both the basic Shape elements and the more powerful Path and Geometry objects for custom drawing. A solid grasp of the Transform classes was essential for dynamically manipulating these visual elements.
The second major pillar was the animation system. A developer needed to master the Storyboard and Animation classes to create time-based visual effects and understand how to use keyframes and easing functions for more sophisticated motion. Finally, a practical knowledge of the MediaElement control for audio and video playback was non-negotiable, as media handling was one of the primary use cases for the Silverlight platform.
Styling Controls with Resources Creating a consistent and professional look and feel is crucial for any application. The 70-506 Exam required a deep understanding of the styling and theming capabilities in Silverlight. The foundation of this system is the Style object. A style is a collection of property setters that can be applied to a control. For example, you could create a style for a Button that sets its Background to a specific color, its FontFamily to a custom font, and its FontSize.
These styles were typically not defined inline. Instead, they were stored as reusable resources inside a ResourceDictionary. A resource dictionary could be defined at the application level, the page level, or even for an individual control. This hierarchical system of resources allowed developers to create a consistent theme for an entire application and then override specific styles for certain sections of the UI as needed. This was a powerful mechanism for separating an application's visual design from its structure.
Understanding the Visual State Manager (VSM) A critical concept for advanced UI development in Silverlight, and a key topic for the 70-506 Exam, was the Visual State Manager (VSM). The VSM is a framework for defining and managing the visual appearance of a control as it transitions between different states. For example, a Button has several common states, such as "Normal," "MouseOver" (when the mouse is hovering over it), "Pressed" (when the user is clicking it), and "Disabled."
The VSM provided a declarative way, directly within XAML, to define what the control should look like in each of these states. You could define a Storyboard for each state that would set the properties of the control's visual elements. The VSM would then automatically handle the smooth animated transitions between these states. This provided a structured and designer-friendly way to manage the complex visual feedback that is expected in a modern user interface.
Redefining Controls with Control Templates One of the most powerful features of the Silverlight UI platform was the concept of "lookless" controls. This meant that a control's behavior was completely separate from its visual appearance. The 70-506 Exam expected developers to master the feature that enabled this: control templating. A ControlTemplate allows a developer to completely replace the visual tree of a control.
For example, the default Button control is a simple rectangle. By creating a new ControlTemplate for the button, you could redefine its appearance to be a circle, a star, or an image, all without changing its underlying behavior. It would still have its Click event and all its other properties. This ability to completely restyle and re-skin controls was fundamental to creating unique and heavily branded application interfaces and was a key differentiator of the platform.
Displaying Data with Data Templates While a ControlTemplate defines the look of a control, a DataTemplate defines the visual representation of a data object. This distinction is a crucial concept for the 70-506 Exam. Data templates are most commonly used with items controls, such as a ListBox or a DataGrid. When you bind a collection of data objects to a ListBox, the control needs to know how to display each individual object in the list.
This is the job of the DataTemplate. You would define a DataTemplate that contains a set of UI elements (like TextBlocks and Images) whose properties are bound to the properties of the underlying data object. The ListBox would then use this template to generate the UI for every item in its collection. This provided a powerful and flexible way to create rich, data-driven lists and displays.
The Model-View-ViewModel (MVVM) Pattern While the 70-506 Exam did not have a specific objective called "MVVM," a deep understanding of this architectural pattern was essential for answering many of the more advanced questions. The Model-View-ViewModel (MVVM) pattern was the de facto standard for building robust and maintainable Silverlight applications. It promotes a clean separation of concerns by dividing the application into three distinct parts.
The Model represents the application's data. The View is the UI, defined in XAML, and it contains no business logic. The ViewModel is the bridge between the two. It exposes the data from the model as properties that the view can bind to, and it exposes the application's functionality as commands that the view can execute. This separation, enabled by Silverlight's powerful data binding system, made the application much easier to test and maintain.
Implementing Navigation in Silverlight For applications that consisted of more than a single screen, a navigation framework was required. The 70-506 Exam covered the built-in navigation framework provided with Silverlight. This framework was designed to mimic the navigation experience of a web browser. It was based on two primary controls: the Frame and the Page. The Frame was a container that would host different pages. The Page was a specific view or screen within the application.
A developer could use the Frame's Maps method to load a new Page into the view. The framework automatically handled the browser's history journal, enabling the use of the back and forward buttons. It also supported "deep linking," where a specific URI could be used to navigate directly to a particular page within the Silverlight application, which was important for creating bookmarkable and shareable links.
Working with the DataGrid Control For displaying and editing tabular data, the most powerful control in the Silverlight toolkit was the DataGrid. The 70-506 Exam expected developers to be proficient with this complex control. The DataGrid could be bound to a collection of data objects, and it would automatically generate columns for each of the public properties of the objects. Developers had full control over the columns, allowing them to customize the headers, define the cell templates, and control the formatting.
The DataGrid also provided a rich set of built-in functionality. It had built-in support for sorting data by clicking on the column headers and for grouping data by dragging column headers to a dedicated grouping area. It also had a robust editing model, allowing users to edit data directly within the cells of the grid. Mastering the DataGrid was essential for building any kind of line-of-business or data-centric application in Silverlight.
Key UI/UX Concepts for the 70-506 Exam The advanced UI domain of the 70-506 Exam was centered on the platform's remarkable flexibility. The core concept to master was the "lookless" nature of the controls. This was enabled by a powerful trio of technologies that a candidate had to know in detail: Style objects for applying a consistent look, the Visual State Manager (VSM) for defining visual appearances in different states, and ControlTemplates for completely redefining a control's visual structure.
Furthermore, a deep understanding of DataTemplates was essential for creating rich, data-driven interfaces. Tying all of this together was the Model-View-ViewModel (MVVM) architectural pattern. While not a specific technology, a solid grasp of MVVM was the key to understanding how to build scalable, testable, and maintainable applications, and was therefore critical for success on the 70-506 Exam.
Printing Support in Silverlight 4 One of the most requested features for enterprise applications, and a new addition in Silverlight 4, was native printing support. The 70-506 Exam included this topic to test a developer's ability to create printable output. The printing API was centered around the PrintDocument class. To print, a developer would create an instance of this class, subscribe to its PrintPage event, and then call its Print method.
The PrintPage event would fire for each page that needed to be printed. Inside the event handler, the developer was responsible for creating the visual content for that specific page. This was done by constructing a visual tree of Silverlight elements (like Grids, TextBlocks, and Images) and assigning it to the PageVisual property of the event arguments. This API provided a high degree of control over the layout and content of the printed document.
Interacting with the Browser DOM While a Silverlight application ran within its own plug-in sandbox, it was not completely isolated from its host environment. The 70-506 Exam required developers to know how to interact with the hosting web page. This was accomplished through a feature called the HTML Bridge. The HTML Bridge allowed for two-way communication between the managed C# code of the Silverlight application and the JavaScript running in the browser.
A developer could use the HtmlPage class in C# to access and manipulate the HTML Document Object Model (DOM), for example, to change the style of an HTML element. It was also possible to expose C# methods to be callable from JavaScript and, conversely, to invoke JavaScript functions directly from the C# code. This interoperability was essential for creating applications that were tightly integrated with the surrounding web page.
COM Interop in Out-of-Browser Applications For Silverlight applications that were installed to run out of the browser, Silverlight 4 introduced a powerful new capability that was a key topic for the 70-506 Exam: COM Interoperability. If an out-of-browser application was granted trusted status during installation, it could use COM automation to interact with other applications installed on the user's local machine.
The most common use case for this was to automate Microsoft Office applications. For example, a data-centric Silverlight application could have a feature that would export the data from a DataGrid and then use COM interop to automatically create a new Microsoft Excel spreadsheet, populate it with the data, and format it. This feature allowed trusted Silverlight applications to provide a level of integration with the desktop environment that was previously only possible for traditional desktop applications.
The Silverlight Network Security Model All network communication from a Silverlight application was subject to a strict security model to protect users. Understanding this model was a critical part of the 70-506 Exam. The most important rule was the same-origin policy. By default, a Silverlight application could only make network calls to services that were hosted on the same domain from which the application itself was downloaded.
To enable communication with a service on a different domain, a cross-domain access policy had to be put in place. The target server had to host a special XML file at the root of its domain. There were two types of policy files: a clientaccesspolicy.xml file, which was specific to Silverlight, or a crossdomain.xml file, which was the legacy standard from Adobe Flash. This file explicitly granted permission for Silverlight clients from other domains to connect to its services.
Isolated Storage for Local Data Because a browser-hosted Silverlight application was running in a security sandbox, it was not allowed to directly access the user's local file system. To allow applications to save data locally, Silverlight provided a feature called Isolated Storage. The 70-506 Exam required developers to understand this concept. Isolated Storage was a virtual, sandboxed file system that was managed by the Silverlight plug-in.
Each Silverlight application was given its own private "isolated" area where it could create files and directories. This storage was sandboxed, meaning that one Silverlight application could not access the isolated storage of another. This provided a secure way for an application to store user-specific settings, cache data, or save user-created documents without compromising the security of the user's machine.
Multi-threading and the UI Thread Like most modern UI frameworks, Silverlight used a single-threaded apartment model for its user interface. This meant that there was a single, dedicated UI thread that was responsible for all interactions with the visual elements. This is an important architectural concept for the 70-506 Exam. If a developer needed to perform a long-running operation, such as a complex calculation or a large network download, it was crucial that this work was done on a background thread.
If a long-running task was performed on the UI thread, the entire application would become unresponsive, or "freeze," until the task was complete. After the work on the background thread was finished, the results often needed to be used to update a UI element. However, only the UI thread is allowed to touch UI elements. To solve this, a developer had to use the Dispatcher.BeginInvoke method to marshal the call back to the UI thread to safely update the UI.
The End of an Era: The Legacy of Silverlight While Silverlight was a powerful and innovative platform for its time, its reliance on a browser plug-in ultimately led to its decline. The industry, led by Apple's decision not to support plug-ins on its mobile devices and the rise of the powerful new capabilities in HTML5, moved towards a plug-in-free web. Microsoft eventually deprecated Silverlight, and it has now reached its end of life.
However, the legacy of Silverlight and the concepts tested in the 70-506 Exam are incredibly significant. The core ideas of a declarative UI language (XAML), a powerful data binding engine, and the Model-View-ViewModel (MVVM) architectural pattern did not disappear. Instead, they became the foundation for all subsequent Microsoft UI frameworks, including the Windows Presentation Foundation (WPF), Windows Phone, the Universal Windows Platform (UWP), and the modern MAUI and WinUI frameworks.
Final Conceptual For any developer studying the topics of the 70-506 Exam today, the lasting value lies not in the specific Silverlight 4 APIs, but in the powerful architectural patterns it championed. The three most important pillars to understand are the UI layer, the ViewModel layer, and the communication layer. The UI layer is defined by the flexibility of XAML, control templating, and the Visual State Manager.
The ViewModel layer is defined by the MVVM pattern, which is enabled by the powerful data binding system and the key interfaces like INotifyPropertyChanged. The communication layer is defined by the asynchronous nature of all server communication, whether it was with standard WCF services or the more advanced WCF RIA Services framework. A deep understanding of how these three layers interacted is the true legacy of Silverlight development and the key takeaway from the 70-506 Exam.