Introduction to Data Binding

Exclusive offer: get 50% off this eBook here
Microsoft Silverlight 4 Data and Services Cookbook

Microsoft Silverlight 4 Data and Services Cookbook — Save 50%

Over 80 practical recipes for creating rich, data-driven business applications in Silverlight with this Microsoft book and eBook

$35.99    $18.00
by Gill Cleeren Kevin Dockx | May 2010 | Microsoft

In this article series by Gill Cleeren and Kevin Dockx, authors of Microsoft Silverlight 4 Data and Services Cookbook, we will cover the following recipes:

  • Displaying data in Silverlight applications
  • Creating dynamic bindings
  • Binding data to another UI element
  • Binding collections to UI elements
  • Enabling a Silverlight application to automatically update its UI
  • Obtaining data from any UI element it is bound to
  • Using the different modes of data binding to allow persisting data
  • Data binding from Expression Blend 4
  • Using Expression Blend 4 for sample data generation

Introduction

Data binding allows us to build data-driven applications in Silverlight in a much easier and much faster way compared to old-school methods of displaying and editing data. This article and the following one take a look at how data binding works. We'll start by looking at the general concepts of data binding in Silverlight 4 in this article.

Analyzing the term data binding immediately reveals its intentions. It is a technique that allows us to bind properties of controls to objects or collections thereof.

The concept is, in fact, not new. Technologies such as ASP.NET, Windows Forms, and even older technologies such as MFC (Microsoft Foundation Classes) include data binding features. However, WPF's data binding platform has changed the way we perform data binding; it allows loosely coupled bindings. The BindingsSource control in Windows Forms has to know of the type we are binding to, at design time. WPF's built-in data binding mechanism does not. We simply defi ne to which property of the source the target should bind. And at runtime, the actual data—the object to which we are binding—is linked. Luckily for us, Silverlight inherits almost all data binding features from WPF and thus has a rich way of displaying data.

A binding is defined by four items:

  • The source or source object: This is the data we are binding to. The data that is used in data binding scenarios is in-memory data, that is, objects. Data binding itself has nothing to do with the actual data access. It works with the objects that are a result of reading from a database or communicating with a service. A typical example is a Customer object.
  • A property on the source object: This can, for example, be the Name property of the Customer object.
  • The target control: This is normally a visual control such as a TextBox or a ListBox control. In general, the target can be a DependencyObject. In Silverlight 2 and Silverlight 3, the target had to derive from FrameworkElement; this left out some important types such as transformations.
  • A property on the target control: This will, in some way—directly or after a conversion—display the data from the property on the source.

The data binding process can be summarized in the following image:

In the previous image, we can see that the data binding engine is also capable of synchronization. This means that data binding is capable of updating the display of data automatically. If the value of the source changes, Silverlight will change the value of the target as well without us having to write a single line of code. Data binding isn't a complete black box either. There are hooks in the process, so we can perform custom actions on the data fl owing from source to target, and vice versa. These hooks are the converters.

Our applications can still be created without data binding. However, the manual process—that is getting data and setting all values manually on controls from code-behind—is error prone and tedious to write. Using the data-binding features in Silverlight, we will be able to write more maintainable code faster.

In this article, we'll explore how data binding works. We'll start by building a small data-driven application, which contains the most important data binding features, to get a grasp of the general concepts. We'll also see that data binding isn't tied to just binding single objects to an interface; binding an entire collection of objects is supported as well. We'll also be looking at the binding modes. They allow us to specify how the data will flow (from source to target, target to source, or both). We'll finish this article series by looking at the support that Blend 4 provides to build applications that use data binding features.

In the recipes of this article and the following one, we'll assume that we are building a simple banking application using Silverlight. Each of the recipes in this article will highlight a part of this application where the specific feature comes into play. The following screenshot shows the resulting Silverlight banking application:

Displaying data in Silverlight applications

When building Silverlight applications, we often need to display data to the end user. Applications such as an online store with a catalogue and a shopping cart, an online banking application and so on, need to display data of some sort.

Silverlight contains a rich data binding platform that will help us to write data-driven applications faster and using less code. In this recipe, we'll build a form that displays the data of the owner of a bank account using data binding.

Getting ready

To follow along with this recipe, you can use the starter solution located in the Chapter02/ SilverlightBanking_Displaying_Data_Starter folder in the code bundle available on the Packt website. The finished application for this recipe can be found in the Chapter02/SilverlightBanking_Displaying_Data_Completed folder.

