Shawn Wildermuth's Blog

Second Week of European Conference Tour

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 26 Oct 2009 13:43:17 GMT

Last week I had the pleasure of presenting again at the SDN Conference. I had a great time at the conference. I ended up presenting (or co-presenting) six talks at the conference. The Silverlight talks were some of my favorites:

Using Silverlight Validation (download code)
Creating Behaviors for Silverlight 3 (download code)

In addition, I gave a breakout session at the Windows 7 launch (where they gave away 100 copies of Windows 7). My talk at the launch was:

Adding Windows 7 Features to Your .NET Applications

I was able to show off how to create TaskDialogs, Taskbar features like progress, thumbnails and jumplists. I had a lot of fun doing that talk (et lekker!).

A couple of days before the talk, I noticed that Ted Neward and I had a similar talk on MGrammar so we decided to co-host both sessions. Since Oslo is early, there were a lot of skeptics in the rooms; not all did we convert but it did create some very interesting discussion of what is a Domain Specific Language and whether Oslo is the key to DSLs in the Microsoft space. The talks I did on Oslo included:

Why Oslo Matters
Writing Your First MGrammar (co-presented with Ted Neward) (download code)
The Busy .NET Developer's Guide to DSLs in Oslo (co-presented with Ted Neward) (download code)

Of course conferences are not just about doing talks. They are also about visiting with *my* favorite speakers. The usual bunch were there:

Carl Franklin

Steve Forte and Richard Campbell

Beth Massi

Ted likes his soup:

Paco Likes Soup too (aka Hadi Hariri)

Its been a fun time, and almost 1/2 over.

[advertisement]
The Silverlight Tour is a three-day workshop covering topics from XAML and Blend to data access and server scenarios. For more information, see our website at http://silverlight-tour.com.

Fun with CollectionViews

shawn@wildermuth.com (Shawn Wildermuth) — Sun, 25 Oct 2009 17:06:25 GMT

URL: http://wildermuth.com/downloads/CollectionViewF...

I've recently been looking at the PagedCollectionView class. For those who are not familiar with this class, it allows you to automatically show sections of a collection in a paged way (especially when paired with the PagerControl). There is a good example on MSDN here:

http://msdn.microsoft.com/en-us/library/system.windows.data.pagedcollectionview(VS.95).aspx

The PagedCollectionView class supports the ICollectionView interface that supports a number of features that are really useful for dealing with collections. These include:

Sorting
Filtering
Grouping

To show this, I decided to start with a simple DataGrid. I created the PagedCollectionView and wrapped my data collection in it like so (GameList is a simple collection of a Game class to show some data):

PagedCollectionView view = 
  new PagedCollectionView(new GameList());

Then when data binding, I simple do the binding directly to the view instead of the collection:

theGrid.ItemsSource = view;

Using the PagedCollectionView as a wrapper for your collection provides the functionality of sorting, grouping and filtering to your collection. Let's start with sorting.

The ICollectionView interface has a SortDescriptions collection that is used to set the sort for the view. For example, to sort our collection by ReleaseDate then Name, we can add two SortDescription objects to the collection:

view.SortDescriptions.Clear();

view.SortDescriptions.Add(
  new SortDescription("ReleaseDate", 
                      ListSortDirection.Descending));

view.SortDescriptions.Add(
  new SortDescription("ProductName", 
                      ListSortDirection.Ascending));

In our DataGrid, both columns will mark themselves with the sort markers to indicate the search. You can reverse this if you need to detect the changes in sorting that happens when the user clicks on the columns to sort. You can do this by registering for the CollectionChanged event and looking at the SortDescription collection:

view.CollectionChanged += view_CollectionChanged;

...

void view_CollectionChanged(object sender, 
  NotifyCollectionChangedEventArgs e)
{
  foreach (var s in view.SortDescriptions)
  {
    MessageBox.Show(
      string.Concat("Sorting is: ", 
                    s.PropertyName, 
                    " - ", 
                    s.Direction));
  }
}

The ICollectionView also exposes the ability to group items in the DataGrid. To add grouping, you simply need to add new GroupDescription objects to the view's GroupDescription list. The only type of GroupDescription that is currently implemented is the PropertyGroupDescription which allows you to group by a property. For example, to group by the ReleaseDate I added a new PropertyGroupDescription like so:

view.GroupDescriptions.Add(
  new PropertyGroupDescription("ReleaseDate"));

In the DataGrid, these groups look like so:

The last feature I love about the ICollectionView interface is the ability to do arbitrary filtering. The interface has a Filter property that takes a Predicate<object> object. This way we can use a simple lambda to perform filtering. For example, to only show the games that have Microsoft in the name, I just create a simple lambda like so:

view.Filter = g => 
  ((Game)g).Publisher.Contains("Microsoft");

Cool, huh?

Five Minutes with Me

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 21 Oct 2009 12:30:21 GMT

URL: http://www.cloudcasts.net/ViewWebcast.aspx?webc...

While in Bulgaria, I was asked to sit down with Tibu Tiberiu “Tibi” Covaci for five minutes for a short list of questions. He's released the short podcast and go take a look here if you're interested in hearing what I have to say about the future of technology.

http://www.cloudcasts.net/ViewWebcast.aspx?webcastid=2521462397756387551

First Week of European Conference Tour

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 16 Oct 2009 07:37:20 GMT

One week into my European Conference tour and I thought it was time to send you lot a update. My first stop was Sofia, Bulgaria to join the great folks at DevReach. I got in a couple of days early so I could relax and get my time change down.

The first day I arrived I did the worst thing you can do when you are going to be away for five weeks: I broke my laptop screen. Yeah, I know. Here's a pic of it (click for bigger version):

I could try and do my talks with my netbook, but that seemed pretty impossible. So I inquired around and found out that a block away was a computer superstore (kind of a Bulgarian BestBuy). So I figured I just needed to a mid-powered computer that I could use around the office when I get home. One thing that you might not be familiar with is that the Bulgarian language uses Cyrillic alphabet so its very difficult to make out signs and such. At my hotel, the concierge was spectacular. He drove me over (remember, I am still hobbling around on a broken foot) to the store, waited for me and translated inside the store. Just what I needed. I picked up a little Inspiron N1545. Two interesting things about buying this laptop:

Most of the laptops for sale did not come with Windows. Either FreeDOS (yeah, DOS) or Linux (Ubuntu for the Dell).
The keyboard has Bulgarian alphabet superimposed:

The broken laptop just has a broken screen, so I was able to use the data on it. In case you don't know it, I actually keep ISOs and installers to repave my entire machine on my harddrive since I pave my machine about every six weeks. It saves me a lot of time (and saved my butt big time in this case). I was able to get the laptop up and running in time to do my first talk at DevReach.

DevReach treats the speakers really well and is great about taking us out to traditional Bulgarian food. Here's one of the parties with a lot of the usual subjects:

The ever-shy Carl Franklin was able to be coaxed into serenading the entire hotel:

I was able to catch up with the brilliant Tim Huckaby, Richard Campbell, Steve Forte and Chris Sells at the event as well. I also got to meet a number of great speakers that I hadn't had the chance to run into before. Its been a lot of fun...except...

The last day of DevReach I came down with a pretty bad flu. I've spent most of the last couple of days in bed and had to cancel my attendance to the Poland Code Camp in Krakow. I was really disappointed.

But as of today I am feeling pretty good and looking forward to heading out to the Netherlands in the morning to attend and speak at the SDC conference. I'll be speaking about Silverlight and Oslo, with a little Windows 7 talk thrown in. If you'll be around, don't be afraid to say hello!

I am on .NET Rocks Talking about Declarative UI's

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 13 Oct 2009 05:29:43 GMT

URL: http://www.dotnetrocks.com/default.aspx?ShowNum...

