Patrick Cauldwell's Blog

New classes in the lineup

Patrick Cauldwell — Wed, 17 Jun 2009 17:19:27 GMT

We’ve added some new classes to the SoftSource training calendar, including a one-day Blend 2 class, and SQL 2008 for Developers. Other offerings coming up are “Agile in a Day”, WPF, WCF, ASP.NET 3.5, LINQ, Silverlight, and of course, C#. Discounts available for multiple students from the same organization, and custom on-site training also.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Default button semantics in Silverlight revisited

Patrick Cauldwell — Thu, 11 Jun 2009 19:03:22 GMT

A month or so ago I posted on a solution for simulating “default button” semantics in a Silverlight app, meaning that if you are entering text in a text box and you hit the enter key, the “default button” for the “page” should be pressed. Very natural for form entry, etc.

An issue came up (discovered by John Papa) with the solution in a Prism app, because my solution depends on being able to find the “default” button in the visual tree using the FindName method. That means that you have to be high enough up the visual tree to find the button, since it only works “down” the tree. In a Prism app, it’s not necessarily clear where “high enough” might be. Plus, because the solution requires unique names, and Prism modules may have nothing to do with one another, they may have duplicate names, etc.

Here’s a revision to the solution that doesn’t require unique names, and doesn’t require any static references that might interfere with proper garbage collection…

First, a new object called DefaultButtonHub that keeps track of the relationship between text boxes and buttons. It also exposes an Attached Property that takes a DefaultButtonHub reference so we can hook up text boxes and buttons to the “hub” in XAML.

public class DefaultButtonHub
{
   ButtonAutomationPeer peer = null;

   private void Attach(DependencyObject source)
   {
       if (source is Button)
       {
           peer = new ButtonAutomationPeer(source as Button);
       }
       else if (source is TextBox)
       {
           TextBox tb = source as TextBox;
           tb.KeyUp += OnKeyUp;
       }
       else if (source is PasswordBox)
       {
           PasswordBox pb = source as PasswordBox;
           pb.KeyUp += OnKeyUp;
       }
   }

   private void OnKeyUp(object sender, KeyEventArgs arg)
   {
       if(arg.Key == Key.Enter)
           if (peer != null)
               ((IInvokeProvider)peer).Invoke();
   }

   public static DefaultButtonHub GetDefaultHub(DependencyObject obj)
   {
       return (DefaultButtonHub)obj.GetValue(DefaultHubProperty);
   }

   public static void SetDefaultHub(DependencyObject obj, DefaultButtonHub value)
   {
       obj.SetValue(DefaultHubProperty, value);
   }

   // Using a DependencyProperty as the backing store for DefaultHub.  This enables animation, styling, binding, etc...
   public static readonly DependencyProperty DefaultHubProperty =
       DependencyProperty.RegisterAttached("DefaultHub", typeof(DefaultButtonHub), typeof(DefaultButtonHub), new PropertyMetadata(OnHubAttach));

   private static void OnHubAttach(DependencyObject source, DependencyPropertyChangedEventArgs prop)
   {
       DefaultButtonHub hub = prop.NewValue as DefaultButtonHub;
       hub.Attach(source);
   }

}

Basically we’re expecting that both the text boxes and the button will register themselves with the “hub”. If it’s a button that’s being registered, we wrap it in a ButtonAutomationPeer so we can “press” it later. If it’s a text box, we hook up a KeyUp handler that will “press” the button if it’s there. The requirement in the XAML is only marginally heavier than in my previous solution…we have to add a resource of type DefaultButtonHub, and point the button and text boxes at it using the {StaticResource} markup extension.

<UserControl x:Class="DefaultButton.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:my="clr-namespace:DefaultButton"
    Width="400" Height="300">
    <UserControl.Resources>
        <my:DefaultButtonHub x:Key="defaultHub"/>
    </UserControl.Resources>
    <Grid x:Name="LayoutRoot" Background="White">
        <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition/>
        </Grid.RowDefinitions>
        <TextBox x:Name="theText" Grid.Row="0"
                 my:DefaultButtonHub.DefaultHub="{StaticResource defaultHub}"/>
        <Button x:Name="theButton" Grid.Row="1" Content="Default"
                Click="theButton_Click" my:DefaultButtonHub.DefaultHub="{StaticResource defaultHub}"/>
    </Grid>
</UserControl>

Note that the new DefaultHub attached property is applied to both the text box and the button, each pointing the the single resource. This way everything gets wired up property, there isn’t any problem with name resolution (aside from the usual resource name scoping) and everything will get cleaned up if the form needs to be GC’d.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

RIA Services: the client side

Patrick Cauldwell — Fri, 05 Jun 2009 21:47:59 GMT

Last time, I talked about how to build a Domain Service from scratch using whatever POCO you have lying around. Now it’s time to talk about how that works on the client side…

One of the coolest things about RIA Services is that you don’t even have to “Add Service Reference…” to get a reference to the Domain Service. If your Silverlight project is linked to the ASP.NET project correctly (see the RIA Services doc for how this works) the build steps will take care of generating the right code in your Silverlight project, and away you go. There are several ways of accessing the service client-side, from dead-easy to a bit more involved. We’ll start with dead easy.

The very easiest way to get things hooked up is to use the DomainDataSource control. It wraps your DomainDataContext (the client-side generated bit) with a data source you can bind directly against in XAML.

<ria:DomainDataSource x:Name="PeopleDataSource" LoadMethodName="LoadPersons" AutoLoad="True">
  <ria:DomainDataSource.DomainContext>
      <services:PeopleDomainContext/>
  </ria:DomainDataSource.DomainContext>
</ria:DomainDataSource>
<dataControls:DataForm x:Name="dfPeople" CanUserAddItems="True" CanUserDeleteItems="true"
                     ItemsSource="{Binding ElementName=PeopleDataSource, Path=Data}" 
                     ItemEditEnded="dfPeople_ItemEditEnded">
</dataControls:DataForm>

The LoadMethodName attribute on the DomainDataSource tells it what method on the DomainContext to call in order to correctly populate the data context. You can also pass parameters defined in XAML to the Load method if you only need to load a subset. The DataForm control is bound to the Data property of the DomainDataSource, and away you go. You get this

Because the Insert/Update/Delete methods are implemented on the server-side DomainService, the DataForm automagically enables the edit, add and delete buttons at the top. If I edit or add a record, the save button shows up…

Pressing either the Save or Cancel button fires the ItemEditEnded event, which we can grab to submit the changes back to the server

private void dfPeople_ItemEditEnded(object sender, DataFormItemEditEndedEventArgs e)
{
  if (e.EditAction == DataFormEditAction.Commit)
      PeopleDataSource.SubmitChanges();
}

this is the very simplest case. Calling SubmitChanges() here will send the edits/inserts up to the server right away. For the sake of bandwidth, etc. I might want to implement my own “Save” button that batches up a whole set of change to the server rather than committing each edit individually. You would still call PeopleDataSource.SubmitChanges, but not in response to the DataForm’s events.

One of the great things about the way this works on the client side is that way the data validation attributes we set on the server-side POCO objects get propagated to the client. For example, the server side LastName property looks like this (at least in the metadata class…)

[Required]
[RegularExpression("[a-zA-z]*")]
public string LastName;

The property that gets generated on the client side is

[DataMember()]
[RegularExpression("[a-zA-z]*")]
[Required()]
public string LastName
{
  get
  {
      return this._lastName;
  }
  set
  {
      if ((this._lastName != value))
      {
          this.ValidateProperty("LastName", value);
          this.RaiseDataMemberChanging("LastName");
          this._lastName = value;
          this.RaiseDataMemberChanged("LastName");
      }
  }
}

It maintains the [Required] and [RegularExpression] attributes. Plus, in the property setter, it calls ValidateProperty, which uses reflection to examine those attributes and throw validation exceptions if necessary. By default, then, I get UI on the Silverlight client for validation.

The DataForm provides the UI around both the field in question and the summary at the bottom. In this case, I probably don’t want to tell the user what RegEx I’m validating against, so I need to add the ErrorMessage property to the validation attribute