How to do it...

Let's assume that we are building a form, part of an online banking application, in which we can view the details of the owner of the account. Instead of wiring up the fields of the owner manually, we'll use data binding. To get data binding up and running, carry out the following steps:

  1. Open the starter solution, as outlined in the Getting Ready section.
  2. The form we are building will bind to data. Data in data binding is in-memory data, not the data that lives in a database (it can originate from a database though). The data to which we are binding is an instance of the Owner class. The following is the code for the class. Add this code in a new class fi le called Owner in the Silverlight project.
    public class Owner
    {
    public int OwnerId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public string ZipCode { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Country { get; set; }
    public DateTime BirthDate { get; set; }
    public DateTime CustomerSince { get; set; }
    public string ImageName { get; set; }
    public DateTime LastActivityDate { get; set; }
    public double CurrentBalance { get; set; }
    public double LastActivityAmount { get; set; }
    }
  3. Now that we've created the class, we are able to create an instance of it in the MainPage.xaml.cs file, the code-behind class of MainPage.xaml. In the constructor, we call the InitializeOwner method, which creates an instance of the Owner class and populates its properties.
    private Owner owner;
    public MainPage()
    {
    InitializeComponent();
    //initialize owner data
    InitializeOwner();
    }
    private void InitializeOwner()
    {
    owner = new Owner();
    owner.OwnerId = 1234567;
    owner.FirstName = "John";
    owner.LastName = "Smith";
    owner.Address = "Oxford Street 24";
    owner.ZipCode = "W1A";
    owner.City = "London";
    owner.Country = "United Kingdom";
    owner.State = "NA";
    owner.ImageName = "man.jpg";
    owner.LastActivityAmount = 100;
    owner.LastActivityDate = DateTime.Today;
    owner.CurrentBalance = 1234.56;
    owner.BirthDate = new DateTime(1953, 6, 9);
    owner.CustomerSince = new DateTime(1999, 12, 20);
    }
  4. Let's now focus on the form itself and build its UI. For this sample, we're not making the data editable. So for every field of the Owner class, we'll use a TextBlock. To arrange the controls on the screen, we'll use a Grid called OwnerDetailsGrid. This Grid can be placed inside the LayoutRoot Grid.
    We will want the Text property of each TextBlock to be bound to a specifi c property of the Owner instance. This can be done by specifying this binding using the Binding "markup extension" on this property.

    <Grid x:Name="OwnerDetailsGrid"
    VerticalAlignment="Stretch"
    HorizontalAlignment="Left"
    Background="LightGray"
    Margin="3 5 0 0"
    Width="300" >
    <Grid.RowDefinitions>
    <RowDefinition Height="100"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
    <RowDefinition Height="*"></RowDefinition>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
    <ColumnDefinition></ColumnDefinition>
    <ColumnDefinition></ColumnDefinition>
    </Grid.ColumnDefinitions>
    <Image x:Name="OwnerImage"
    Grid.Row="0"
    Width="100"
    Height="100"
    Stretch="Uniform"
    HorizontalAlignment="Left"
    Margin="3"
    Source="/CustomerImages/man.jpg"
    Grid.ColumnSpan="2">
    </Image>
    <TextBlock x:Name="OwnerIdTextBlock"
    Grid.Row="1"
    FontWeight="Bold"
    Margin="2"
    Text="Owner ID:">
    </TextBlock>
    <TextBlock x:Name="FirstNameTextBlock"
    Grid.Row="2"
    FontWeight="Bold"
    Margin="2"
    Text="First name:">
    </TextBlock>
    <TextBlock x:Name="LastNameTextBlock"
    Grid.Row="3"
    FontWeight="Bold"
    Margin="2"
    Text="Last name:">
    </TextBlock>
    <TextBlock x:Name="AddressTextBlock"
    Grid.Row="4"
    FontWeight="Bold"
    Margin="2"
    Text="Adress:">
    </TextBlock>
    <TextBlock x:Name="ZipCodeTextBlock"
    Grid.Row="5"
    FontWeight="Bold"
    Margin="2"
    Text="Zip code:">
    </TextBlock>
    <TextBlock x:Name="CityTextBlock"
    Grid.Row="6"
    FontWeight="Bold"
    Margin="2"
    Text="City:">
    </TextBlock>
    <TextBlock x:Name="StateTextBlock"
    Grid.Row="7"
    FontWeight="Bold"
    Margin="2"
    Text="State:">
    </TextBlock>
    <TextBlock x:Name="CountryTextBlock"
    Grid.Row="8"
    FontWeight="Bold"
    Margin="2"
    Text="Country:">
    </TextBlock>
    <TextBlock x:Name="BirthDateTextBlock"
    Grid.Row="9"
    FontWeight="Bold"
    Margin="2"
    Text="Birthdate:">
    </TextBlock>
    <TextBlock x:Name="CustomerSinceTextBlock"
    Grid.Row="10"
    FontWeight="Bold"
    Margin="2"
    Text="Customer since:">
    </TextBlock>
    <TextBlock x:Name="OwnerIdValueTextBlock"
    Grid.Row="1"
    Grid.Column="1"
    Margin="2"
    Text="{Binding OwnerId}">
    </TextBlock>
    <TextBlock x:Name="FirstNameValueTextBlock"
    Grid.Row="2"
    Grid.Column="1"
    Margin="2"
    Text="{Binding FirstName}">
    </TextBlock>
    <TextBlock x:Name="LastNameValueTextBlock"
    Grid.Row="3"
    Grid.Column="1"
    Margin="2"
    Text="{Binding LastName}">
    </TextBlock>
    <TextBlock x:Name="AddressValueTextBlock"
    Grid.Row="4"
    Grid.Column="1"
    Margin="2"
    Text="{Binding Address}">
    </TextBlock>
    <TextBlock x:Name="ZipCodeValueTextBlock"
    Grid.Row="5"
    Grid.Column="1"
    Margin="2"
    Text="{Binding ZipCode}">
    </TextBlock>
    <TextBlock x:Name="CityValueTextBlock"
    Grid.Row="6"
    Grid.Column="1"
    Margin="2"
    Text="{Binding City}">
    </TextBlock>
    <TextBlock x:Name="StateValueTextBlock"
    Grid.Row="7"
    Grid.Column="1"
    Margin="2"
    Text="{Binding State}">
    </TextBlock>
    <TextBlock x:Name="CountryValueTextBlock"
    Grid.Row="8"
    Grid.Column="1"
    Margin="2"
    Text="{Binding Country}">
    </TextBlock>
    <TextBlock x:Name="BirthDateValueTextBlock"
    Grid.Row="9"
    Grid.Column="1"
    Margin="2"
    Text="{Binding BirthDate}">
    </TextBlock>
    <TextBlock x:Name="CustomerSinceValueTextBlock"
    Grid.Row="10"
    Grid.Column="1"
    Margin="2"
    Text="{Binding CustomerSince}">
    </TextBlock>
    <Button x:Name="OwnerDetailsEditButton"
    Grid.Row="11"
    Grid.ColumnSpan="2"
    Margin="3"
    Content="Edit details..."
    HorizontalAlignment="Right"
    VerticalAlignment="Top">
    </Button>
    <TextBlock x:Name="CurrentBalanceValueTextBlock"
    Grid.Row="12"
    Grid.Column="1"
    Margin="2"
    Text="{Binding CurrentBalance}" >
    </TextBlock>
    <TextBlock x:Name="LastActivityDateValueTextBlock"
    Grid.Row="13"
    Grid.Column="1"
    Margin="2"
    Text="{Binding LastActivityDate}" >
    </TextBlock>
    <TextBlock x:Name="LastActivityAmountValueTextBlock"
    Grid.Row="14"
    Grid.Column="1"
    Margin="2"
    Text="{Binding LastActivityAmount}" >
    </TextBlock>
    </Grid>
  5. At this point, all the controls know what property they need to bind to. However, we haven't specifi ed the actual link. The controls don't know about the Owner instance we want them to bind to. Therefore, we can use DataContext. We specify the DataContext of the OwnerDetailsGrid to be the Owner instance. Each control within that container can then access the object and bind to its properties . Setting the DataContext in done using the following code:
    public MainPage()
    {
    InitializeComponent();
    //initialize owner data
    InitializeOwner();
    OwnerDetailsGrid.DataContext = owner;
    }

    The result can be seen in the following screenshot:

Microsoft Silverlight 4 Data and Services Cookbook Over 80 practical recipes for creating rich, data-driven business applications in Silverlight with this Microsoft book and eBook
Published: April 2010
eBook Price: $35.99
Book Price: $59.99
See more
Select your format and quantity:

How it works...

Before we take a look at the specifics of data binding, let's see what code we would need to write if Silverlight did not support data binding. The following is the ManualOwner class and we will be binding an instance of this class manually:

public class ManualOwner
{
public int OwnerId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Address { get; set; }
public string ZipCode { get; set; }
public string City { get; set; }
public string State { get; set; }
public string Country { get; set; }
public DateTime BirthDate { get; set; }
public DateTime CustomerSince { get; set; }
public string ImageName { get; set; }
public DateTime LastActivityDate { get; set; }
public double CurrentBalance { get; set; }
public double LastActivityAmount { get; set; }
}

The XAML code would look the same, apart from the binding markup extensions that are absent as we aren't using the data binding functionality. The following is a part of the code that has no data binding markup extensions:

<TextBlock x:Name="OwnerIdValueTextBlock"
Grid.Row="1"
Grid.Column="1"
Margin="2" >
</TextBlock>
<TextBlock x:Name="FirstNameValueTextBlock"
Grid.Row="2"
Grid.Column="1"
Margin="2" >
</TextBlock>
<TextBlock x:Name="LastNameValueTextBlock"
Grid.Row="3"
Grid.Column="1"
Margin="2" >
</TextBlock>
<TextBlock x:Name="AddressValueTextBlock"
Grid.Row="4"
Grid.Column="1"
Margin="2" >
</TextBlock>

Of course, the DataContext would also not be needed. Instead, we would manually have to link all the TextBlock controls with a property of the ManualOwner from code-behind as shown in the following code. As can be seen, this is not the most exciting code one can write!

public MainPage()
{
InitializeComponent();
//initialize owner data
InitializeOwner();
SetOwnerValues();
}
private void SetOwnerValues()
{
OwnerIdValueTextBlock.Text = owner.OwnerId.ToString();
FirstNameValueTextBlock.Text = owner.FirstName;
LastNameValueTextBlock.Text = owner.LastName;
AddressValueTextBlock.Text = owner.Address;
//other values go here
}

It's also easy to make errors this way. When a field gets added to the ManualOwner, we need to remember the places in which we have to update our code manually.

However, we can do better using data binding. Data binding enables us to write less code and have fewer opportunities to make errors.

Silverlight's data binding features allow us to bind the properties of the Owner instance to the Text property of the TextBlock controls using the Binding "markup extension". A markup extension can be recognized by a pair of curly braces ({}). It's basically a signal for the XAML parser that more needs to be done than simple attribute parsing. In this case, an instance of the System.Windows.Data.Binding is to be created for data binding to happen. The created Binding instance will bind the source object with the target control.

Looking back at the XAML code, we find that this binding is achieved for each TextBlock using the following code:


<TextBlock Text="{Binding CustomerSince}" />

This is, in fact, the shortened format. We could have written it as the following code:

<TextBlock Text="{Binding Path=CustomerSince}" />

The format for the binding is generally the following:

<TargetControl TargetProperty="{Binding SourceProperty,
SomeBindingProperties}" />