Before I left for Europe, I had a chance to sit down with Richard and Carl and espouse my views on views. Specifically we discussed how the separation of UIs (in declarative UI's like XAML and JavaScript templating) may help developers know specifically when they are in or out of the user interface part of their project. Hopefully this will make it easier to keep our code from getting tangled. Watch out for the bad pizza/spagetti code reference...

What Do We Want in Silverlight Validation?

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 05 Oct 2009 14:26:57 GMT

URL: http://niagara.codeplex.com

As I've been on the mend lately, i've been looking deep into how Validation should work in Silverlight. As I am trying to expand some of hte validation scenarios in Silverlight (in my Niagara project), I'd like to see how you are feeling about Validaiton.

Currently (as my previous post mentioned), the current validation stack is pretty tightly coupled to RIA Services (though with some work you can get it working with other data stacks). But the question is really which validation stack does Silverlight really need. Let's discuss the two I've been looking at: DataAnnotations and Enterprise Libraries' Validation Application Block.

DataAnnotations

Let's talk history. Back in .NET 3.5 SP1 (ok, I know many of you are still in .NET 2.0, my apologies), the DataAnnotations assembly was shipped. My assumption that this was to accomodate the newly christened Dynamic Data Web projects. Dynamic Data needed a way to communicate information it couldn't discern (like required fields, string length, etc.) The way that it did this was via a set of attributes in the System.ComponentModel.DataAnnotations. For example:

public class GameInfo
{
  [Required]
  [StringLength(100)]
  public string Name { get; set; }

  [Range(0d, 1000d)]
  public decimal Price { get; set; }
}

The problem with this approach was that in most cases, the classes were generated via an ORM (LINQ to SQL, Entity Framework, etc.) and adding these attributes on generated code just doesn't work. So someone came up with a workaround (or a hack if you prefer): the Metadata Type.

The idea behind a metadata type was that with partial types, users can add attributes to a class (but not a property) so by adding an attribute to each entity class that said, the metadata (e.g. validation attributes) for this class are stored in this metadata type that is never used except as a payload for the metadata about our entity. For example:

[MetadataType(typeof(Game.GameMetadata))]
public partial class Game
{
  internal sealed class GameMetadata
  {
    // Metadata classes are not meant to be instantiated.
    private GameMetadata()
    {
    }

    public string Description;

    public string Developer;

    public EntityState EntityState;

    public int GameID;

    public Genre TheGenre;

    public string ImageUrl;

    [Required]
    [StringLength(100)]
    public string Name;

    [Range(0d, 2000d)]
    public Nullable Price;

    public string Publisher;

    public Rating TheRating;

    public Nullable ReleaseDate;
  }
}

Early on, using the metadata classes to add these bits of data may have made sense because the sites you were creating were quick and dirty data editing sites. The problem is that this stack was adopted by RIA Services to allow for better validation in the Silverlight space (and eventually other platforms).

The DataAnnotations in RIA Services are a bit fractured as well. There are no less than three versions of the DataAnnotations that can cause confusion. The atttributes lists are different in these three versions:

.NET 3.5 SP1's System.ComponentModel.DataAnnotations
RIA Services's System.ComponentModel.DataAnnotations
Silverlight's System.ComponentModel.DataAnnotations

The three versions can cause some confusion as the attributes that you can use are duplicative (See .NET 3.5 SP1's Description attribute versus RIA Service's as an example).

The current Silverlight validation stack relies on exceptions to be thrown during set property setters (or you can validate the whole objects yourself). While this works, it does seem at odd with the work at hand and having a simple Validation model that returned results would be better IMHO. I understand that RIA Services was trying to fit into an existing Silverlight model but that doesn't mean I have to like it.

This stack may be good enough, especially with the ability to do custom validation with RIA Services but I sense that it may be too shallow for real validation.

Enterprise Library's Validation Application Block

On the other side of the coin is the Patterns and Practice team's Validation Application Block (VAB). This is a set of code that allows you to specify validation using either attributes or configuration files. While the Validation Application Block doesn't support Silverlight directly, I've been investigating it as an alternative design.

The Validation Application Block's design is focused on some of the same principals as the DataAnnotations but they were trying to solve some different problems. Some of the features of that design that may be of use in Silverlight are:

Multi-level validation (e.g. Validates with And/or clauses: "NULL or StringLength 5-25")
Configuration doesn't rely on attributes but can use them
Uses a provider model for specifying the validation so other sources of validation metadata are possible
Large number of built-in validations
Support for multiple sets of validation (RuleSets)
Validation is object-based to allow for cross validation (Either Name or CompanyName but not be null).
Fail-over validation detection (e.g. look for attributes, if not found look up configuration, etc.)
Validation returns simple ValidationResults which can be parsed or shown to the user. No Exceptions requried.

For example a typical attribute scenario for validation looks a lot like the RIA Services' approach:

[StringLengthValidator(1, 50, 
  Ruleset="RuleSetA", 
  MessageTemplate="First Name must be between 1 and 50 characters")]
public string FirstName
{
    get { return firstName; }
    set { firstName = value;  }
}

[StringLengthValidator(1, 50, 
  Ruleset = "RuleSetA", 
  MessageTemplate = "Last Name must be between 1 and 50 characters")]
public string LastName
{
    get { return lastName; }
    set { lastName = value; }
}

[RelativeDateTimeValidator(-120, 
  DateTimeUnit.Year, -18, DateTimeUnit.Year, 
  Ruleset="RuleSetA", 
  MessageTemplate="Must be 18 years or older.")]
public DateTime DateOfBirth
{
    get { return dateOfBirth; }
    set { dateOfBirth = value; }
}

[RegexValidator(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*", 
  MessageTemplate="Invalid e-mail address", 
  Ruleset = "RuleSetA")]
public string Email
{
    get { return email; }
    set { email = value; }
}

[ObjectValidator("RuleSetA", Ruleset = "RuleSetA")]
public Address Address
{
    get { return address; }
    set { address = value; }
}

[RangeValidator(0, RangeBoundaryType.Inclusive, 
  1000000, 
  RangeBoundaryType.Inclusive, 
  Ruleset = "RuleSetA", 
  MessageTemplate="Rewards points cannot exceed 1,000,000")]
public int RewardPoints
{
    get { return rewardPoints; }
    set { rewardPoints = value; }
}

In addition it supports a configuration-based solution:

 <validation>
    <type assemblyName="ValidationQuickStart.BusinessEntities, 
                        Version=1.0.0.0, 
                        Culture=neutral, PublicKeyToken=null"
          name="ValidationQuickStart.BusinessEntities.Address">
      <ruleset name="RuleSetB">
        <properties>
          <property name="City">
            <validator lowerBound="1"
                       lowerBoundType="Inclusive"
                       upperBound="30"
                       upperBoundType="Inclusive"
                       negated="false"
                       messageTemplate=""
                       messageTemplateResourceName=""
                       messageTemplateResourceType=""
                       tag=""
                       type="Microsoft.Practices.EnterpriseLibrary.
                         Validation.Validators.StringLengthValidator, 
                         Microsoft.Practices.EnterpriseLibrary.Validation"
                       name="String Length Validator" />
            <validator characterSet="1234567890!@#$%^&*()-="
                       containsCharacter="Any"
                       negated="true"
                       messageTemplate="City may not contain numbers"
                       messageTemplateResourceName=""
                       messageTemplateResourceType=""
                       tag=""
                       type="Microsoft.Practices.EnterpriseLibrary.Validation.
                         Validators.ContainsCharactersValidator, 
                         Microsoft.Practices.EnterpriseLibrary.Validation"
                       name="Contains Characters Validator" />
            <validator negated="false"
                       messageTemplate=""
                       messageTemplateResourceName=""
                       messageTemplateResourceType=""
                       tag=""
                       type="Microsoft.Practices.EnterpriseLibrary.Validation.
                         Validators.NotNullValidator, 
                         Microsoft.Practices.EnterpriseLibrary.Validation"
                       name="Not Null Validator" />
          </property>
      </ruleset>
    </type>
  </ruleset>
</validation>

This syntax while it works, its pretty terse and unreadable (as configuration tends to be). But it is decoupled which is nice.

While many of these features are laudable, it feels a bit over-engineered and complex. The VAB uses Validators for a number of cases where its just a grouping technique so debugging individual validations can be complex.

"Just Right?"

So here is where I put it to you, my readers:

"What do you need in Silverlight?"

Is the RIA Stack good enough?
Do you want validation regardless of what the transport is (ADO.NET Data Services, WCF, REST)?
Is using RIA Services' CustomValidation with method name good enough for custom scenarios?
Do you need complex validation (where AND/OR validation is necessary)?
How important is decoupling your validation metadata from the model?
Do you detest metadata types or is it just a necessary evil?

Please comment here so we can start a dialogue to help me understand what the development community is thinking about validation.

Speaking at TechEd Europe!

shawn@wildermuth.com (Shawn Wildermuth) — Sun, 04 Oct 2009 19:02:27 GMT

URL: http://www.microsoft.com/europe/teched/

I am excited to be asked to speak in Berlin this November at TechEd Europe 2009. This event is happening November 9-13th in Berlin, Germany. If you have a chance, it'll be a great time to see and be seen. There are a lot of great speakers that are all a must-see (humbling a bit).

I'll be doing two talks and participating in a panel:

Securing Microsoft Silverlight: Knowing the Enemy
Architecting Microsoft Silverlight Applications with MVVM

The panel is "Everything You Always Wanted to Know about Microsoft Silverlight, But Were Afraid to Ask" with Tim Heuer, Oliver Scheer and Damir Tomicic (and me!)

Bring your toughest questions...

My Favorite Silverlight Extensions APIs - Part 1

shawn@wildermuth.com (Shawn Wildermuth) — Sun, 04 Oct 2009 18:17:21 GMT

URL: http://slextensions.codeplex.com

As some of you may know, I am a contributor to the SilverlightContrib open source project. Recently this project and the Silverlight Extensions open source project (also know as SLExtensions) decided to merge to create a single place for a lot of interesting functionality.

I want to highlight some of the pieces that I didn't contribute as I've seen a lot of really great functionality for those of you who are building Silverlight Applications. I honestly have no idea how many parts this blog series will be, as long as I have parts that are interesting, I'll continue to post about them.

First up is SLExtension's Bootstrapper functionality. If you are currently using Prism or a related technology to compose your application at runtime, this functionality is lost on you. The Bootstrapper functionality is for that middle-ground where you want to break up your project into a small number of .xap files that are loaded when the project loads up but don't need a full composition engine with MEF or Prism.

The Bootstrapper functionality is in a separately assembly in the SLExtensions project (SLExtensions.Bootstrapping.dll). This is a small assembly (so that your main project loads fast). The way it works is to have you change the derived class for the App.xaml to a BootstrapApplication:

public partial class App : BootstrapApplication
{

Since its the App.xaml class, you'll need to change the XAML as well:

<bs:BootstrapApplication 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="FunWithBootstrapper.App"
  xmlns:bs="clr-namespace:SLExtensions.Bootstrapping;
            assembly=SLExtensions.Bootstrapping">
  <bs:BootstrapApplication.Resources>

  </bs:BootstrapApplication.Resources>
</bs:BootstrapApplication>

Once you have the application changed, you will need to override the Xaps property to supply the list of XAP files to load:

protected override IEnumerable<Uri> Xaps
{
  get
  {
    // Must be absolute Uris so we steal it from the host
    return new Uri[] { 
      new Uri(new Uri(Host.Source.AbsoluteUri), "SecondApp.xap"),
      new Uri(new Uri(Host.Source.AbsoluteUri), "ThirdApp.xap"),
    };
  }
}

At this point it will load up the other .xap files but we won't be able to do anything with them. So let's look at the other projects briefly.

Silverlight Projects" />

The other Silverlight projects are actually full Silverlight Applications (not Client Library projects). The Bootstrapper is usually used to create a 'splash screen' xap file that loads the other parts of the applications. Again, not real composition like Prism, but something less than that.

In the main project, you will make a reference to the other application projects. That's how you'll be able to reference the code from the other xap files (though only once they've been loaded).

To help you know when its updated, the Bootstrapper application has two facilities:

Progress event
OnApplicationReady overridable method

Now that you have a bootstrapping application, you want to be able to work with it. The first thing I usually do (because I want to use the Bootstrapping API's from anywhere without casting) is create a new static property on the Application class:

// Better access to the bootstrapping app
public static App MyApp
{
  get { return Current as App; }
}

Then I can use the Progress event to show the user some progress like so:

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
  App.MyApp.Progress += 
    new EventHandler<BootstrapEventArgs>(Bootstrap_Progress);
}

void Bootstrap_Progress(object sender, BootstrapEventArgs e)
{
  thePartProgress.Value = e.StepProgress;
  theFullProgress.Value = e.OverallProgress;
}

I'd like to be able to know when the application is completely loaded too. Unfortunately the Progress event tends to not return 100% at any time. I haven't figured out why yet, but to get around that you can use the OnApplicationReady overridable method:

public partial class App : BootstrapApplication
{
  ...
  
  protected override void OnApplicationReady(StartupEventArgs e)
  {
    // Do startup behavior
  }
  
  ...
}

While this works, I often don't want to do this work in the App class, but instead in other parts of my application (e.g. MainForm.xaml.cs). So For my use, I usually expose an event as well:

public event EventHandler<StartupEventArgs> StartupComplete;

protected override void OnApplicationReady(StartupEventArgs e)
{
  if (StartupComplete != null)
  {
    StartupComplete(this, e);
  }
}

By throwing an event when the application is ready, I can register for this event and do the startup once I know all the code is available:

// MainPage.xaml.cs
void MainPage_Loaded(object sender, RoutedEventArgs e)
{
  App.MyApp.Progress += 
    new EventHandler<BootstrapEventArgs>(Bootstrap_Progress);

  App.MyApp.StartupComplete += 
    new EventHandler<StartupEventArgs>(Bootstrap_StartupComplete);
}

void Bootstrap_StartupComplete(object sender, StartupEventArgs e)
{
  // Use the loaded types 
  // (SecondApp.MainPage and ThirdApp.MainPage)
  theSecondApp.Children.Add(new SecondApp.MainPage());
  theThirdApp.Children.Add(new ThirdApp.MainPage());
}

Note that once the bootstrapping has completed you can use the assemblies in the other .xap projects. If you attempt to use them before, you'll get an exception that it couldn't load the type.

Just to prove the point, here is a list of the .xap files. Notice that the 2nd and 3rd .xap file are pretty big but even with the bootstrapping assembly, our code is only 10K which means it should load very fast:

Neat? What do you think?

You can get the source to my example here:

http://wildermuth.com/downloads/FunWithBootstrapper.zip

No longer a C# MVP...

shawn@wildermuth.com (Shawn Wildermuth) — Thu, 01 Oct 2009 12:48:15 GMT

URL: https://mvp.support.microsoft.com/profile/Shawn...

Eight long years ago I was presented with my very first MVP. In those days I was a .NET MVP, the only designation for anyone doing .NET. Yeah, I am getting old ;)

A couple of years later they retired the .NET designation and separated the .NET MVP's into a number of groups. In those days I was "The ADO Guy" and none of the groups seemed like a good fit so I fell into being C# MVP. I chose C# mostly because I was doing WinForms, WebForms, SOA, Databases, etc. And nothing really crossed all those boundaries.

Of course the last few years I've been focused on Silverlight and the Silvelright Tour. I was approached last year to change my designation to a Silverlight MVP but again I was doing so many things that Silverlight felt too limiting...

That brings us to today. Behind the scenes for a few years I've been lobbying for a designation for those of us who are like me: we care about data. I have my hands in Silverlight, but my passion in is data (as it relates to Silerlight and other platforms). I write about ADO.NET Data Services, RIA Services, Web Services, etc. This year they've finally created our niche: Data Platform Development MVP (which I will just say MVP (Data) for simplicity). This means that while I am no longer a "C# MVP", I am a "Data MVP" and I am proud to be in this program, again!

Less Than Two Weeks Left Before Silverilght Tour in Miami!

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 30 Sep 2009 12:54:41 GMT

URL: http://agilitrain.com/workshop/info/Silverlight...

Are you ready...for Silverlight 3? If not, now's your time to ramp up in three days. The Silverlight Tour is coming back to Miami next week. It arrives on October 12th-14th in Miami, Florida and there are still seats available.

The new Silverlight 3 features covered include:

Out of the Browser Support
Pixel Shaders
Hardware Graphic Accelleration
Behaviors
Navigation Framework
Blend 3
SketchFlow
Binding Improvements
Secure Web Services
Binary XML Transport
RIA Services Client Controls
Text Rendering Improvements
Render Caching
And more...

In addition to the course, all attendess will also receive a free full-license to Telerik's RadControls for Silverlight. RadControls are built on Microsoft Silverlight 3 and include 34 UI controls for building rich line-of-business Silverlight applications.

To sign up for the class or hold a seat, visit the registration site:

http://silverlight-tour.com

Choosing a Data Access Layer for Silverlight 3

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 29 Sep 2009 00:07:56 GMT

If you're a regular reader of my blog, you'll probably remember my pithy blog post where I stated that "It all depends..." to the question "Which Data Access Should I Use for Silverlight 3?" The reality is that much like the similar question I am confronted with at user groups for the past decade ("What data access should I use in my .NET app?"). The reasons for picking a strategy are wide and varied so I will not try to analyze all possible outcomes, but I think the different strategies need to be explained better.

The three major candidates in Silverlight 3 are Web Services (WCF/ASMX), ADO.NET Data Services and RIA Services. In any situation, any of these will work. But they are suited to different styles and requirements. Here's the abridged differences between the stacks:

Web Services: Interface-based Data Access
ADO.NET Data Services: LINQ-based Data Access with change management
RIA Services: Interface-based Data Access with change management

Let's dive deeper into explaining these differences and why that might matter.

Web Services

Using web services is the tried and true method for communicating across the firewall. This pattern is well known and reliable. In general this requires you specify an interface for the CRUD operations as separate operations on a web service then dutifully call them in your Silverlight code.

Reasons to Use: Any existing investment in web services can be a great reason to use them (whether in code or skillset). Also, web services are often used in cases where a project wants a very close control over the flow from the application to the database.

Reasons to Avoid: With web services you end up having to keep track of the changes yourself and know what services to call with updates. Any need for batching or transactional support gets cumbersome and code-intensive.

ADO.NET Data Services

ADO.NET Data Services is a simple REST-based facility for data access. It relies on the HTTP stack to help define the interface. GET calls become Reads, POST becomes Updates and so on. It uses ATOM or JSON for its serialization format so it is consumable by a variety of clients.

Underneath its covers it takes this URI based API and converts it into a LINQ call for GETs and to API calls to the provider for inserts, updates and deletes. That means that ADO.NET is a thin layer who's purpose is to translate the URI model to data access code. But its better than that...

The real power of ADO.NET Data Services for Silverlight is the inclusion of the Client Library. This client library allows you to issue LINQ queries defined in the client and executed on the server. While the LINQ syntax is somewhat limited when compared to the server, it fulfills the 80% case and ADO.NET Data Services allows you to add operations to fill in the rest when necessary. In addition, the client library includes a powerful data context class that can monitor changes and issue changes in batches with transactional support.

Exposing your data access with ADO.NET Data Services is about exposing queryable end-points instead of defining an interface. This is what makes is unique. For example, we can query our service using a LINQ Query like so:

// Silverlight Code

// Create the query using LINQ
var qry = (from g in ds.Games
           where g.Price < 50m
           orderby g.Name
           select g) as DataServiceQuery<Game>;

// Execute the Query
// (This part is getting cleaner in ADO.NET Data Services v1.5) 
qry.BeginExecute(new AsyncCallback(r =>
  {
    games2.ItemsSource = qry.EndExecute(r).ToList();
    games2.DisplayMemberPath = "Name";
  }), null);

Reasons to Use: Want a simple, secure model where the developers can define the queries they need in code instead of changing the interface as the needs change. The ADO.NET Data Services' client library makes the amount of code you write on the client small as it becomes LINQ calls and working with the context class.

Reasons to Avoid: When you want tight control over the interface to your data access and do not want developers issuing LINQ queries directly from the client code.

RIA Services

As the new kid on the block, RIA Services has a lot to offer. RIA Services is based on the idea of creating a data access API on the server and at the same time creating the client code in Silverlight (and other platforms in the future). Its focused on sharing code between the client and the server including validation logic. In addition, while it allows you to create a set interface, it also provides a context object which can monitor changes on the client and batch those changes back to the server. In some ways RIA Services is like a hybrid of Web Services and ADO.NET Data Services.

Because RIA Services is based on a server-side query defined in its interface, on the client we call the query by calling the call on the interface:

// Silverlight Code

// The context object that tracks changes
XBoxGamesContext ctx = new XBoxGamesContext();

// Our RIA Query, really a call to an interface
var qry = ctx.GetGamesByGenreQuery("Shooter");

// Bind the data
theList.ItemsSource = ctx.Load<Game>(qry).AllEntities;

While in ADO.NET Data Services you are issuing LINQ queries, RIA Services also allow you to add LINQ constraints to the query endpoints. For example instead of just creating a query by calling the interface, you can add LINQ expressions to the endpoint like so:

var riaQry = ctx.GetGamesQuery()
                .Where(g => g.Price < 50m)
                .OrderBy(g => g.Name);

LoadOperation<Game> op = 
  ctx.Load<Game>(riaQry);

Reasons to Use: RIA Services is a good choice if you expect to develop a straightforward application minimum number of tiers. It works best in Rapid Application development scenarios versus large architected applications. RIA Services does support a mix between the interface based from Web Servics and and LINQ based querying that is supported by ADO.NET Data Services.

Reasons to Avoid: RIA Services leverages a lot of magic code generation to make it work and that is harder to debug than it should be. Integration with large enterprises is possible, its not as easy it as it should be.

"So Which Would You Suggest?"

While I paint this picture of data access in Silverlight with a broad brush, I still get the question to suggest one over the other. The fact remains that there isn't a right/wrong answer here. A lot of it depends on the environment, project and skillset of the developers. So, no...I won't tell you what I suggest because I don't know the requirements and environment you work in. That's why they pay you the big bucks to be a developer, right?

Niagara's Validation DSL - First Pass

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 28 Sep 2009 15:23:36 GMT

URL: http://niagara.codeplex.com

While Niagara is not going to require that you specify your validation attributes using its DSL, there are some benefits I think we can get by loosely coupling the validation. To that end, i've come up with a very first draft of the DSL to define the attributes. I've decided that instead of being very English-like, to mimic the "M" style of language. Here is my take:

// Niagara.Sample.Validation.validation
ValidationInfo
{
  Validators
  {
    // Some validators are built in
    // E.g. the System.ComponentModel.DataAnnotations
    MyCustomValidator = 
      "MyCustomValidator, Niagara.Example.Validators, Version 0.1"
  }
  
  Types("XBoxGames.Data, Version=1.0.0.0")
  {
    XBoxGames.Data.Game
    {
      Name { Required, StringLength(100) },
      Price { Range(0,2000) },
      Rating 
      {
        Required,
        MyCustomValidator("Adult", 1000)
      }
    },
    XBoxGames.Data.Genre
    {
      Name
      {
        Required,
        StringLength(100)
      }
    },
    XBoxGames.Data.Rating
    {
      Name
      {
        Required,
        StringLength(100)
      }
    }
  }
}

For any comments, please add them to the codeplex site here instead of commenting on the blog:

http://niagara.codeplex.com/Thread/View.aspx?ThreadId=70371

Introducing Project Niagara

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 28 Sep 2009 01:59:01 GMT

URL: http://niagara.codeplex.com

The goal of Project Niagara is to democratize the validation support. The project wants to help developers add validation support to ADO.NET Data Services as well as Web Services in Silverlight. In addition, it has the goal of allowing multiple ways to supply the validation metadata to the different data access strategies. As it is my opinion that there are scenarios where attributes are not the best idea.

The deliverables for this project will include:

ValidatingDataSvcUtil: Produce Validating Data Service Proxies.
ValidatingProxy Library: Supply external metadata for generation of Proxies.
MValidation: DSL for defining Validation outside of attributes.
Oslo Integration: to store/retrieve validation out of the Oslo Repository.
Alignment: RIA Services' and ADO.NET Data Services' Validation Logic

At this point the project is very young (version 0.1) and a lot of the pieces are not ready but I am looking for help! I can't write it all. Please visit the CodePlex site and take a look at what I want to accomplish and send me a message if you want to help out:

http://niagara.codeplex.com

Current State of Niagara

Currently, I have built up some infrastructure to allow the whole project. This inlcudes a first pass at the DSL. The one working pieces is the ValidatingDataServiceUtil which allows you to manually generate (via the command-line) an ADO.NET Data Service proxy that includes support for validation attributes and calling validation during two-way binding.

The current version does not have a release yet, but if you're brave and willing to report bugs, you can get the source and build it yourself.

To use the ValidatingDataServiceUtil, you can call it from the command-line:

NiagaraDataServiceUtil.exe http://localhost:14000/GameService.svc 
  ..\Niagara.Sample.Web\bin\Niagara.Sample.Web.dll 
  .\GameService.cs 
  Niagara.Sample.Data /v /b /c:V2

While more complex than the original DataSvcUtil, the arguments are pretty straightforward:

URI to the ADO.NET Data Service endpoint.
Path to the assembly that holds the types and metadata (so we can read the metadata with reflection).
The output file.
The namespace to use.
Options to specify what version of the data service library to use, bindability and validation.

This is an alternative to using a service reference. We hope to move this to be a project item instead of a command-line for the project.

NOTE: It requires the ADO.NET Data Services CTP2 to work.

Let me know what you think!

How Silverlight 3 Validation Works

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 28 Sep 2009 01:57:44 GMT

As RIA Services is plodding towards a release, many people are looking at it to help them with validation of data in Silverlight. Using this validation in Silverlight 3 is pretty straightforward but there are some caveats. I want to show you under the covers so you understand what is happening. In this first part of the series, let's look at what it means to use validation from the outside.

How It Works

Back when Dynamic Data was being developed, a set of attributes was created to help tell the Dynamic Data folks about validation and other metadata so they could create smart scaffolds. These include:

RequiredAttribute
StringLengthAttribute
RangeAttribute
RegularExpressionAttribute

In addition, there were attributes that could tell Dynamic Data about how to name fields and such. This meant that if you were using a POCO class or a DTO, that you could do the annotation like so:

public class GameInfo
{
  [Required]
  [StringLength(100)]
  public string Name { get; set; }

  [Range(0d, 1000d)]
  public decimal Price { get; set; }
}

When the GameInfo class is generated on the client, that's how the validaiton is happening. On the client we can simply bind to the DataForm to show the validation in action:

While the DataForm will do this in a generic fashion (or even let you define templates), many Silverlight applications would like this validation behavior without using the DataForm. In fact, all the Silverlight 3 controls now support it but only if you know how to bind the elements correctly. If we bind the GameInfo to a StackPanel with some controls, we can get this same validation experience:

This works in two ways. First the controls themselves have support built-in for the validation part of the user control. When you skin a TextBox or other control, part of the ControlTemplate is the validation UI. So you can change what that looks like. The controls themselves react to the validation errors because of the way they are bound. For example, this simple UI looks like this in XAML:

<TextBlock>Name</TextBlock>
<TextBox Text="{Binding Name, Mode=TwoWay, 
                              NotifyOnValidationError=true, 
                              ValidatesOnExceptions=true}" />
<TextBlock>Price</TextBlock>
<TextBox Text="{Binding Price, Mode=TwoWay, 
                               NotifyOnValidationError=true, 
                               ValidatesOnExceptions=true}" />