[Required]
[RegularExpression("[a-zA-z]*", ErrorMessage="Alpha characters only please!")]
public string LastName;

When that error is corrected and I press the Save button, the Custom Validation routine is applied (see last post for details)

When all the errors are corrected, and the save happens (and gets committed back to the server) the DataForm is updated to show the correct ID value (from the server) as well as the calculated Age property.

For next to no work, I get a pretty good user experience for browsing, editing, inserting and deleting records. If I wanted a bit more control, I could load the data into the DataContext myself, and then setup the databinding, rather than using the DomainDataSource in XAML

private PeopleDomainContext _context = new PeopleDomainContext();

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
  if (_context.Persons.Count == 0)
  {
      _context.Loaded += (s, arg) => loadPeople();
      _context.LoadPersons();
  }
  else
      loadPeople();
}

private void loadPeople()
{
  dfPeople.ItemsSource = _context.Persons;
}

This would give me an opportunity to only load some people based on parameters, or whatever else I wanted to do to affect the loading of data before the data binding happens.

Next time… more cool things you can do with the DomainDataContext

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

.NET RIA Services from Scratch

Patrick Cauldwell — Tue, 02 Jun 2009 22:53:18 GMT

Most of the demos/samples I’ve looked at so far for RIA Services have started with a LINQ to SQL or ADO.NET Entity model and generated Domain Service classes from those. I decided to start from something super simple (a POCO, if you will) and work up from there. I started with a canonical “Person” class

public partial class Person : INotifyPropertyChanged
{
   #region INotifyPropertyChanged Members

   public event PropertyChangedEventHandler PropertyChanged;

   #endregion

   protected virtual void Changed(string propertyName)
   {
       PropertyChangedEventHandler handler = PropertyChanged;
       if (handler != null)
       {
           handler(this, new PropertyChangedEventArgs(propertyName));
       }
   }

   private int _personId;
   public int PersonId
   {
       get
       {
           return _personId;
       }
       set
       {
           if (_personId != value)
           {
               _personId = value;
               Changed("PersonId");
           }
       }
   }

   private string _firstName;
   public string FirstName
   {
...
   }
   private string _lastName;
   public string LastName
   {
...
   }
   private System.DateTime _birthDate;
   public System.DateTime BirthDate
   {
...
   }
}

Nothing to see here. It’s just a simple POCO that supports INotifyPropertyChanged for databinding. Note that it’s a partial class… The simplest path would be to add RIA Services attributes directly to these properties for things like data validation, but I wanted to try out all the features, so I split out the metadata into another file

[MetadataTypeAttribute(typeof(RiaServices.Web.Person.PersonMetadata))]
public partial class Person
{

   internal sealed class PersonMetadata
   {
       [Key]
       [Required]
       public int PersonId;

       [Required]
       [RegularExpression("[a-zA-z]*")]
       public string FirstName;

       [Required]
       [RegularExpression("[a-zA-z]*")]
       public string LastName;

       [Required]
       public DateTime BirthDate;
   }
}

This is kind of an interesting trick, and allows me to separate out all the RIA specific metadata from the original class definition. This makes total sense when you look at the way they handle LINQ to SQL, for example. In that case you already have Entity classes defined by the LINQ to SQL wizard, so this extra metadata class allows you to associate the right attributes without touching the (generated) LINQ to SQL classes. Clever. Notice that the metadata class uses fields, not properties, and just matches the names for the sake of simplicity.

In this case, the additional metadata defines data validation rules that get enforced both server and client side. There are other attributes to enforcing string length and ranges.

This all works because RIA Services generates “proxy” entity classes on the client side that are Silverlight compilable and also DataContracts (for serializing, which is cool…). However, what happens if I have a calculated property that’s not just storage? There’s a solution for that too, and it involves another piece of the partial class

public partial class Person
{
   [Shared]
   public int Age
   {
       get
       {
           this.Changed("Age");
           return Convert.ToInt32(Math.Floor((DateTime.Now - _birthDate).Days / 365.25));
       }
   }

}

This bit goes in a file called Person.shared.cs, and it will be copied to the client project and compiled there as well as on the server. The [Shared] attribute marks the bits that need to be thus propagated. Again, clever. Of course, any such shared code has to compile in Silverlight.

The other piece of code I want to share (using the same method) is a custom validator. In addition to the [Required] or [RegularExpression] attributes used above, you can register a custom validation routine that can examine the state of the entity as a whole. The validation routine looks like this

[Shared]
public class PersonValidator
{
   public static bool IsPersonValid(Person p, ValidationContext context, out ValidationResult result)
   {
       bool valid = true;

       result = null;

       if (p.Age > 130)
           valid = false;

       if (!valid)
       {
           result = new ValidationResult("Birthdate is invalid, people can't be that old", new []{"BirthDate"});
       }

       return valid;

   }
}

That’s in a file called PersonValidator.shared.cs, so that it will be available client and server-side. It’s associated with the Person entity with an additional attribute

[CustomValidation(typeof(PersonValidator), "IsPersonValid")]
[MetadataTypeAttribute(typeof(RiaServices.Web.Person.PersonMetadata))]
public partial class Person
...

With the Person entity all ready, I can expose it to the client by creating a new DomainService class with methods for Get, Insert, Update, Delete, etc.

[EnableClientAccess()]
public class PeopleDomainService : DomainService
{
   public IQueryable<Person> GetPersons()
   {

       return PeopleData.Persons.AsQueryable<Person>();
   }

   public IQueryable<Person> GetPerson(int personId)
   {
       return (from p in PeopleData.Persons
               where p.PersonId == personId
               select p).AsQueryable<Person>();
   }

   public void UpdatePerson(Person person)
   {
       Person oldP = (from p in PeopleData.Persons
                      where p.PersonId == person.PersonId
                      select p).FirstOrDefault();

       if (oldP != null)
       {
           PeopleData.Persons.Remove(oldP);
           PeopleData.Persons.Add(person);
       }
   }

   public void InsertPerson(Person person)
   {
       if (person.PersonId == 0)
       {
           int max = PeopleData.Persons.Max(p => p.PersonId);
           person.PersonId = max + 1;
       }

       PeopleData.Persons.Add(person);
   }

   public void DeletePerson(Person person)
   {
       Person oldP = (from p in PeopleData.Persons
                      where p.PersonId == person.PersonId
                      select p).FirstOrDefault();

       if (oldP != null)
       {
           PeopleData.Persons.Remove(oldP);
       }
   }
}

PersonData.People in this case is a List<Person> that’s populated with some sample data. The [EnableClientAccess] attribute causes the build-time bits to generate a client side proxy for calling the service without the client project needing a service reference. It really makes the Silverlight and the Web projects feel like parts of the same app rather than disconnected pieces.

The corresponding class that is generated on the client side is a DomainDataContext, which feels much like a LINQ to SQL DataContext only it’s lazy-loaded like the Astoria ones. The GetPersons method on the server results in LoadPersons on the client, etc. If I hadn’t implemented the Insert/Update/Delete methods on the server side, the DomainDataContext would simple behave like a read only data source. This model works really well with the DataForm class. If I set the ItemsSource of the DataForm to the Persons “table” in the client side data context, it will properly enable/disable the add/delete buttons depending on the capabilities of the data context. Neat.

Coming in future posts… hooking up the PersonDataContext to the Silverlight 3 UI, and in ASP.NET

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Silverlight: Taking it on the road

Patrick Cauldwell — Thu, 28 May 2009 23:38:16 GMT

Shaun and I will be doing a one-day training, “Practical Silverlight 3”, in lovely San Francisco, CA on July 8th. It’s a full day of Silverlighty goodness, starting with the basics and movin’ on up. We like to think of it as a 300 level technical introduction to the subject, so you will come away with a better understanding of the fundamentals, and where to look next.

Topics include

An introduction to Silverlight 3
All about controls (styling, templating, building your own)
Integrating with the browser
Communicating with the server via WCF, REST/POX, Sockets, you name it