Note that using SomeBindingProperties, more options can be specified when creating t he binding. For example, we can specify that data should not only flow from source object to target control, but also vice versa. We'll explore a whole list of extra binding properties in the next recipes.

Are we missing something? Each control knows what it should bind to, but we haven't specifi ed the actual source of the data. This is done using the DataContext. We set the Owner instance to be the DataContext of the Grid containing the controls. All controls within the Grid can access the data. We'll look at the DataContext in a later recipe.

Finally, there is one important point to note; we can't just bind everything. Basically, there are two rules we must follow:

  1. The target object must be a DependencyObject (System.Windows. DependencyObject). In Silverlight 2 and Silverlight 3, the target could be a FrameworkElement instance only. FrameworkElement is lower in the class hierarchy than DependencyObject. Because of this, some important objects could not be used in data binding scenarios such as Transformations. Silverlight 4 has solved this problem.
  2. The target property must be a dependency property. Again, don't panic, as almost all properties on UI controls (such as text, foreground and so on) are dependency properties.

Dependency properties were introduced with WPF and can be considered as properties on steroids. They include a mechanism that at any point in time determines what the value of the property should be, based on several influences working on the property such as data binding, styling, and so on. They can be considered as the enabler for animations, data binding, styling, and so on.

More on dependency properties can be found at http://msdn.microsoft.com/en-us/library/system.windows.dependencyproperty.aspx.