These three parts of the binding are critical to making this work. The validation is performed when the data is pushed back into the backing data but how does this actually work? The hint is in the "ValidatesOnExceptions".

With a TwoWay binding, when you lose focus on a control, the value is pushed back to the control (including going through any converters you have specified). Normally if an exception is thrown during that process it fails to update the underlying object, but just swallows that error. But if you enable it with these two binding markup extensions, it assumes that any exception thrown during the TwoWay operation is a Validation error. Back in Silverlight 2, you could do this by simply adding validation logic directly in your data classes like so:

public string Name
{
  get
  {
    return this._name;
  }
  set
  {
    if ((this._name != value))
    {
      if (value.Length > 100)
      {
        throw new ValidationException(
          "String cannot be longer than 100 characters");
      }

      this._name = value;
    }
  }
}

This is where the Validaiton attributes we mentioned earlier come in. The controls themselves do not make the check for the validation. Instead there are two classes that come into picture. ValidationContext and Validator. These classes can be used to test a property's or an entire object's set of validation attributes. Essentially, the ValidationContext sets up what needs to be validated and the Validator performs the validation like so:

public string Name
{
  get
  {
    return this._name;
  }
  set
  {
    if ((this._name != value))
    {
      var ctx = new ValidationContext(this, null, null);
      ctx.MemberName = "Name";

      // If fails, throws an excption
      Validator.ValidateProperty(value, ctx);

      this._name = value;
    }
  }
}