If you are or will be in NorCal, come check it out. It’s a good introduction for a very reasonable price.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Debugging session at PDX Code Camp

Patrick Cauldwell — Tue, 26 May 2009 20:51:11 GMT

SoftSource developer Prashant Sinha is going to be presenting on “Production Debugging for Silverlight and ASP.NET” at Code Camp. Prashant is a debugging wiz, and teaches our two-day .NET debugging course, so this should be a very useful session.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Code Contracts

Patrick Cauldwell — Thu, 21 May 2009 21:50:38 GMT

In my book, I talked a bit about programming by contract and how that makes everyone’s lives easier. Say I have a method that divides one integer by another

public double Divide(int dividend, int divisor)
{
  return dividend / divisor;
}

I’d like to be able to let callers know that they can’t pass a 0 for the divisor, because that will result in a DivideByZeroException, and nobody wants that. In the past I had a couple of choices on how to express that, mostly involving writing different kids of code, because C# doesn’t have a native expression of design by contract like Eiffel does. One way is to use Debug.Assert

public double Divide(int dividend, int divisor)
{
  Debug.Assert(divisor != 0);

  return dividend / divisor;
}

That way any caller that passes a 0 will get an assertion dialog at runtime, which brings it pretty dramatically to everyone’s attention. The assumption is that using the Debug.Assert will flush out all cases where people are incorrectly calling my method during development, so it’s OK that the assertion will get compiled out of my Release build. However, that doesn’t make it impossible for a caller to pass a 0 at runtime and cause the exception. Another option is explicitly checking parameters and throwing a different exception.

public double Divide(int dividend, int divisor)
{
  if (divisor == 0)
      throw new ArgumentException("divisor cannot be zero", "divisor");

  return dividend / divisor;
}

Patrick argues that this has now moved from defining contract to defining behavior, and I can agree with that, although I’d probably argue that it defines both contract and behavior since I’ve extended the functionality of the Debug.Assert to the release build, while also protecting my internal state from bad data. But that’s really a separate discussion… :)

Now thanks to the Microsoft Code Contracts project, I have a third option. The Code Contracts project is the evolution of the work done on Spec#, but in a language neutral way. The Code Contracts tools are currently available from DevLabs for VS 2008, as well as shipping with VS 2010 B 1. Just at the moment, there are more features in the DevLabs version that what made it into the 2010 beta. With Code Contracts, I can rewrite my Divide method like this

public double Divide(int dividend, int divisor)
{
  Contract.Requires(divisor != 0);

  return dividend / divisor;
}

I like the syntax, as it calls out quite explicitly that I’m talking about contract, and making an explicit requirement. The default behavior of this method at runtime is identical to Debug.Assert, it brings up an assertion dialog and brings everything to a screeching halt. However, it’s configurable at build time, so I can have it throw exceptions instead, or do whatever might be appropriate for my environment if the contract is violated. I can even get the best of both worlds, with a generic version of Requires that specifies an exception

public double Divide(int dividend, int divisor)
{
  Contract.Requires<ArgumentException>(divisor != 0, "divisor");

  return dividend / divisor;
}

I could configure this to bring up the assertion dialog in Debug builds, but throw ArgumentNullException in Release builds. Good stuff.

The example above demonstrates a required “precondition”. With Code Contracts, I can also specify “postconditions”.

public void Transfer(Account from, Account to, decimal amount)
{
  Contract.Requires(from != null);
  Contract.Requires(to != null);
  Contract.Requires(amount > 0);
  Contract.Ensures(from.Balance >= 0);

  if (from.Balance < 0 || from.Balance < amount)
      throw new InsufficientFundsException();

  from.Balance -= amount;
  to.Balance += amount;

}

This isn’t the greatest example, but basically the Transfer method is promising (with the Contract.Ensures method) that it won’t ever leave the Balance a negative number. Again, this is arguably behavior rather than contract, but you get the point.

A really nifty feature is that I can write an interface definition and associate it with a set of contract calls, so that anyone who implements the interface will automatically “inherit” the contract validation. The syntax is a bit weird, but you can see why it would need to be like this…

[ContractClass(typeof(ContractForCalucluator))]
interface ICalculator
{
   int Add(int op1, int op2);
   double Divide(int dividend, int divisor);
}

[ContractClassFor(typeof(ICalculator))]
class ContractForCalucluator : ICalculator
{
   #region ICalculator Members

   public int Add(int op1, int op2)
   {
       return default(int);
   }

   public double Divide(int dividend, int divisor)
   {
       Contract.Requires(divisor != 0);

       return default(double);
   }

   #endregion
}

Now any class that implements ICalculator will have the contract validated for the Divide method. Cool. The last thing I want to point out is that the team included a handy sample of how to work with contract validation in your MSTest unit test code. The Contract class exposes an event called ContractFailed, and I can subscribe to the event to decide what happens on a failure. For a test assembly, I can do this

[AssemblyInitialize]
public static void AssemblyInitialize(TestContext tc)
{
  Contract.ContractFailed += (sender, e) =>
  {
      e.SetHandled();
      e.SetUnwind();
      Assert.Fail(e.FailureKind.ToString() + " : " + e.Message);
  };
}

which will translate contract failures into test failures with very explicit error messages. In the case of my Divide method if I run this test

[TestMethod()]
public void DivideContractViolation()
{
  Calculator target = new Calculator(); 
  int dividend = 12; 
  int divisor = 0; 
  double actual;
  actual = target.Divide(dividend, divisor);
  Assert.Fail("Should have failed");
}

I get a test failure of

Test method CalculatorTests.CalculatorTest.DivideContractViolation threw exception: System.Diagnostics.Contracts.ContractException: Precondition failed: divisor != 0 divisor ---> Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.Fail failed. Precondition : Precondition failed: divisor != 0 divisor.

Cool. This is definitely something I’ll be looking at more in the future.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

PDX Code Camp is coming up…

Patrick Cauldwell — Wed, 20 May 2009 20:45:43 GMT

Not this weekend but next (5/30) is PDX Code Camp 2009. A whole day of free software learning and general nerdy hanging out. I’ll be talking about building business apps in Silverlight 3, and my SoftSource compadre Tim Johnson is going to be talking about making your web application more accessible for people with disabilities. There are also a host of other sessions including some big names like Ward Cunningham, so it’s an event not to be missed, and cheap at twice the price!

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

LINQ: joining data in memory with data in SQL Server

Patrick Cauldwell — Wed, 20 May 2009 20:38:43 GMT

This came up in class yesterday, so I did a little digging. Everyone may already know this, but it came as news to me. :)

If I’ve got a collection in memory, as well as a LINQ to SQL DataContext

List<FavoriteFood> foods = new List<FavoriteFood>(){
	new FavoriteFood{CustomerID = "ALFKI", Favorite="Chips"},
	new FavoriteFood{CustomerID = "ANATR", Favorite = "Fish"}};

NorthwindDataContext context = new NorthwindDataContext();

and I want to do an INNER JOIN between the foods list and the Customer table in Northwind, it would seem like this should do it

var bad = (from cust in context.Customers
         join f in foods on cust.CustomerID equals f.CustomerID
         select new
         {
             cust.ContactName,
             f.Favorite
         }).ToList();

but sadly, no.

if you stop to think about it, it totally makes sense that it wouldn’t work like that, since there’s no way to translate that into SQL in any rational way to send to SQL server.

OK, so the next step would be to first get the customers in memory, then do the join

//this executes the whole query, thus retrieving the entire customer table
var customers = (from c in context.Customers
             select c).ToList();

//an inner join between the customers from SQL and the in-memory list
var inner = from cust in customers
     join f in foods on cust.CustomerID equals f.CustomerID
     select new
     {
         cust.ContactName,
         f.Favorite
     };

That works, but I’ve had to pull the entire Customer table into memory just to join two rows. If I wanted to do a LEFT OUTER JOIN, I’d need that anyway, like so