There's more...

Instead of creating the Owner instance in code, we can create it from XAML as well. First, we need to map the CLR namespace to an XML namespace as follows:

xmlns:local="clr-namespace:SilverlightBanking"

In the Resources collection of the container (the UserControl), we instantiate the type like this:

<UserControl.Resources>
<local:Owner x:Key="localOwner"
City="London"
Country="United Kingdom"
FirstName="John"
LastName="Smith"
OwnerId="1234567 ...>
</local:Owner>
</UserControl.Resources>

The actual binding is almost the same, apart from specifying the source. We are not using the DataContext now, but we need to use the Source in each binding, referring to the item in the Resources:

<TextBlock x:Name="OwnerIdValueTextBlock"
Grid.Row="1"
Grid.Column="1"
Margin="2"
Text="{Binding OwnerId,
Source={StaticResource localOwner}}" >
</TextBlock>
<TextBlock x:Name="FirstNameValueTextBlock"
Grid.Row="2"
Grid.Column="1"
Margin="2"
Text="{Binding FirstName,
Source={StaticResource localOwner}}" >
</TextBlock>
<TextBlock x:Name="LastNameValueTextBlock"
Grid.Row="3"
Grid.Column="1"
Margin="2"
Text="{Binding LastName,
Source={StaticResource localOwner}}" >
</TextBlock>