These classes working together validates the value against whatever ValidationAttributes are on the "Name" property (e.g. Required, StringLength) and throws a ValidationException when it fails. In fact, lets look look at the RIA Services class it generates in Silverlight:

[DataMember()]
[Required()]
[StringLength(100)]
public string Name
{
  get
  {
    return this._name;
  }
  set
  {
    if ((this._name != value))
    {
      this.ValidateProperty("Name", value);
      this.OnNameChanging(value);
      this.RaiseDataMemberChanging("Name");
      this._name = value;
      this.RaiseDataMemberChanged("Name");
      this.OnNameChanged();
    }
  }
}

In fact, the first thing that the generated class does is call a base class method called ValidateProperty which does the same thing as our previous example. Understanding how this really works is key to debugging odd scenarios (like a validation exception showing up for a conversion failure).

Trouble with the Code Generation

Most of us are not using POCO classes (yet) for our data containers, but are using ORM's to build our data layers for us. This was a problem for the Dynamic Data folks back a while and came up with the idea of Metadata Types. A metadata type is simply a way of specifying a candiate class. In fact RIA services does this for you (if you ask it nicely) but you can specify these yourself. The key is the MetadataType attribute which is useful to do in the partial class. For example for an Entity Framework type:

[MetadataType(typeof(Game.GameMetadata))]
public partial class Game
{
  internal sealed class GameMetadata
  {
    // Metadata classes are not meant to be instantiated.
    private GameMetadata()
    {
    }