//here's the left outer join between the customer list from SQL 
//and the in-memory favorites
var leftouter = from cust in customers
             join f in foods on cust.CustomerID equals f.CustomerID into custFoods
             from custFood in custFoods.DefaultIfEmpty()
             select new
             {
                 cust.ContactName,
                 Favorite = custFood == null ? null : custFood.Favorite
             };

but I want an inner join without pulling down all the customers, so I need to only fetch those rows that will join from Customer

//this is how you manage the IN clause
var x = from c1 in context.Customers
     where (from cf in foods
           select cf.CustomerID).Contains(c1.CustomerID)
     select c1;

//Note that to join the result in x back to the foods collection you would have to 
//execute the query just like with customers above...
var littleInnerJoin = from filteredCustomer in x.ToList()
                   join f in foods on filteredCustomer.CustomerID equals f.CustomerID
                   select new
                       {
                           filteredCustomer.ContactName,
                           f.Favorite
                       };

It’s two steps, but now I’ve just loaded the rows that will join into memory, and then done the join with LINQ to Objects. It bears a little thinking about, but doesn’t seem like too much overhead, IMHO.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

A “default button” in Silverlight

Patrick Cauldwell — Thu, 07 May 2009 20:27:54 GMT

Let’s say I’ve got to the effort of creating a modal dialog or it’s equivalent in a Silverlight application. What I would like to complete the picture is a “default” button, so that if I hit the Enter key while in a text box, the dialog will be “submitted”. There are probably several ways of achieving this end, but I wanted something that was simple, and encapsulated in an attached property so the consumer wouldn’t have to deal with much code. I wrote the attached property so that I could use it on text boxes like this

<TextBox x:Name="theText" VerticalAlignment="Center" Margin="10,0,10,0" 
	Grid.Row="0" my:DefaultButtonService.DefaultButton="theButton"/>

where “theButton” here is the default button I want to be pressed when the Enter key happens inside my text box. The downside is that I have to apply this property to every text box on the page, but so be it, that seems like a relatively small price to pay. So I got as far as finding the named button in the visual tree, but the the question was, how to “press” the button. The Button class in Silverlight has a protected OnClick that would do the trick, if it wasn’t protected. I could derive my own control from Button and expose the OnClick method, but ewww. If I did that then every dialog that wanted this behavior would have to remember to use the derived Button class. I tried reflecting over the Button and Invoking OnClick anyway, but turns out you get a security exception. OK. Then, thanks to a presentation Stuart gave us yesterday on Accessibility, I remembered the Automation framework in Silverlight. That turned out to be super easy, just create an instance of ButtonAutmationPeer from the Button, then Invoke it. Cool.

public static class DefaultButtonService
{
   public static readonly DependencyProperty DefaultButtonProperty =
       DependencyProperty.RegisterAttached("DefaultButton", typeof(string), typeof(DefaultButtonService), new PropertyMetadata(OnDefaultButtonChanged));


   public static string GetDefaultButton(DependencyObject d)
   {
       return (string)d.GetValue(DefaultButtonProperty);
   }

   /// <summary>
   /// Sets the CommandParameter property.
   /// </summary>
   public static void SetDefaultButton(DependencyObject d, string value)
   {
       d.SetValue(DefaultButtonProperty, value);
   }

   private static void OnDefaultButtonChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
   {
       TextBox tb = d as TextBox;
       if (tb != null)
       {
           tb.KeyUp += new KeyEventHandler(tb_KeyUp);
       }
   }

   static void tb_KeyUp(object sender, KeyEventArgs e)
   {
       switch (e.Key)
       {
           case Key.Enter:
               string name = (string)((DependencyObject)sender).GetValue(DefaultButtonProperty);
               object root = App.Current.RootVisual;
               object button = ((FrameworkElement)root).FindName(name);
               if (button is Button)
               {
                   ButtonAutomationPeer peer = new ButtonAutomationPeer((Button)button);

                   IInvokeProvider ip = (IInvokeProvider)peer;
                   ip.Invoke();
               }
               break;
       }
   }
}

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

New one-day classes at SoftSource

Patrick Cauldwell — Tue, 07 Apr 2009 17:41:19 GMT

We just added a set of new one day classes starting in May, including “Agile in day”, Silverlight 3, and UI design patterns for WPF and Silverlight. These are lecture-style classes that will give you an in depth look at each subject. Like our previous Silverlight event, these are 300-400 level, technical sessions that will give you a leg up on each subject in a day. Because they are presented lecture style, we can offer them for only $125 each, so feel free to collect the whole set. :-) Details and registration here. We may be adding some additional topics soon, so check back often.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

MIX 09 - Thursday

Patrick Cauldwell — Thu, 19 Mar 2009 20:45:58 GMT

I'll probably have some more cogent things to say about it all in a few days, but my first set of takeaways as of mid-day Thursday:

Silverlight 3 solves many if not most of the downsides of working in Silverlight vs. WPF
Silverlight 3 + .NET RIA services totally removes any and all barriers to building business apps in Silverlight
.NET RIA services is the killer app we’ve been waiting for as far as building RIA apps is concerned. it’s like Astoria, only better, and doesn’t require Entities (long live LINQ to SQL!).
Blend 3 will revolutionize the way designers and developers work together, and make the design process much faster
Free martinis are both a blessing and a curse
Having a DJ at your keynotes is a fantastic idea
Not only would downtown Hillsboro (where I live) fit inside the Venetian, but you probably wouldn’t actually notice it.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

MVVM and a modal dialog

Patrick Cauldwell — Tue, 10 Mar 2009 23:36:01 GMT

I’m building a MVVM app in WPF, and needed to show a modal dialog, but I couldn’t figure out how to make it work and still maintain the separation between ViewModels and Views. I have been mapping Views to ViewModels using DataTemplates, so that the relationship is declarative in XAML rather than in code someplace. What I ended up with was a new Window called Dialog that takes a type in its constructor that corresponds to a ViewModelBase-derived type. (See Josh Smith’s WPF Apps With The Model-View-ViewModel Design Pattern article for background on how the pieces fit together…)

public partial class Dialog : Window
{
    public Dialog(Type vmType)
    {
        InitializeComponent();

        ViewModelBase vmb = Activator.CreateInstance(vmType) as ViewModelBase;
        
        item.Content = vmb;

        this.Title = vmb.DisplayName;
    }
}

In the XAML for Dialog, there’s just a Grid that contains a ContentPresenter called “item”. The constructor sets item’s content to be the ViewModel, and the DataTemplate takes care of associating the View (a UserControl) with the ViewModel. Note the use of SizeToContent="WidthAndHeight" on the Dialog window, which causes the window to resize to how ever big the UserControl that represents the View might be.

<Window x:Class="SomeNamespace.Dialog"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Dialog" SizeToContent="WidthAndHeight">
    <Grid>
        <ContentPresenter x:Name="item">
            
        </ContentPresenter>
    </Grid>
</Window>

<DataTemplate DataType="{x:Type vm:NewThingViewModel}">
    <vw:NewThing/>
</DataTemplate>

To create an instance of the new modal dialog, I just create a new instance of Dialog and pass the type of ViewModel it’s supposed to host…

new Dialog(typeof(NewThingViewModel)).ShowDialog();

There are still some details to work out as far as getting results from said dialog, but hey, progress…

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

MVVM: binding to Commands in Silverlight

Patrick Cauldwell — Thu, 05 Mar 2009 00:06:59 GMT

So yesterday I was reading Josh Smith’s WPF Apps With The Model-View-ViewModel Design Pattern article in last month’s MSDN magazine, and I really liked the sample app that he built. It totally cleared up for me some rough edges (in my understanding) of MVVM. Most specifically, I had been conflicted about where to put things like button click handlers. Do you put a Click event handler in your codebehind, which just defers to the View Model? Do you create a generic CommandBinding handler to wire up commands to your View Model’s methods? (I’ve seen both in various examples…) The former seems like cheating a bit on MVVM (no code behind would be ideal, it seems to me) and the latter overly complicated. Josh’s solution is to bind the Command property of the UIElement (button, menu item, whatever) to a property of type ICommand on the View Model.