See also

The DataContext makes its fi rst appearance in this recipe, but we'll look at it in more detail in the Obtaining data from any UI element it is bound to recipe in this article.

Creating dynamic bindings

In the previous recipe, you've learned how to use data binding in XAML. This is often useful because it allows you to show data easily to your user, for example, showing user information or a list of products. In this recipe, you'll learn how to do exactly the same in C# code, instead of XAML. This can be useful in situations where you want to bind a dependency property to the property of an object that you'll know only at runtime.

Getting ready

For this recipe, we can continue from the solution that was completed in the previous recipe. Alternatively, you can find the starter solution in the Chapter02/SilverlightBanking_ Dynamic_Bindings_Starter folder in the code bundle that is available on the Packt website. Also, the completed solution can be found in the Chapter02/SilverlightBanking_ Dynamic_Bindings_Completed folder.

How to do it...

We're going to change the code from the previous recipe, so we can create the bindings in C#, instead of XAML. To do this, we'll carry out the following steps:

  1. Open the solution created in the previous recipe,

    Displaying data in Silverlight applications, locate the grid named OwnersDetailsGrid in MainPage.xaml, and remove the Binding syntax from the XAML code for each TextBlock as shown in the following code:

    <TextBlock x:Name="OwnerIdValueTextBlock"
    Grid.Row="1"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="FirstNameValueTextBlock
    Grid.Row="2"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="LastNameValueTextBlock"
    Grid.Row="3"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="AddressValueTextBlock"
    Grid.Row="4"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="ZipCodeValueTextBlock"
    Grid.Row="5"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="CityValueTextBlock"
    Grid.Row="6"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="StateValueTextBlock"
    Grid.Row="7"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="CountryValueTextBlock"
    Grid.Row="8"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="BirthDateValueTextBlock"
    Grid.Row="9"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
    <TextBlock x:Name="CustomerSinceValueTextBlock"
    Grid.Row="10"
    Grid.Column="1"
    Margin="2">
    </TextBlock>
  2. Open the code-behind MainPage.xaml.cs file. Here, we're going to create the same bindings in the C# code. In the constructor, after the call to InitializeComponent(), add the following code:
    OwnerIdValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("OwnerId"));
    FirstNameValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("FirstName"));
    LastNameValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("LastName"));
    AddressValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("Address"));
    ZipCodeValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("ZipCode"));
    CityValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("City"));
    StateValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("State"));
    CountryValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("Country"));
    BirthDateValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("BirthDate"));
    CustomerSinceValueTextBlock.SetBinding(TextBlock.TextProperty,
    new Binding("CustomerSince"));
  3. We can now build and run the application, and you'll notice that the correct data is still displayed in the details form. The result can be seen in the following screenshot:

How it works...

This recipe shows you how to set the binding using C# syntax.Element.SetBinding expects two parameters, a dependency property and a binding object. The fi rst parameter defi nes the DependencyProperty of the element you want to bind. The second parameter defi nes the binding by passing a string that refers to the property path of the object to which you are binding.

There's more...

In our example, we've used new Binding("path") as the syntax. The binding object, however, has different properties that you can set and which can be of interest. A few of these properties are Converter, ConverterParameter, ElementName, Path, Mode, and ValidatesOnExceptions.

To know when and how to use these properties, have a look at the other recipes in this article and the next which explain all the possibilities in detail. They are, however, already mentioned in this recipe to make it clear you can do everything that is required as far as bindings are concerned in both C# and XAML.

>> Continue Reading: Working with Binding data and UI elements in Silverlight 4

If you have read this article you may be interested to view :

Microsoft Silverlight 4 Data and Services Cookbook Over 80 practical recipes for creating rich, data-driven business applications in Silverlight with this Microsoft book and eBook
Published: April 2010
eBook Price: $35.99
Book Price: $59.99
See more
Select your format and quantity:

About the Author :


Gill Cleeren

Gill Cleeren is Microsoft Regional Director (http://www.theregion.com), Silverlight MVP (former ASP.NET MVP) and Telerik MVP. He lives in Belgium where he works as .NET architect at Ordina (http://www.ordina.be/). Passionate about .NET, he’s always playing with the newest bits. In his role as Regional Director, Gill has given many sessions, webcasts and training on new as well as existing technologies, such as Silverlight, ASP.NET and WPF at conferences including TechEd Berlin 2010, TechDays Belgium – Switzerland - Sweden, DevDays NL, NDC Oslo Norway, DevReach Bulgaria, NRW Conference Germany, Spring Conference UK, Telerik Silverlight Roadshow in Sweden, Telerik RoadShow UK. He is the author of Packt’s Microsoft Silverlight 4 Data and Services Cookbook and is also the author of many articles in various developer magazines and for SilverlightShow.net and he organizes the yearly Community Day event in Belgium. He also leads Visug (http://www.visug.be), the largest .NET user group in Belgium. You can find his blog at http://www.snowball.be and on Twitter by following @gillcleeren.

Kevin Dockx

Kevin Dockx lives in Belgium and works at RealDolmen, one of Belgium's biggest ICT companies, where he is a 30-year old technical specialist/project leader on .NET web applications, mainly Silverlight, and a solution manager for Rich Applications (Silverlight, Windows Phone 7, WPF, Surface, HTML5). His main focus is on all things Silverlight, but he still keeps an eye on the new developments concerning other products from the Microsoft .NET (Web) Stack. As a Silverlight enthusiast, he's a regular speaker on various national and international events, like Microsoft DevDays in the Netherlands, Microsoft Techdays in Portugal, NDC Oslo Norway, and Community Day Belgium. He is the author of Packt’s Microsoft Silverlight 4 Data and Services Cookbook and also writes articles for various Silverlight-related sites & magazines. His blog, which contains various tidbits on Silverlight, .NET, and the occasional rambling, can be found at http://blog.kevindockx.com/, and you can find him on Twitter as well: @KevinDockx.

Books From Packt

Microsoft Silverlight 4 Business Application Development: Beginner’s Guide
Microsoft Silverlight 4 Business Application Development: Beginner’s Guide

SOA Patterns with BizTalk Server 2009
SOA Patterns with BizTalk Server 2009

ASP.NET MVC 1.0 Quickly
ASP.NET MVC 1.0 Quickly

Programming Microsoft Dynamics NAV 2009
Programming Microsoft Dynamics NAV 2009

VSTO 3.0 for Office 2007 Programming
VSTO 3.0 for Office 2007 Programming

Microsoft Dynamics AX 2009 Programming: Getting Started
Microsoft Dynamics AX 2009 Programming: Getting Started

Least Privilege Security for   Windows 7, Vista, and XP
Least Privilege Security for Windows 7, Vista, and XP

Learning SQL Server 2008 Reporting Services
Learning SQL Server 2008 Reporting Services

Code Download and Errata
Packt Anytime, Anywhere
Register Books
Print Upgrades
eBook Downloads
Video Support
Contact Us
Awards Voting Nominations Previous Winners
Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
Resources
Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software