    public string Description;

    public string Developer;

    public EntityState EntityState;

    public int GameID;

    public Genre TheGenre;

    public string ImageUrl;

    [Required]
    [StringLength(100)]
    public string Name;

    [Range(0d, 2000d)]
    public Nullable Price;

    public string Publisher;

    public Rating TheRating;

    public Nullable<DateTime> ReleaseDate;
  }
}

This class is a place that the validation or dynamic data runtimes can look for the attributes. Note, that this example uses a nested type but it could be a completely separate type as well.

NOTE: This works with RIA Services great. But its a hack. To pretend its anything but a hack is deluding yourself. My opinion is that this sort of information that is view specific should probably be loosely coupled instead of tightly in the form of attributes. If we did this on POCO classes, we'd be forced to have the validation attributes exist as a reference in every place we need them.

Just RIA Services?

There are many organizations out there that aren't using RIA Services for their data access (and i'll blog soon about why RIA Services is just a solution, not *the* solution data access). But if you are already using ADO.NET Data Services or Web Services, hooking into the validation logic is difficult. Adding the attributes is difficult in Silverlight since the generated code doesn't have any place to hook up the attributes (and MetadataType isn't supported in Silverlight). In addition, the attributes are only part of the problem as you'd need to build in the ability to do the validation on the set/gets (which is possible with ADO.NET Data Services but impossible with today's Web Service proxies). So today, this is most easily accomplished using RIA services. But I don't believe that in the best interest of developers.

If you've followed this blog, you know that I love the idea of choice (e.g. my LINQ to Hibernate ADO.NET Data Example). So I want to be able to leverage the Validation logic no matter what what data access you're using. I have started a new project called Niagara that I hope will address some of these issues. See my blog post about it here:

http://wildermuth.com/2009/09/28/Introducing_Project_Niagara

Fall/Winter Silverlight Tour Schedule

shawn@wildermuth.com (Shawn Wildermuth) — Sun, 20 Sep 2009 23:07:09 GMT

URL: https://agilitrain.com/workshop/info/Silverligh...

We have made some adjustments in the Fall/Winter schedule for the Silverlight Tour. As Fall is often our busiest time of year, we decided to move some dates around to not conflict with the PDC and other conferences. Here is the new Schedule for the Silverlight Tour and the Advanced Silverlight Workshop:

Silverlight Tour

Oct 12-14, 2009		Miami, FL
Dec 2-4, 2009		Portland, OR
Dec 7-9, 2009		Atlanta, GA
Jan 4-6, 2010		San Francisco, CA

Advanced Silverlight Workshop

Nov 30-Dec 1, 2009		Atlanta, GA
Mar 22-23, 2010		Atlanta, GA