That totally made sense to me. No more code behind (like at all, basically) and I don’t have to build additional framework to make it happen, with the exception of coming up with an ICommand implementation. Josh solved that with a class he calls RelayCommand, which just wraps an ICommand implementation around a delegate (or lambda) of type Action<object>, with an optional Predicate<object> to handle the CanExecute method of ICommand.

Groovy, now my XAML knows absolutely nothing about the View Model, and it’s only links to said View Model are through data binding.

Then I got to wondering if something as easy could work in Silverlight… The answer turned out to be almost, but not quite. Since Silverlight controls don’t expose a Command property, you have to hook them up yourself, but otherwise it works just the same way.

So if I’ve got a page with a single button on it

<UserControl x:Class="SilverlightCommands.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:my="clr-namespace:SilverlightCommands"
    Width="400" Height="300">
    <Grid x:Name="LayoutRoot" Background="White">
        <Button Content="Say Hello..." VerticalAlignment="Center" 
                HorizontalAlignment="Center" 
                my:ButtonService.Command="{Binding Path=SayHello}"/>
    </Grid>
</UserControl>

I can add an attached property whose value is bound to the ICommand property on the View Model. The attached property grabs the ICommand and hooks up the button’s click handler to the ICommand’s Execute method.

#region Command

/// <summary>
/// Command Attached Dependency Property
/// </summary>
public static readonly DependencyProperty CommandProperty =
    DependencyProperty.RegisterAttached("Command", typeof(ICommand), typeof(ButtonService),
        new PropertyMetadata(OnCommandChanged));

/// <summary>
/// Gets the Command property.
/// </summary>
public static ICommand GetCommand(DependencyObject d)
{
    return (ICommand)d.GetValue(CommandProperty);
}

/// <summary>
/// Sets the Command property.
/// </summary>
public static void SetCommand(DependencyObject d, ICommand value)
{
    d.SetValue(CommandProperty, value);
}

/// <summary>
/// Handles changes to the Command property.
/// </summary>
private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    if (d is Button)
    {
        Button b = d as Button;
        ICommand c = e.NewValue as ICommand;
        b.Click += delegate(object sender, RoutedEventArgs arg) { c.Execute(null); };
    }
}

#endregion

In the View Model, then, is the actual handler for the command

public class PageViewModel
{
    public ICommand SayHello
    {
        get
        {
            return new RelayCommand(param => MessageBox.Show("HelloWorld"));
        }
    }
}

Note that I’m using Josh’s RelayCommand helper to wrap the simple lambda.

That feels like not too terribly much infrastructure, although I might have to create separate attached properties to handle different control types (e.g. those that don’t have a Click event). It would be pretty straightforward to support command parameters in the same way, by creating a CommandParameter attached property and picking up its value in the OnCommandChanged handler…

private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    if (d is Button)
    {
        string parameter = d.GetValue(CommandParameterProperty) as string;
        Button b = d as Button;
        ICommand c = e.NewValue as ICommand;
        b.Click += delegate(object sender, RoutedEventArgs arg) { c.Execute(parameter); };
    }
}

The only thing that doesn’t really handle well is the CanExecute method, which in WPF would automatically enable/disable the button based on the result of the ICommand’s CanExecute method. I tried a couple ways of wiring it up during the OnCommandChanged handler, but couldn’t come up with anything that didn’t look to have nasty side-effect (garbage collection, etc.) or be just ugly. I’d probably just bind the IsEnable property of the button to a separate boolean on the View Model and deal with it there.

Update:

Code is here.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Replacing JavaScript with Silverlight

Patrick Cauldwell — Mon, 02 Mar 2009 23:08:15 GMT

Shaun posted a nice concise example of replacing JavaScript code with similar compiled code in Silverlight. If you have any complex business logic currently written in JavaScript, this would be a great way of turning that into compiled, type-safe C#.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

MVVM and testing Silverlight

Patrick Cauldwell — Mon, 02 Mar 2009 22:42:25 GMT

After reading Justin Angel’s very good summary of unit testing Silverlight using the Silverlight UnitTest framework, RhinoMocks, Unity etc. I decided to give it a go and find out how easy it was for a “real” application. I converted the course evaluation app I’ve been working on since December to MVVM using Unity, and then set about trying to test it with the testing tools.

I must say I do rather like the MVVM pattern, so that part went pretty well, as did the use of Unity, although there was some learning to do there. It’s not quite as obvious as it maybe should be, but it didn’t take too long. The biggest issue I had with both Unity and the test tools come in relation to the WCF proxy that I’m using to talk back to the server from Silverlight. I think it would be a bit easier using the asynchronous interface that is generated as part of the proxy (the one that has all the BeginXXX, EndXXX methods on it) but I’m using the interface that consists of completion events and XXXAsync methods. That object (in my case it’s called “EvalServiceClient”) doesn’t like being created by Unity, presumably somewhere down in the WCF infrastructure, so I had to create it myself and register the instance with Unity.

Current = new UnityContainer();
Current.RegisterInstance(typeof(EvalServiceClient), new EvalServiceClient());

That isn’t too terrible, but it did take a while to figure out. One of the things that makes that harder is that the errors that come back just say “Unity couldn’t create your thing” and it takes a bit of digging to find out where and why it actually failed.

The blogosphere suggests (and I agree) that implementing MVVM in Silverlight isn’t quite as straightforward as it might be in WPF, largely due to the lack of commands. There are a couple of declarative solutions for mapping UI elements to methods in a View Model, but most relied on quite a bit of infrastructure. I decided it was OK (enough) to put just enough code in my code-behind to wire up event handlers to methods on the View Model. Icky? No too bad. Commands would obviously be better, but there it is.

private void submitEval_Click(object sender, RoutedEventArgs e)
{
    ViewModel.SubmitEval();
}

private void lstCourse_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    CourseInfo ci = lstCourse.SelectedItem as CourseInfo;
    ViewModel.CourseSelected(ci);
}

I found that the reliance on data binding makes it much easier to separate presentation from business logic. The View Model can represent any UI specific logic like which buttons should be enabled when (which the underlying business/domain model doesn’t care about) and allow a designer to work strictly with XAML. Because INotifyPropertyChanged really works, you don’t have to worry about pushing data into the interface, just on which properties have to be marked as changed. For a computed property like “should the submit button be shown” it may take a few extra notification calls to make sure the UI gets updated properly, but that seems reasonable.

public bool CanSubmit
{
    get
    {
        _canSubmit = (_registrationId.HasValue && _questionCategories != null);
        return _canSubmit;
    }
    set
    {
        if (_canSubmit != value)
        {
            _canSubmit = value;
            Changed("CanSubmit");
        }
    }
}

public int? RegistrationId
{
    get
    {
        return _registrationId;
    }
    set
    {
        if (_registrationId != value)
        {
            _registrationId = value;
            Changed("RegistrationId");
            Changed("CanSubmit");
        }
    }
}

public System.Collections.ObjectModel.ObservableCollection<Evaluation.EvaluationServer.QuestionCategory> QuestionCategories
{
    get
    {
        return _questionCategories;
    }
    set
    {
        if (_questionCategories != value)
        {
            _questionCategories = value;
            Changed("QuestionCategories");
            Changed("CanSubmit");
        }
    }
}

In the example above, the value of “CanSubit” relies on the state of RegistrationID and QuestionCategories, so the property setters for those properties also “invalidate” CanSubmit so the UI will update properly. In the XAML, the IsEnabled property of the Submit button is bound to the CanSubmit property of the View Model.

The next challenge was getting the test code to work. Because I didn’t want the test code to call the real web service, I had to mock the calls to the EvalServiceClient. For whatever reason, I didn’t have any luck with mocking the object itself. I think this had to do with the asynchronous nature of the calls. The code registers an event handler for each completion event, then calls XXXAsync to call the web service. When it returns, it fires the completion handler. To make that work with RhinoMocks, you have to record the event hookup, then capture an IEventRasier interface that will let you raise the desired event.

using (mocks.Record())
{
    client.GetStudentNameCompleted += null;
    raiser = LastCall.IgnoreArguments().GetEventRaiser();

That call to GetEventRaiser fails if I mock the EvalServiceClient object itself, so I had to create an interface that I could mock instead. Luckily, the generated proxy is a partial class, so it’s easy to add a new interface.

public interface IEvalServiceClient
{
    event System.EventHandler<GetStudentNameCompletedEventArgs> GetStudentNameCompleted;

    void GetStudentNameAsync();
}

public partial class EvalServiceClient : IEvalServiceClient
{

}

Now the RhinoMocks code mock the IEvalServiceClient interface, and the GetEventRaiser call works just fine. Because the WCF client actually gets created by Unity, we have to register the new mock instance with the UnityContainer.

MockRepository mocks = new MockRepository();
IEvalServiceClient client = mocks.StrictMock<IEvalServiceClient>();

IoC.Current.RegisterInstance<IEvalServiceClient>(client);
IEventRaiser raiser;

using (mocks.Record())
{
    client.GetStudentNameCompleted += null;
    raiser = LastCall.IgnoreArguments().GetEventRaiser();

    client.GetStudentNameAsync();

}

using (mocks.Playback())
{
    Page page = new Page();
    raiser.Raise(client, new GetStudentNameCompletedEventArgs(new object[]{"Jones, Fred"}, null, false, null));
    WaitFor(page, "Loaded");
    TestPanel.Children.Add(page);

    EnqueueCallback(() => Assert.IsTrue(page.lblStudent.Text == "Jones, Fred"));

    EnqueueTestComplete();
}

During playback, we can use the IEventRaiser to fire the completion event, then check the UI to make sure the property got set correctly.

I’m pretty convinced that MVVM is a good idea, but this method of testing seems awfully cumbersome to me, plus pretty invasive. I had to make quite a few changes to my app to make the testing work, including creating the interface for the EvalServiceClient, and marking any controls I needed to write tests against with x:FieldModifier=”public” in my XAML. It’s good to know how to make this work, but I’m not sure I’d use this method to test everything in my Silverlight app. Probably only the highest risk areas, or places that would be tedious for a tester to hit.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Validation UI revisitied: attached properties

Patrick Cauldwell — Fri, 20 Feb 2009 23:32:07 GMT

On Wednesday I posted about coming up with a way of decorating any UIElement with a red border in response to a validation error. The only drawback (that I could see just then) was that I had to add borders to all the elements that I might want to exhibit this behavior. Today Shaun suggested that I try it as an attached property instead, which might save that hassle. Indeed it does. Because of the way attached properties work in Silverlight, it’s possible to use them to attach behavior as well as data be hooking the value changed event. Here’s the same (basically) logic as an attached property

public class ValidationService
{
    public static readonly DependencyProperty ValidationBehaviorProperty =
        DependencyProperty.RegisterAttached("ValidationBehavior", typeof(bool), typeof(ValidationService),
                                    new PropertyMetadata(OnValidationBehaviorChanged));

    public static bool GetValidationBehavior(DependencyObject d)
    {
        return (bool)d.GetValue(ValidationBehaviorProperty);
    }

    public static void SetValidationBehavior(DependencyObject d, bool value)
    {
        d.SetValue(ValidationBehaviorProperty, value);
    }

    private static void OnValidationBehaviorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is FrameworkElement)
        {
            FrameworkElement fe = d as FrameworkElement;

            if ((bool)e.OldValue)
            {

            }
            if ((bool)e.NewValue)
            {
                fe.BindingValidationError += new EventHandler<ValidationErrorEventArgs>(fe_BindingValidationError);
            }
        }
    }

    static void fe_BindingValidationError(object sender, ValidationErrorEventArgs e)
    {
        FrameworkElement fe = e.OriginalSource as FrameworkElement;
        DependencyObject parent = fe.Parent;
        Border b = null;

        if (parent is Grid)
        {
            b = new Border() { BorderBrush = new SolidColorBrush(Colors.Red), BorderThickness = new Thickness(0) };

            Grid g = parent as Grid;
            g.Children.Add(b);
            int column = (int)fe.GetValue(Grid.ColumnProperty);
            b.SetValue(Grid.ColumnProperty, column);
            int row = (int)fe.GetValue(Grid.RowProperty);
            b.SetValue(Grid.RowProperty, row);
            g.Children.Remove((UIElement)fe);
            b.Margin = fe.Margin;
            fe.Margin = new Thickness(0);
            b.Child = (UIElement)fe;
        }
        else if (parent is Border)
        {
            b = parent as Border;
        }

        if (e.Action == ValidationErrorEventAction.Added)
        {
            if (b != null)
            {
                b.BorderThickness = new Thickness(1);
            }
            ToolTipService.SetToolTip(fe, new TextBlock() { Text = e.Error.Exception.Message });
        }
        if (e.Action == ValidationErrorEventAction.Removed)
        {
            if (b != null)
            {
                b.BorderThickness = new Thickness(0);
            }
            ToolTipService.SetToolTip(fe, null);
        }
    }
}

Note that when registering the attached property, we register a value changed handler (in this case OnValidationBehaviorChanged). This will get called the first time the property is set, which gives us an opportunity to mess with the element that the property is attached to. If the value of the property is being set to true, we hook up the BindingValidationError handler.

In the validation error handler, we have to find out if the element is currently surrounded by a Border, and add one if it isn’t. Note: in this example it will only work if the element is originally the child of a Grid. This could easily be modified to support the other Panel types.

Once the parent is a border, then the old logic from the previous example can be reused to set the border and tooltip on or off as appropriate.

Notice that we don’t mark the BindingValidationError event as Handled so that it will bubble. That allows us to write additional forms specific error handling higher up in the visual hierarchy. At the form level we might want to invalidate the submit button if validation failed, or something similar, while letting the logic in the attached property handle the UI effects.

In the XAML, this new attached property can be used to attached the desired visual effect to any FrameworkElement like so

<TextBox Width="Auto" x:Name="txtNewHours"  Text="{Binding Hours, Mode=TwoWay, Converter={StaticResource hoursConverter}, 
    NotifyOnValidationError=true, ValidatesOnExceptions=true}" 
    my:ValidationService.ValidationBehavior="true"
    Grid.Row="1" Grid.Column="1" Margin="5,5,5,5"/>

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

LINQ order by with dymanic “column” names

Patrick Cauldwell — Thu, 19 Feb 2009 21:38:59 GMT

Stuart posted a great solution he came up with for writing dynamic orderby queries in LINQ when you don’t know the “column” name that you want to sort by ahead of time.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

New hands on Continuous Integration course at SoftSource

Patrick Cauldwell — Thu, 19 Feb 2009 20:37:26 GMT

I’m going to be teaching two new one-day courses on setting up a Continuous Integration process, one using freely available tools, and one using Microsoft Team Foundation Server. For more details and to register, see our registration page.

Both classes will be held at the Westside campus of

Course Description:

This one day course will provide a hands on look at setting up a Continuous Integration process using freely available tools from beginning to end. Students will learn the theory and practice behind establishing a Continuous Integration process, including setting up a build script, running unit tests, setting up an automated build/test server, and capturing reporting information for the whole process.

Course Technology

This course uses Microsoft Windows XP, the Microsoft .NET 3.5 Framework, NAnt, NUnit, and CruiseControl.NET.

At the end of the course you will be able to:

Create a build script using NAnt or MSBuild
Create and run unit tests using NUnit
Set up and run an automated build using CruiseControl.NET
Capture reporting data from the automated CI process

Course Outline

Why CI is important
How CI fits into the Software Development process

What goes in a build script?
How does NAnt work?
How does MSBuild work?
Creating build scripts for NAnt or MSBuild
Running an automated build

Writing NUnit tests
Running tests as part of a build
Capturing test results

Installing and configuring CC.NET
Adding projects to a build server
Reporting with CC.NET
Running multiple builds on the same server

Prerequisites