Note that by attending the Silverlight Tour workshop, you not only receive a full version of Telerik's RadControls for Silverlight but also get a discount to attend the Advanced Silverlight Workshop.

Using Large Message Requests in Silverlight with WCF

shawn@wildermuth.com (Shawn Wildermuth) — Thu, 10 Sep 2009 21:17:11 GMT

Today I was working with a client and ran into a problem I didn't expect. This particular problem had to do with Silverlight consuming a WCF Service. Sometimes WCF causes me to spew four letter words. There is a class of WCF problems that cause this: connection rejection. WCF has been designed to prevent common DDoS and other attacks that could cause servers to fail or at least not serve honest requests. To this end the default size of a request is quite small. In fact, its usually 64K in size. This size is fine for most every request but occassionally when a client wants to send a collection of things to the server this size is too small. But we'll get to that in a minute. First, some background...

This particular client has a large service that's been working for quite a while, then suddenly a single call he has was being rejected. The new service call he was making was sending back a list of a couple of hundred of POCO classes. He had been downloading large lists before so on the surface this should have worked. But it didn't.

The cause was that the default WCF limits were rejecting the connection. This type of error where its just failing, even Fiddler isn't helpful. There is no return code, the connection is just severed. Debugging it requires some trial and error which sucks. The calls that were returning a lot of data were working fine because the default ClientConfig file looks like this:

<configuration>
  <system.serviceModel>
    <bindings>
      <customBinding>
        <binding name="CustomBinding_MyService">
          <binaryMessageEncoding />
          <httpTransport maxReceivedMessageSize="2147483647"
                       maxBufferSize="2147483647">
            <extendedProtectionPolicy policyEnforcement="Never" />
          </httpTransport>
        </binding>
      </customBinding>
    </bindings>
    <client>
      <endpoint address="http://127.0.0.1.:8000/MyService.svc"
                binding="customBinding"
                bindingConfiguration="CustomBinding_MyService"
                contract="MyServices.MyService"
                name="CustomBinding_MyService" />
    </client>
  </system.serviceModel>
</configuration>

The maxReceivedMessageSize and maxBufferSize both accept these large responses from the server. But the reverse isn't true. The server's defaults are about 64K. Since we got it working, I wanted to show what we did so maybe others could use these server settings to address it.

The trick is to change the customBinding in the web.config to use larger defaults. I picked 2MB as it its a reasonable size. Of course setting them to 2GB like shown above will work but it does leave you more vulnerable to attacks. Pick a size that isn't larger than your largest request but isn't overly large. Its a guessing game. To set these, you need to add them to your web.config is to put them on the httpTransport node:

<system.serviceModel>
  <behaviors>
    <serviceBehaviors>
      <behavior name="TestLargeWCF.Web.MyServiceBehavior">
        <serviceMetadata httpGetEnabled="true"/>
        <serviceDebug includeExceptionDetailInFaults="false"/>
      </behavior>
    </serviceBehaviors>
  </behaviors>
  <bindings>
    <customBinding>
      <binding name="customBinding0">
        <binaryMessageEncoding />
        <httpTransport maxReceivedMessageSize="2097152"
                     maxBufferSize="2097152" 
                     maxBufferPoolSize="2097152" />
      </binding>
    </customBinding>
  </bindings>
  <serviceHostingEnvironment aspNetCompatibilityEnabled="true"/>
  <services>
    <service behaviorConfiguration="Web.MyServiceBehavior"
             name="TestLargeWCF.Web.MyService">
      <endpoint address=""
                binding="customBinding"
                bindingConfiguration="customBinding0"
                contract="TestLargeWCF.Web.MyService"/>
      <endpoint address="mex"
                binding="mexHttpBinding"
                contract="IMetadataExchange"/>
    </service>
  </services>
</system.serviceModel>

That's the trick. Hope it helps you not waste your day like I wasted mine ;)

ADO.NET Data Services 1.5 Feature: Projections

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 09 Sep 2009 22:34:36 GMT

If you've been following my blog, you should know that I am keeping a pretty close watch on ADO.NET Data Services. The team recently released a second CTP of the new version with some interesting features. This CTP has some pretty compelling additions, but I am going ot focus on one in particular.

I've been teaching and using ADO.NET Data Services for a long time and I like showing off exposing a LINQ-based provider (Entity Framework, NHibernate or others) to a Silverlight application. While ADO.NET Data Services does expose its API through a REST API, the magic for me is in its use in Silverlight. In case you haven't been following along, using the Silverlight client you can issue a LINQ query through the Silverlight client (though in fairness, the full power of LINQ is not supported in the client):

var qry = (from g in ctx.Games
           where g.Genre.Name == "Shooter"
           orderby g.ReleaseDate
           select g) as DataServiceQuery<Game>;

qry.BeginExecute(new AsyncCallback(r =>
{
  try
  {
    theList.ItemsSource = qry.EndExecute(r).ToList();
  }
  catch (Exception ex)
  {
    // NOOP
  }
}), null);

This is a powerful feature so that (unlike web services) developers can use a looser service definition to define their data stack. Let the developer who needs data be able to sort, filter and shape that data as necessary.

The last part of that phrase is "shape" on purpose. When I first teach this technology, I am often asked "what sort of shaping do you mean?" In ADO.NET Data Services 1.0, you could shape it by returning a hierarchy of data using the Expand method in the LINQ query. For example, we can return the game data with the Genre entity attached to every game like so:

var qry = (from g in ctx.Games
                        .Expand("Genre")
           where g.Genre.Name == "Shooter"
           orderby g.ReleaseDate
           select g) as DataServiceQuery<Game>;

qry.BeginExecute(new AsyncCallback(r =>
{
  try
  {
    theList.ItemsSource = qry.EndExecute(r).ToList();
  }
  catch (Exception ex)
  {
    // NOOP
  }
}), null);

But this level of shaping is powerful but limited in scope. This is where ADO.NET Data Services 1.5 comes up trumps. In this new CTP we can now do projections to retrieve specific data. For example:

var qry = (from g in ctx.Games
           where g.Genre.Name == "Shooter"
           orderby g.ReleaseDate
           select new
           {
             Name = g.Name,
             ReleaseDate = g.ReleaseDate.GetValueOrDefault(),
           }) as DataServiceQuery;

This query creates a new anonymous type that has the two values we want instead of returning the entire entity. In any other .NET project this would be fine, but for Silverlight we can't use the anonymous type for data binding (for security reasons). So like other anonymous type uses in Silverlight, you must project them into a known type. A type like that is pretty easy to cruft up if you need:

var qry = (from g in ctx.Games
           where g.Genre.Name == "Shooter"
           orderby g.ReleaseDate
           select new GameInfo()
           {
             Name = g.Name,
             ReleaseDate = g.ReleaseDate.GetValueOrDefault()
           }) as DataServiceQuery<GameInfo>;

This is useful to no only limit the fields you return but also to shape the result. For example we can use the projection to retrieve the name, release date and the genre's name (normally a related object) like so:

var qry = (from g in ctx.Games
           where g.Genre.Name == "Shooter"
           orderby g.ReleaseDate
           select new GameInfo()
           {
             Name = g.Name,
             ReleaseDate = g.ReleaseDate.GetValueOrDefault(),
             GenreName = g.Genre.Name
           }) as DataServiceQuery<GameInfo>;

This is all well and good, but what about saving these projections? For the most part you should treat complex projections (like the one above) as read-only. But if you retrieve entities that are purely subsets of existing entities, then ADO.NET Data Services will handle it. Though currently this is crashing in Silverlight (it is a CTP after all). I will update this if I find a way around the saving bug in the near future and post the demo at that time.

But in general this is an awesome new addition to the library that I hope will close some of the use-cases that forced me to write Service Operations in the past.

What do you think?

Silverlight Data Examples Have Been Updated!

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 02 Sep 2009 16:44:25 GMT

URL: http://www.silverlightdata.com

If you've never had the chance to visit my sister site (http://www.silverlightdata.com), now's a good time. I've updated my examples there to include my MVVM, Prism and Declarative UI examples (to go with the skinning/switchable Astoria example). Take a look if you're doing Silverlight data-based applications.

Why Declarative UIs Are Important

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 02 Sep 2009 11:42:50 GMT

URL: http://wildermuth.com/downloads/declarativeui.zip

If you're building Internet applications, you've probably been bombarded with lots of new technologies the last few years: Silverlight, Flex, ASP.NET MVC, jQuery, etc. While all of these technologies have their use-cases, many of them are pointing to something that is new and important.

The central idea of separating concerns is not new. Back in SmallTalk when Model-View-Controller was born, the benefits of isolating layers of an application were pretty apparent. The problem was that it wasn't easy to implement. The problem with implementation was never the code...or was exactly the code. The problem is that when you are working on a problem in the user interface, it is far to easy to try and solve it directly in the code. Its not laziness or lack of talent. Its simply a matter of focus sometimes. Under the timeline gun its easy to be myopic about a problem. Its simply too easy to just try and solve a problem by writing code in the user interface (or the View).

This is why I think that Declarative User Interfaces are so important. But what are Declarative User Interfaces? Simply put, Declarative User Interfaces (or Declarative UIs) are defining views using markup to deliver content and behavior. The two most obvious examples in the Microsoft space are XAML and MVC Views. What makes Declarative UI's so seductive is that fact that putting non-UI code (or business logic) in the markup is not only difficult but tends to feel wrong. That sort of code sticks out like a thumb. In my opinion, it encourages the behavior of keeping the View as purely user interface code. Let's use Silverlight as an example of building using a Declarative UI.

An Example

I started by staying completely in Blend to do my design. My basic, but simple idea, was an editor for XBox games (yeah, I know) that could select by Genre the games to view. Here's my original concept:

Now that idea is fine, but I needed some data to clarify my ideas so I used the Blend Sample Data feature to create some dummy data. At this point all I am doing is proving my design, but at the same time I am getting a data shape that development (me in this case, but possibly different people) will use later as the data I want to edit. By defining this shape, I am allowing myself to do the data binding. My Sample Data in Blend looks something like this:

Once data bound, my initial user interface looks like so:

Normally, this would be the time that the user interface would initially be handed over to development. Since I wrote everything, I moved on to Visual Studio. The benefit of doing this much work in Blend first is that all I need to do is handle creating the data and replace the sample data with my own data and we can move on.

Once in Visual Studio, you should notice that the sample data is now part of your project. The Sample data is included in the App.XAML file like so:

<Application xmlns="..."
             xmlns:x="..."
             xmlns:SampleData="..."
             xmlns:d="..."
             xmlns:mc="..."
             x:Class="DeclarativeUI.App"
             mc:Ignorable="d">
  <Application.Resources>
    <!-- Resources scoped at the Application 
         level should be defined here. -->
    <SampleData:GamesData x:Key="GamesData"
                          d:IsDataSource="True" />
  </Application.Resources>
</Application>