This class is intended for experienced .NET 2.0 software developers.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Databinding validation in Silverlight, a UI perspective

Patrick Cauldwell — Wed, 18 Feb 2009 22:10:45 GMT

I was having a bit of trouble getting validation to work during data binding in SL, but that seems to be resolved now. I’ve got a little time tracking app, and want to be able to log new time entries…

I want the user to be able to enter hours only in 1/4 hour increments. The way that gets handled in Silverlight is different from WPF. To make it work in Silverlight the data binding source has the throw an exception if the new value is unacceptable. In this case, the source is a “LogEntry” class that has a property “Hours” that implements INotifyPropertyChanged to support full two-way data binding.

public class LogEntry : INotifyPropertyChanged
{

    private decimal hours;
    public decimal Hours 
    {
        get
        {
            return hours;
        }
        set
        {
            if ((value % .25M) != 0)
            {
                throw new Exception("please enter time in quarter-hour increments");
            }
            if (hours != value)
            {
                hours = value;

                NotifyPropertyChanged("Hours");
            }
        }
    }

    private void NotifyPropertyChanged(string p)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(p));
        }
    }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    #endregion
}

In the property setting for the Hours property, if the value isn’t evenly divisible by .25 an Exception gets thrown. In the XAML, the binding is set up to notify (as a binding error) when an exception gets thrown

<TextBox Width="Auto" x:Name="txtNewHours"  Text="{Binding Hours, 
    Mode=TwoWay, 
    Converter={StaticResource hoursConverter}, 
    NotifyOnValidationError=true, ValidatesOnExceptions=true}"/>

The grid that holds all the controls handles the BindingValidationError event, which is where all the fun stuff happens…

private void newEntryGrid_BindingValidationError(object sender, ValidationErrorEventArgs e)
{
    if (e.Action == ValidationErrorEventAction.Added)
    {
        //not valid
    }
    if (e.Action == ValidationErrorEventAction.Removed)
    {
        //now it's valid
    }
}

OK, so now I know when the value isn’t valid, but what to do about it. In WPF, the easiest thing to do would be to use a “decorator” to add a border around the UI element that failed validation, but in Silverlight we don’t get decorators. Instead, I wrapped each item that needed to support validation in a red border with a thickness of 0 in XAML.

<Border BorderBrush="Red" BorderThickness="0">
    <TextBox x:Name="txtNewHours" Text="{Binding ...}"/>
</Border>

That’s a little extra work that I’d rather not do, but there it is. It would be easy to wrap up this behavior in a custom control, but this was much quicker.

In the validation handler then, all we have to do is get the original source of the binding error and use the VisualTreeHelper to get it’s parent. If that parent happens to be a border, set the border’s thickness to 1 to make it visible. I’m also setting the tooltip for that offending control to be the message of the validation error. If the ValidationErrorEventAction == Removed, then get rid of the tooltip and set the border’s thickness back to 0.

private void newEntryGrid_BindingValidationError(object sender, ValidationErrorEventArgs e)
{
    if (e.Action == ValidationErrorEventAction.Added)
    {
        DependencyObject ui = e.OriginalSource as DependencyObject 
        DependencyObject parent = VisualTreeHelper.GetParent(ui);
        if (parent is Border)
        {
            ((Border)parent).BorderThickness = new Thickness(1);
        }
        ToolTipService.SetToolTip(ui, new TextBlock() { Text = e.Error.Exception.Message });
    }
    if (e.Action == ValidationErrorEventAction.Removed)
    {
        DependencyObject ui = e.OriginalSource as DependencyObject 
        DependencyObject parent = VisualTreeHelper.GetParent(ui);
        if (parent is Border)
        {
            ((Border)parent).BorderThickness = new Thickness(0);
        }
        ToolTipService.SetToolTip(ui, null);
    }
}

That same code should work for any control that I want to do validation on, as long as I remember to add the borders in XAML.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

The bossman blogeth

Patrick Cauldwell — Fri, 13 Feb 2009 20:16:28 GMT

In the wake of our Silverlight presentations this week, Shaun (CTO of SoftSource, and my boss) is going to be blogging on his demos, starting with Silverlight/JavaScript interactivity. His demos were pretty cool, so I’m looking forward to reading his commentary. I might just follow suit with a few examples too…

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

New courses in Portland

Patrick Cauldwell — Fri, 13 Feb 2009 18:17:36 GMT

Check out http://events.sftsrc.com/ for more new classes…

LINQ

2 days of LINQ to Objects, LINQ to XML, LINQ to SQL, LINQ to Entities and more

ASP.NET

5 days of ASP.NET including some AJAX and a hint of Silverlight

3 days of WPF goodness

Silverlight

2 days for those with WPF experience or
3 days for web developers

C# and the .NET Framework

5 days of C# 3.0 and the 3.5 framework, including LINQ, extension methods and the rest of the new language features

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

LINQ to SQL and concurrency

Patrick Cauldwell — Fri, 06 Feb 2009 17:39:15 GMT

Google is great at providing 20/20 hindsight.

The little problem I was having with insert triggers is (unsurprisingly) not uncommon. I googled a bit after a suggestion in a comment (thanks El Guapo) and found a great explanation by Mike Taulty on how to deal with just such a concurrency problem. He’s specifically dealing with a timestamp column, but the issue is essentially the same.

Good to know…

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Vegas, baby

Patrick Cauldwell — Thu, 05 Feb 2009 22:56:38 GMT

I’ll be there, soaking up the Silverlight-y goodness.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

LINQ to SQL & insert triggers (can be an problem)

Patrick Cauldwell — Thu, 05 Feb 2009 22:49:23 GMT

Lets say I have a nice simple database (guess which one…)

Now I want to insert a new Order into the Orders table


            using (NorthwindDataContext context
= newNorthwindDataContext())

{

    Order order = newOrder();

    context.Orders.InsertOnSubmit(order);

    context.SubmitChanges();

}

No problem. Totally works like you’d think. What happens if I make more changes after that and call SubmitChanges() again?


            using (NorthwindDataContext context
= newNorthwindDataContext())

{

    Order order = newOrder();

    context.Orders.InsertOnSubmit(order);

    context.SubmitChanges();

    order.Freight = 98.77M;

    order.ShipName = "Fred Jones";

    context.SubmitChanges();

}

Still cool. The problem comes in if I add an insert trigger. Let’s say I add a trigger to set the OrderDate column of the order to make sure it’s always the right date…


            ALTER TRIGGER Trigger1

            ON dbo.Orders

            FOR INSERT
          
            AS
          
            UPDATE Orders

            SET OrderDate = GETDATE()

            FROM Orders INNER JOIN inserted ON Orders.OrderID
= inserted.OrderID

Whether or not that’s a good idea is a whole ‘nother topic. Seemed like the thing to do at the time… However, now there’s a problem. The first SubmitChanges() works fine, but the second one fails with an update conflict. WTF? After I stopped to think about it (and talked to Stuart) I realized that that makes perfect sense. The copy of Order that I have in memory doesn’t know anything about the result of the insert trigger, and so the record is out of date, hence the conflict. In this particular case it wasn’t a problem because it wasn’t too much work to just take out the trigger and set the date in the code. I had been hoping that I wouldn’t have to redeploy the web app, hence the trigger. Best laid plans…

Anyway, it turns out that something similar came up on another project, so it is something to be aware of.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Joining the conversation

Patrick Cauldwell — Thu, 05 Feb 2009 21:04:23 GMT

After reading Scott’s latest missive, I finally gave in and joined the Tweeple.

@pcauldwell

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Databinding to a UserControl in Silverlight

Patrick Cauldwell — Thu, 22 Jan 2009 20:54:28 GMT

Yesterday I posted a bit about a dynamic survey in Silverlight, and today I wanted to start delving into a few details. First of all, databinding to a user control…

I wanted my datagrid to show a series of radio buttons representing a “rating” from 1-5, where that rating corresponds to an enum value in C# and an integer in SQL.