This data is used in the main view simply as its DataContext (because that's how I bound the sample data in Blend):

<UserControl xmlns="..."
             xmlns:x="..."
             x:Class="DeclarativeUI.MainPage"
             DataContext="{Binding Source={StaticResource GamesData}}">

Now that I am in Visual Studio, I can start replacing the Sample Data. I built a Model and a ViewModel (see my MSDN Magazine article here for more information on MVVM in Silverlight). The ViewModel simply exposed the same sort of data that the sample data does (though I am returning a fuller Game and Genre object since there is more data in the database):

public interface IMainViewModel : IViewModel
{
  ObservableCollection<Genre> Genres { get; }
  ObservableCollection<Game> Games { get; }

  void GetGenresAsync();
  void GetGamesByGenreAsync(object sender, EventArgs args);
  void SaveAllAsync();
}

The ViewModel looks like the Sample Data so simply setting the DataContext with my ViewModel should work at showing the sample data. But we're only partly there. Note that the ViewModel interface exposes both the Genres and Games collections that we defined in the sample data, but also exposes the methods that performs the data access verbs. This is where Declarative UIs can be really powerful.

In Silverlight 3, the Blend team introduced Behaviors to simplify actions and triggers in XAML. For the WPF-aware readers, Behaviors are different in that they are pre-packaged bundles of functionality. While most behaviors are tied to performing actions on the user interface directly (e.g. ControlStoryboardAction) they are not technologically limited in that way. In my early experiments with Behaviors, I had created a simple behavior to call into a ViewModel. Because Behaviors can work with data binding, it becomes an easy way to interact with the ViewModel (without having a hard connection to it). They allow our UI's to be declarative but still separating those concerns.

My Behavior had a lot of problems with it and I had been looking for time to revisit it when I ran into the Blend team's new sample behaviors:

http://expressionblend.codeplex.com

This project adds a number of behaviors to Blend including several specifically for data-driven applications. While all the data-driven behaviors are interesting, i'll focus on one for our problem: CallDataMethod. This behavior allows you to call a method on an object (usually the DataContext) when an event fires.

In our XAML code, I decided that I needed to load the combobox full of Genres as the first data call. Since I am allowing users to filter by Genre, the combobox will be the source of that filtering. So I added the Behavior which looks like this in XAML:

<i:Interaction.Triggers>
  <i:EventTrigger EventName="Loaded">
    <si:CallDataMethod Method="GetGenresAsync" />
  </i:EventTrigger>
</i:Interaction.Triggers>

The behavior simply reacts to the UserControl's Loaded event (so that this fires when the XAML is loaded) and calls the GetGenresAsync method. If you look at our interface, you will notice that GetGenresAsync method takes no parameters which is one of the signatures that the CallDataMethod behaviors supports.

When the Loaded event fires, the behavior calls GetGenresAsync which starts the call to the server to get the data. When that operation comples, the ViewModel simply fills in the Genres into the Genres collection on the ViewModel so that it is shown in UI. We could throw an event to the UI, but that's not necessary because the same return can show the error information. How? Let's look at the ViewModel code:

void theModel_OnGenresCompleted(object sender, EntityEventArgs<Genre> e)
{
  if (e.Error != null)
  {
    ErrorMessage = e.Error.ToString();
  }
  else
  {
    theGenres.Clear();

    foreach (var g in e.Results.OrderBy(g => g.Name))
    {
      theGenres.Add(g);
    }
  }

  IsBusy = false;
}

Notice when the Genres are returned from the server that we are sending in whether there was an error. And if an error was returned, we simply set the string on an ErrorMessage property. This is a property that the UI is data bound to in order to show the error. This way we still don't need an event thrown to the UI to communicate the error. This is a pattern in ViewModels I use quite a lot as it helps our UI's stay declarative and clean.

To load the DataGrid with games, I needed to use the CallDataMethod trigger again. But in this case, I need to be able to tell the ViewModel which Genre was selected. The CallDataMethod takes a very simple approach and simply will allow you to use the standard event syntax as well (see how the interface supports the standard event signature of an object and an EventArgs):

<ComboBox x:Name="Genres"
          HorizontalAlignment="Left"
          Margin="8,2,0,0"
          Width="150"
          Grid.Row="1"
          DisplayMemberPath="Name"
          ItemsSource="{Binding Genres, Mode=OneWay}">
  <i:Interaction.Triggers>
    <i:EventTrigger EventName="SelectionChanged">
      <si:CallDataMethod Method="GetGamesByGenreAsync" />
    </i:EventTrigger>
  </i:Interaction.Triggers>
</ComboBox>

So when the SelectionChanged event is fired on the combobox, we call the GetGamesByGenreAsync method. That method has the standard event syntax so that in the event we can retrieve the selected Genre:

public void GetGamesByGenreAsync(object sender, EventArgs e)
{
  IsBusy = true;
  var sel = sender as Selector;
  if (sel != null && sel.SelectedItem is Genre)
  {
    theModel.GetGamesByGenreAsync(((Genre)sel.SelectedItem).Name);
  }
}

Note that this method assumes that the UI is using some sort of Selector (from which ListBox, ComboBox and ItemsControl all derive) which is a concession to the separation. But if it weren't a Selector, we could probably craft this same experience with other behaviors. Because we can get the selected element from the Selector, our View still is very declarative.

This is why I think declarative UIs are so powerful. We are leaving all the look and feel of the application directly in the markup. So that the XAML is self describing and it makes it harder to write business logic code in the user interface. That should be left in the other tiers where it belongs.

So Declarative User Interfaces are Code-less?

The answer is yes and no. While declarative user interfaces can be codeless in many cases, it should not be dogmatic. If it makes sense to write code in a view, write the code. The power here is to do most of the work required in the markup itself. Purity for purity sake is not helpful. But if you do write code in your view, it better not be business logic. If you need business logic, communicate back to the VM or with the data objects themselves. That's where it belongs.

You can get the source to this sample here (which includes both an "AfterBlend" version and a "AfterVS" version):

http://wildermuth.com/downloads/declarativeui.zip

What do you think?

My SketchFlow .NET Rocks TV Episode is up (DNR-TV)

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 31 Aug 2009 19:44:25 GMT

URL: http://dnrtv.com/default.aspx?ShowID=148

I am excited to announce that my new DNR-TV episode is up at .NET Rocks. Carl and I visited while we were both at DevTeach to show off Blend's new SketchFlow functionality. If you have time, give it a spin!

A Plethora of Silverlight Behaviors/Triggers

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 25 Aug 2009 21:06:52 GMT

URL: http://expressionblend.codeplex.com/

It looks like the Expression team is skulking around and releasing code. They've just released a bunch of behaviors on the new Expression Blend Samples CodePlex project. The number of sample behaviors and triggers is just staggering:

PlayMedia
PauseMedia
TogglePlayPauseMedia
RewindMedia
StopMedia
MouseGestureTrigger
MouseEventTrigger
StateChangedTrigger
CallDataMethod
InvokeDataCommand
DataEventTrigger
SetDataProperty
DataStateBehavior
DataStateSwitchBehavior
FluidBindProperty
PropertyChangedTrigger
CallMethod
ClippingBehavior
GoToNextState
GoToPreviousState
SetProperty
ShowMessageBox
ListBoxAddOne
ListBoxRemoveOne
ListBoxRemoveThisItem

Wow, that's impressive. The code is only in Alpha, but the installer does add it to the Blend directory. Go get them now....run don't walk:

http://expressionblend.codeplex.com/

One Week Left Before Seattle's Silverlight Tour Stop

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 24 Aug 2009 12:48:51 GMT

URL: https://agilitrain.com/Workshop/Info/Silverligh...

Are you ready...for Silverlight 3? If not, now's your time to ramp up in three days. The Silverlight Tour is coming back to Seattle next week. It arrives on September 2nd in Bellevue and there are still seats available.

The new Silverlight 3 features covered include:

Out of the Browser Support
Pixel Shaders
Hardware Graphic Accelleration
Behaviors
Navigation Framework
Blend 3
Binding Improvements
Secure Web Services
Binary XML Transport
RIA Services Client Controls
Text Rendering Improvements
Render Caching
And more...

To sign up for the class or hold a seat, visit the registration site:

http://silverlight-tour.com

The Application Class and Application Services in Silverlight 3

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 24 Aug 2009 12:00:22 GMT

URL: http://wildermuth.com/downloads/FunWithAppServi...

While digging into Silverlight 3, I noticed an oft overlooked new feature: Application Services. The problem revolves around the Application class so let's talk about that class first, then i'll get ot the services.

In Visual Studio (or Blend), the Application class represents a pretty important piece of the runtime environment. In fact (much to a surprise to some Silverlight Dev's), the Main Page XAML file is not the first thing loaded. Typically the first thing loaded is the Application class (the class behind the app.xaml file). How does it know to load this class? The AppManifest.xaml file. Ok, let's dive a little deeper.

When you build a Silverlight application, it creates a .xap file with your assembly and other resources (other assemblies, images, fonts, etc.) that are needed by your application. In addition, it creates a final AppManifest.xaml file for the .xap file. Here's a sample:

<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
           EntryPointAssembly="FunWithAppServices"
            EntryPointType="FunWithAppServices.App"
            RuntimeVersion="3.0.40624.0">
  <Deployment.Parts>
    <AssemblyPart x:Name="FunWithAppServices"
                  Source="FunWithAppServices.dll" />
    <AssemblyPart x:Name="MyAppService"
                  Source="MyAppService.dll" />
  </Deployment.Parts>
</Deployment>

This AppManifest.xaml file is created during the build (which is why it looks different from the one in your project). Not that there are two attributes that describe the EntryPoint to the .xap file. This tells the runtime which assembly to load and what type to create to start the application.

When the application class (called App in the default templates) is loaded, it starts the whole process for creating an instance of the MainPage as shown below:

public partial class App : Application
{

  public App()
  {
    this.Startup += this.Application_Startup;
    this.Exit += this.Application_Exit;
    this.UnhandledException += this.Application_UnhandledException;

    InitializeComponent();
  }

  private void Application_Startup(object sender, StartupEventArgs e)
  {
    this.RootVisual = new MainPage();
  }

...
}

So why does any of this matter? Because the Application lives for the life of the application. Therefore many developers find it a common place to hang other functionality. In fact, some frameworks help by getting you to derive your App class from another class to provide even more functionality. Of course, as soon as you need/want two of these sets of functionality, you're stuck because you can't multi-derive in .NET.

The problem with this is as different services to the application are necessary, the App class gets busy and hard to maintain. This is especially hard to loosely couple these services with the application. The main reason many developers put these services on the App class is to ensure that those services are available through the lifetime of the application. In Silverlight 3, Microsoft has come up with another option: Application Services.

The idea of Application Services is pretty simple: any set of functionality that needs to have the same lifetime as the Application. An Application Service is a class that supports the IApplicationService interface (and optionally IApplicationLifetimeAware). IApplicationService is simple:

public interface IApplicationService
{
  void StartService(ApplicationServiceContext context);
  void StopService();
}

The interface supports starting and stopping of the service (as well as sharing application startup initParams). I might have a Logger service that I want to use in my Silverlight app. If I implement the interface, I can then set up this service in the App.xaml file to start up with the applicaton using the Application.ApplicationLifetimeObjects element:

<Application xmlns="..."
             xmlns:x="..." 
             x:Class="..."
             xmlns:s="clr-namespace:MyAppService;assembly=MyAppService"
             >
  <Application.ApplicationLifetimeObjects>
    <s:Logger />
  </Application.ApplicationLifetimeObjects>
  ...
</Application>

The problem with this facility is that while the ApplicaitonLifetimeObjects is handling the lifetime for you, there is not a simple way to get the object. That's why Microsoft advises to create a static Current property like so:

public class Logger : IApplicationService, IApplicationLifetimeAware
{
  static Logger _current = null;

  public static Logger Current
  {
    get { return _current; }
  }

  void IApplicationService.StartService(
    ApplicationServiceContext context)
  {
    _current = this;  
  }

  void IApplicationService.StopService()
  {
    _current = null;
  }
...
}

In addition to the IApplicationService, another useful interface here is the IApplicationLifetimeAware interface. This interface gives you a bit more control in the starting and stopping of the service. Here's the interface:

public interface IApplicationLifetimeAware
{
  void Starting();
  void Started();
  void Exiting();
  void Exited();
}

This interface simply allows you to handle the before and after states of Starting and Exiting the service. This is useful when you need that extra level of granularity.

the Application Service model allows for better separation between lifetime management and services that you want to supply to your Silverlight application. Start using it and please pleave the App alone...please ;)

Here's a link to my simple (and somewhat contrived) example:

http://wildermuth.com/downloads/FunWithAppServices.zip

Augusta in August!

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 24 Aug 2009 10:28:16 GMT

URL: http://augustadevelopers.org/Events/August2009/...

If you are in or around the Augusta area this Thursday, I will be doing my "Introduction to Silverlight" talk. Certain to start a conversation, this talk presents the basics of the platform and some examples of best uses for Silverlight. The event information is:

Augusta Developers Guild

When: Thursday, August 27, 2009 @ 6PM
Where: Augusta State University, University Hall, Room 170 ( Directions )

Hope to see you there!

PHP toolkit for ADO.NET Data Services...And My XBox Demo

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 21 Aug 2009 15:01:06 GMT

URL: http://blogs.msdn.com/pablo/archive/2009/08/21/...

I am happy to see that the Data Programming group at Microsoft have been hard at work as usual. They've just released their PHP toolkit for ADO.NET Data Services.

While I had no part in this effort, I was estastic to see they ported my XBox Games example to PHP for the demo of the toolkit. If you're using PHP and don't know much about ADO.NET Data Services, go grab the toolkit and take a look.