For databinding to work the way I’d want, I need to bind the one value in the source to the set of radio buttons in the target. The easiest way I could think of (and there may be a better way I haven’t thought of) was to make the radio buttons into a user control, and expose a single value. In the XAML for the datagrid, it looks like

<data:DataGridTemplateColumn.CellTemplate>

<t:Rating UserRating="{Binding Path=Answer, Mode=TwoWay}" />

</DataTemplate>

</data:DataGridTemplateColumn.CellTemplate>

The CellTemplate contains just the user control, and binds its UserRating property to the Answer property in the source.

The XAML for the UserControl is simple

<UserControl x:Class="Evaluation.Rating"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>
    <StackPanel Orientation="Horizontal">
        <RadioButton Content="Excellent
(5)" x:Name="excellent" Checked="excellent_Checked"/>
        <RadioButton Content="Good" x:Name="good" Checked="good_Checked"/>
        <RadioButton Content="Neutral" x:Name="neutral" Checked="neutral_Checked"/>
        <RadioButton Content="Adequate" x:Name="adequate" Checked="adequate_Checked"/>
        <RadioButton Content="Poor
(1)" x:Name="poor" Checked="poor_Checked"/>
    </StackPanel>
</UserControl>

In order to get two-way databinding notifications to work properly both ways, the UserRating property of the control is implemented as a DependencyProperty…

publicScaledAnswer UserRating

{

    get { return (ScaledAnswer)GetValue(UserRatingProperty);
}

    set { SetValue(UserRatingProperty, value);
}

}

 
// Using a DependencyProperty as the backing store for
UserRating.  This enables animation, styling, binding, etc...
publicstaticreadonlyDependencyProperty UserRatingProperty
=

    DependencyProperty.Register("UserRating", typeof(ScaledAnswer), typeof(Rating), newPropertyMetadata(newPropertyChangedCallback(RatingChangedCallback)));

Note the callback registered for the PropertyChanged event of the dependency property. If databinding changes the value of the dependency property, we still need to update the UI to check the right radio button.

privatestaticvoid RatingChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)

{

    Rating r = d asRating;

    r.updateUi((ScaledAnswer)e.NewValue);

}

privatevoid updateUi(ScaledAnswer rating)

{

    switch (rating)

    {

        caseScaledAnswer.Excellent:

            excellent.IsChecked
= true;

            break;

        caseScaledAnswer.Good:

            good.IsChecked
= true;

            break;

        caseScaledAnswer.Neutral:

            neutral.IsChecked
= true;

            break;

        caseScaledAnswer.Adequate:

            adequate.IsChecked
= true;

            break;

        caseScaledAnswer.Poor:

            poor.IsChecked
= true;

            break;

    }

}

Finally, the user control handles all the radio button “Checked” events and sets the value of the DependencyProperty to the correct value.

The UserControl provided a fairly smooth way of handling the databinding without having to implement a custom control, and could be reused in other contexts. There’s probably a way to make it a bit more dynamic to handle more radio buttons, etc. but this worked for my particular case.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

A data-driven survey in Silverlight

Patrick Cauldwell — Wed, 21 Jan 2009 18:23:06 GMT

I needed to build a survey (a course evaluation in this case, but name-your-survey…) and I wanted to be able to add new questions and question categories to the database without having to touch my (Silverlight) survey app. I wanted the basic layout to look like this…

It took a little experimentation, and I’m sure there are other ways to make this work, but here’s what worked for me:

The questions and categories live in the database, like so

Categories contain questions, questions have text, and what we store when the survey is complete are the answers to the questions.

In the XAML, first there is an ItemsControl to deal with the categories, so that each category will have it’s own DataGrid. The ItemsControl has a DataTemplate that defines what each category name and data grid of questions will look like (some formatting details removed for clarity)


              <
              ItemsControl
               x
              :
              Name
              ="dgPanel"
>
            
              <
              ItemsControl.ItemTemplate
              >
            
              <
              DataTemplate
              >
            
              <
              StackPanel
               Orientation
              ="Vertical">
            
              <
              TextBlock
               Text
              ="{
              Binding
               CategoryName
              }"
              />
            
              <
              data
              :
              DataGrid
               x
              :
              Name
              ="dgOverall" 
            
              ItemsSource
              ="{
              Binding
               Questions
              }"
              >
            
              <
              data
              :
              DataGrid.Columns
              >
            
              <
              data
              :
              DataGridTextColumn
              Header
              ="Question"
            
                               Binding="{Binding Text}" IsReadOnly="True"/>
          
              <
              data
              :
              DataGridTemplateColumn
               Header
              ="Rating">
            
              <
              data
              :
              DataGridTemplateColumn.CellTemplate
              >
            
              <
              DataTemplate
              >
            
              <
              t
              :
              Rating
               UserRating
              ="{
              Binding
               Path
              =Answer,
               Mode
              =TwoWay}"
/>
            
              </
              DataTemplate
              >
            
              </
              data
              :
              DataGridTemplateColumn.CellTemplate
              >
            
              <
              data
              :
              DataGridTemplateColumn.CellEditingTemplate
              >
            
              <
              DataTemplate
              >
            
              <
              t
              :
              Rating
               UserRating
              ="{
              Binding
               Path
              =Answer,
               Mode
              =TwoWay}"/>
            
              </
              DataTemplate
              >
            
              </
              data
              :
              DataGridTemplateColumn.CellEditingTemplate
              >
            
              </
              data
              :
              DataGridTemplateColumn
              >
            
              </
              data
              :
              DataGrid.Columns
              >
            
              </
              data
              :
              DataGrid
              >
            
              </
              StackPanel
              >
            
              </
              DataTemplate
              >
            
              </
              ItemsControl.ItemTemplate
              >
            
              </
              ItemsControl
              >

The questions come from a WCF call, and get bound in the form load


            void client_GetQuestionsCompleted(object sender, GetQuestionsCompletedEventArgs e)

{

    dgPanel.ItemsSource = e.Result;

}

Each row that comes back has the category header text and a collection of questions, so that for each item in the ItemsControl, the text is bound to the header, and the questions are bound to the datagrid. The DataGridTemplateColumn stuff above maps the Answer property of each question to a UserControl called Rating that contains the radio buttons. Depending on which radio button gets checked, the value of the user control represents an enum value with their answer. Because the data binding is defined as TwoWay, the user’s answers are updating in the in-memory copy of the questions, and when the user eventually hits the “Submit” button, the collection of questions (and answers) is sent back to the web service.

Now I can add new questions to the database and have those questions show up in the survey, and previously submitted evaluations will only have answers for the questions that were present at the time the survey was submitted. There’s still some work to do here, like setting up groups of questions so that different sets of questions could be used for different circumstances, etc, but this is a decent start.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Practical Silverlight: More than just Flash

Patrick Cauldwell — Thu, 15 Jan 2009 22:30:33 GMT

Shaun (my boss) and I are going to be doing a one-day, technically intensive Silverlight event in both Portland (2/12) and Seattle(2/10) next month. This will be a full day (plus lunch) of in depth, 300-400 level Silverlight content. Check out our registration site for full session abstracts and time/place details.

From the event copy…

Look past the glitzy, media rich Silverlight demos, to the reality of writing browser-hosted, business-oriented applications. Learn how to leverage your .NET expertise and see how Silverlight can provide your organization with a powerful platform for building web-delivered solutions.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

Upcoming classes

Patrick Cauldwell — Tue, 06 Jan 2009 00:18:30 GMT

We’ll be teaching several classes on the West side in the next few months, including C#/.NET and Practical .NET Debugging.

The C#/.NET class covers the new features in VS 2008/C# 3.0, including LINQ, automatic properties, the new initializer syntax and the var type, as well as the rest of C# and a solid foundation in .NET 3.5 including XML processing, threading, App Domains, etc.

The Practical .NET Debugging class covers real-world debugging techniques for .NET including the VS 2008 debugger and using WinDbg on .NET code from a practical perspective.

For scheduling details or to register, see our training site.

The posts on this weblog are provided AS IS with no warranties, and confer no rights. The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.