Random Ramblings

EF Code First and WPF with the Chinook database. Part 3 – Styles and DataTemplates 101

Leom Burke — Tue, 22 Feb 2011 13:48:53 +0000

I have decided to split out the styling work into 2 posts as it would be a huge post to restyle even something so simple. so this post is going to change the controls to be more style-conscious and introduce basic style and the next post will introduce some more advance concepts such as using adorners to display additional details.

Going back to the previous post we had a basic app as follows:

This is slightly ugly and needs a little work so the first thing I want to add is a style that will tidy up the artist list.

I want the artist list to have a nice look and feel with rounded button type items and also contain a count of the number of albums – I want each item in the list to look something like this:

The first step to getting this design in place is adding the DataTemplate so that it is picked up by the item. A DataTemplate is a template that gets applied to an object that has no default way of showing itself and manifests itself as its type name.

NOTE – this can also be be done by overriding Object.ToString() but this is a client side post so I don’t want to have to change model code to do something.

I have added a simple DataTemplate to the Application.Resources section in App.xaml as follows:

There are several things going on here:

the first line declares the type that this template is associated with – you have to add the namespace to this file first in order to make this work:
```
xmlns:business="clr-namespace:MusicApp.Model;assembly=MusicApp.Model"
```
The MultiBinding has an associated StringFormat – this is the same as a normal format string except for the “{}” after the equals sign – this simply escapes the format string.
The binding to Albums.Count – yes you can bind to “built-in” properties as well.
The DataTrigger is a simple way of saying that if we have only one album then the trailing text shouldn’t have an ‘s’ on the end.

It is possible to do the whole string in a converter but I like the declarative way as you can see everything going on in one place. For those that like using converters you would bind the TextBlock’s Text property to the whole Artist ({Binding}) and then use a converter like the following:

public class ArtistStringConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        string retVal = string.Empty;
        var artist = value as Artist;
        if (artist != null)
        {
            retVal += string.Format("{0} - {1} {2}", artist.Name, artist.Albums.Count, artist.Albums.Count == 1 ? "artist" : "artists");
        }

        return retVal;
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

this is then used from the xaml as follows:

Once this is added (either option) you need to remove the DisplayMemberPath property from the ArtistList.xaml view so that the template is used instead.

I now have a list of Artists that show the name and the total albums they have so I can work on the actual style to make the list items look like the above image.

I want all three lists to look the same so I am adding a style with no key to the app.xaml file. If you want specific styles for your controls then you can add ‘x:Key=”YourKeyName”’ and reference it using ‘{StaticResource YourKeyName}’ (in this instance the reference would be in the ItemContainerStyle property of the ListBox).

Again I have a couple of things going on inside this style:

It targets ListBoxItem as this is what we want to style (not the ListBox itself).
The margin separates the items nicely.
The actual style part is contained inside a ControlTemplate which is then assigned the Template property of the ListBoxItem.
The ContentPresenter will present whatever content it is given, in this case it is presenting the passed in DataTemplate.
The trigger here indicates that when the ListBoxItem is selected we want to change the fill colour of the rectangle to indicate we have selected an item.

To finish I have added a new DataTemplate for the albums – this looks the same with the type and property names changed to display the correct things and I have also rearranged the view as follows:

This now gives me the following view which I am sure you will agree looks a lot better and is easily achievable by simply using XAML – we could have done this in blend as well but for the simple changes we have made I prefer to edit the XAML directly.

In the next post I will be adding some adorner goodness to the screen for displaying album and track details (which also covers changes to the model).

EF Code First and WPF with the Chinook database. Part 2 – The client

Leom Burke — Tue, 08 Feb 2011 14:27:07 +0000

Now we have the data fetching work sorted out we can turn our attentions to the front-end.

I am going to make a very simple view in this post listing the artists and associated albums with their tracks. It is going to look like this:

Now, this is very basic but it serves its purpose to show the tools we are going to be using – a later post will use the power of WPF to style and transform the screen into something more palatable.

The first thing to do is add a WPF project(I have named mine MusicApp.WPF.Client). If you rename the the MainWindow.xaml file then don’t forget to change the startup uri in app.xaml

In terms of the structure for the project I have separate folders for views, view models and common files.

The View

Once the basic structure is in place we can add our view to the Views folder. The view in this case is a user control that we will add to the main window.

The view itself is very simplistic – 1 grid containing 3 ListBoxes and is created as follows

This is a view with a 2 x 2 grid with columns of equal width (1/2 of the grid each) and one row at 70% width and one at 30%. Inside the grid there is a ListBox that takes up the whole top row (ColumnSpan=2) and one ListBox in each of the columns in the lower row.

I have included all of the bindings so that I know what is required on the view model when I write it. I will need a collection property called ‘Artists’ and 2 properties for the selected artist and selected album.

The DisplayMemberPath details which property of the object will be displayed as text in the ListBoxItem.

Once the control has been written then we can add it to the main window xaml. There are 2 things to do to add a usercontrol to another xaml file

add the correct namespace.
add the control

Adding the namespace requires that we add an xmlns to the top of the main window file

xmlns:views="clr-namespace:MusicApp.WPF.Client.Views"

Once we have this then we can simply add the control as a new object on the window

which gives us a Main window with the following xaml

The ViewModel

Now the view is done I can create a ViewModel to support it. The ViewModel will need to implement INotifyPropertyChanged and I have the following snippet method that will fire the event implemented by it

private void Notify(string propertyName)
{
    if (PropertyChanged != null)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

Unity

I want to be able to use a different data provider here if I want to so I am going to introduce the Unity IoC container to the application at this point. Unity can be installed into the current project directly from NuGet (install-package unity) or you can download directly. It needs a little configuration before we can use it.

I am going to use it to resolve a reference to the IDataProvider interface we created previously so I add a new app.config file to the client project and add the following configuration

This is simply adding a mapping between IDataProvider and EFCodeFirstDataProvider which allows me to resolve the former to the latter.

We need a way of referencing this container in our application so I use a factory class with a static member to hold the actual UnityContainer

class ContainerFactory
{
    private static UnityContainer container;

    public ContainerFactory()
    {
        if (container == null)
        {
            container = new UnityContainer();
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            section.Containers.Default.Configure(container);
        }
    }

    public UnityContainer Container
    {
        get
        {
            return container;
        }
    }
}

I can then have a reference to an IDataProvider in the ViewModel and resolve it from the constructor as follows

ContainerFactory factory = new ContainerFactory();
provider = factory.Container.Resolve();

The whole ViewModel including properties now looks like this.

public class ArtistListViewModel : INotifyPropertyChanged
{
    private IDataProvider provider;
    private ObservableCollection artists;
    private Artist selectedArtist;
    private Album selectedAlbum;

    public ArtistListViewModel()
    {
        ContainerFactory factory = new ContainerFactory();
        provider = factory.Container.Resolve();
        GetArtists();
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public ObservableCollection Artists
    {
        get
        {
            return artists;
        }
        private set
        {
            artists = value;
            Notify("Artists");
        }
    }

    public Artist SelectedArtist
    {
        get
        {
            return selectedArtist;
        }
        set
        {
            selectedArtist = value;
            Notify("SelectedArtist");
        }
    }

    public Album SelectedAlbum
    {
        get
        {
            return selectedAlbum;
        }
        set
        {
            selectedAlbum = value;
            Notify("SelectedAlbum");
        }
    }

    private void GetArtists()
    {
        Artists = new ObservableCollection(provider.GetArtists());
    }

    private void Notify(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Wire it up

Now we have the ViewModel and view in place we need to wire them together this is just a case of setting the views DataContext from its constructor

public ArtistList()
{
    InitializeComponent();
    this.DataContext = new ArtistListViewModel();
}

Wrapping up

Now we have these wired we simply need to add the ConnectionStrings to the config file (that we added the unity config to earlier), change the startup project to the new WPF app and run it. This will now display the window shown at the start and I can change the artist to update the albums/tracks at the bottom.

Next time – making the view look good.

EF Code First and WPF with the Chinook database. Part 1c – the unit tests

Leom Burke — Tue, 25 Jan 2011 12:04:48 +0000

In the final part of the server side code (we have already written a Code First provider and data provider) I am going to implement some unit tests for the two methods I currently have on the data provider.

My unit tests will need to have no access to the database as that would break the encapsulation of the test so we need to mock out the raw data access layer while still providing the functionality that we would expect from the Entity Framework context.

To do this we need to make several changes to the current project to allow us to inject a mocked up context into the data provider.

The first thing we need to do is to abstract the context used by the data provider out into an interface, being as we currently have a small set of classes then the interface is simply:

public interface IContext
{
    IDbSet Artist { get; set; }

    IDbSet Album { get; set; }

    IDbSet Track { get; set; }
}

Notice the IDbSet – this is to allow us to mock up the DbSet’s using the same interface.

Next up we need to edit our Chinook class so that it uses this new interface (note, again, the IDbSet’s)

public class Chinook : DbContext, IContext
{
    protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
    {
        modelBuilder.Conventions.Remove();
    }

    public IDbSet Artist { get; set; }

    public IDbSet Album { get; set; }

    public IDbSet Track { get; set; }
}

Now we have this we can use the interface in the data provider and set it to a Chinook instance by default (for the time being).

private IContext db = new Chinook();

Right we now have a good basis to start working on the test so add a new test project to the solution and create a new class called MockDbSet. This allows us to simulate the actions of a real DbSet in the database for a given set of objects. Huge thanks to Julie Lerman for showing the starting point for this work with her series on EF4 repositories (A great read!).

The MockDbSet implements the IDbSet Interface supplied by the Entity Framework and allows us to replicate the functionality as follows (note I have not implemented the create or find methods as I don’t need them right now.)

public class MockDbSet : IDbSet where T : class
{
    readonly IList _container = new List();

    public T Add(T entity)
    {
        _container.Add(entity);
        return entity;
    }

    public T Attach(T entity)
    {
        _container.Add(entity);
        return entity;
    }

    public TDerivedEntity Create() where TDerivedEntity : class, T
    {
        throw new NotImplementedException();
    }

    public T Create()
    {
        throw new NotImplementedException();
    }

    public T Find(params object[] keyValues)
    {
        throw new NotImplementedException();
    }

    public System.Collections.ObjectModel.ObservableCollection Local
    {
        get
        {
            return new ObservableCollection(_container);
        }
    }

    public T Remove(T entity)
    {
        _container.Remove(entity);
        return entity;
    }

    public IEnumerator GetEnumerator()
    {
        return _container.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return _container.GetEnumerator();
    }

    public Type ElementType
    {
        get
        {
            return typeof(T);
        }
    }

    public System.Linq.Expressions.Expression Expression
    {
        get
        {
            return _container.AsQueryable().Expression;
        }
    }

    public IQueryProvider Provider
    {
        get
        {
            return _container.AsQueryable().Provider;
        }
    }
 }

This is a simple implementation that stores the set in a local List.

Now we have a mock set we can mock up the context which is something that implements IContext and allows us to access the DbSets we want to work with outside of a database environment. I have added some methods to add test data into the sets as well.

class MockContext : IContext
{
    private IDbSet artist;
    private IDbSet album;
    private IDbSet track;

    public IDbSet Artist
    {
        get
        {
            this.CreateArtists();
            return this.artist;
        }

        set
        {
            throw new NotImplementedException();
        }
    }

    public IDbSet Album
    {
        get
        {
            this.CreateAlbums();
            return this.album;
        }
        
        set
        {
            throw new NotImplementedException();
        }
    }

    public IDbSet Track
    {
        get
        {
            this.CreateTracks();
            return this.track;
        }
        
        set
        {
            throw new NotImplementedException();
        }
    }

    private void CreateArtists()
    {
        if (artist == null)
        {
            artist = new MockDbSet();
            artist.Add(new Artist { ArtistId = 1, Name = "Test Artist 1" });
            artist.Add(new Artist { ArtistId = 2, Name = "Test Artist 2" });
            artist.Add(new Artist { ArtistId = 3, Name = "Test Artist 3" });
        }
    }

    private void CreateAlbums()
    {
        if (album == null)
        {
            album = new MockDbSet();
            album.Add(new Album { AlbumId = 1, Title = "Test Album 1", ArtistId = 1 });
            album.Add(new Album { AlbumId = 2, Title = "Test Album 2", ArtistId = 2 });
            album.Add(new Album { AlbumId = 3, Title = "Test Album 3", ArtistId = 3 });
            album.Add(new Album { AlbumId = 4, Title = "Test Album 4", ArtistId = 3 });
        }
    }

    private void CreateTracks()
    {
        if (track == null)
        {
            track = new MockDbSet();
            track.Add(new Track { TrackId = 1, Name = "Test Track 1", AlbumId = 1 });
            track.Add(new Track { TrackId = 2, Name = "Test Track 2", AlbumId = 1 });
            track.Add(new Track { TrackId = 3, Name = "Test Track 3", AlbumId = 1 });
            track.Add(new Track { TrackId = 4, Name = "Test Track 4", AlbumId = 2 });
            track.Add(new Track { TrackId = 5, Name = "Test Track 5", AlbumId = 2 });
            track.Add(new Track { TrackId = 6, Name = "Test Track 6", AlbumId = 2 });
            track.Add(new Track { TrackId = 7, Name = "Test Track 7", AlbumId = 3 });
            track.Add(new Track { TrackId = 8, Name = "Test Track 8", AlbumId = 3 });
            track.Add(new Track { TrackId = 9, Name = "Test Track 9", AlbumId = 4 });
            track.Add(new Track { TrackId = 10, Name = "Test Track 10", AlbumId = 4 });
        }
    }
}

Now we have a context and sets mocked up we can almost write our tests but at the moment we have no way of getting the new mock context into the data provider. This is where we can use an often overlooked assembly attribute, InternalsVisibleTo, which allows the given project access to internal members of the a project. So all we need to do is apply the following to the AssemblyInfo.cs class of the model project.

[assembly: InternalsVisibleTo("MusicApp.Model.Tests")]

and change the context member in the data provider (db) from private to internal and we can access it from the our test project.

I have two tests – one for each method in the data provider and have implemented them as follows:

public class EFCodeFirstDataProviderTest
{
    [TestMethod()]
    public void GetArtistsTest()
    {
        EFCodeFirstDataProvider target = new EFCodeFirstDataProvider() { db = new MockContext() };

        List expected = new List();
        expected.Add(new Artist { ArtistId = 1, Name = "Test Artist 1" });
        expected.Add(new Artist { ArtistId = 2, Name = "Test Artist 2" });
        expected.Add(new Artist { ArtistId = 3, Name = "Test Artist 3" });

        List actual = target.GetArtists();
        CollectionAssert.AreEquivalent(expected, actual);
    }

    [TestMethod()]
    public void SearchArtistsTest()
    {
        EFCodeFirstDataProvider target = new EFCodeFirstDataProvider() { db = new MockContext() };

        string searchTerm = "Artist 1";
        List expected = new List();
        expected.Add(new Artist { ArtistId = 1, Name = "Test Artist 1" });

        List actual = target.SearchArtists(searchTerm);

        CollectionAssert.AreEquivalent(expected, actual);
    }
}

As you can see they are simple tests to determine that the methods return the objects that I wanted. As they stand these methods will fail as the CollectionAssert.AreEquivalent method checks for equality and we have no override for equality (or hash code) in our Artist class so we just need to add them in:

public override int GetHashCode()
{
    return ArtistId;
}

public override bool Equals(object obj)
{
    return ArtistId == (obj as Artist).ArtistId;
}

and the tests will now pass.

In the next post I will create a simple WPF front-end to display the information and then I will build the interface from that point on.

EF Code First and WPF with the Chinook database. Part 1b – the provider

Leom Burke — Thu, 20 Jan 2011 14:40:25 +0000

I like to isolate my data access code to a single point so that my client does not have to worry about creating contexts or anything of the sort. This makes it simpler to change the way the data is delivered to the client as it is abstracted away.

In thinking about what methods I would need for this I discovered that for the first phase I would only need two:

GetArtists() – Returns all artists.
SearchArtists(string searchTerm) – Searches for artists and returns any matches.

I don’t need any methods at the moment to fetch albums or tracks because I have virtual lazy loading properties set up to deal with them. I will be adding more methods to this provider as the series grows (such as adding, deleting…etc).

Lets go ahead and test those lazy properties:

class Program
{
    static Chinook db = new Chinook();

    static void Main(string[] args)
    {
        // Using ToList() executes the command so the datareader is closed.
        var artists = db.Artist.ToList();
        foreach (var a in artists)
        {
            Console.WriteLine(a.Name);
            PrintAlbums(a.Albums);
        }

        Console.ReadLine();
    }

    static void PrintAlbums(ICollection albums)
    {
        foreach (var a in albums)
        {
            Console.WriteLine("\t" + a.Title);
            PrintTracks(a.Tracks);
        }
    }

    static void PrintTracks(ICollection tracks)
    {
        foreach (var t in tracks)
        {
            Console.WriteLine("\t\t" + t.Name);
        }
    }
}

Whoops – seems we have an invalid column name “ArtistArtistId”.

This is due to the way Code First decides on what the foreign key columns are called if we don’t explicitly include them – the default is “{TypeName}{TypeName}Id” which we obviously don’t have in the database.

We need to add the foreign key properties to our objects so EF picks up the correct names (this needs to be done for both Album and Track – note the new ArtistId and AlbumId respectively):

public class Album
{
    public int AlbumId { get; set; }

    public string Title { get; set; }

    public int ArtistId { get; set; }

    public virtual Artist Artist { get; set; }

    public virtual ICollection Tracks { get; set; }
}

public class Track
{
    public int TrackId { get; set; }

    public string Name { get; set; }

    public int AlbumId { get; set; }

    public virtual Album Album { get; set; }

    public string Composer { get; set; }
}

We can now run our demo and get a correct output:

We are now in a position to implement our simple data provider.

I am going to put the data provider behind an interface to allow for easy extension and dependency injection should we want to go that way.

public interface IDataProvider
{
    List GetArtists();

    List SearchArtists(string searchTerm);
}

This is then implemented as follows for the code first model:

public class EFCodeFirstDataProvider : IDataProvider
{
    private Chinook db = new Chinook();

    public List GetArtists()
    {
        return this.db.Artist.ToList();
    }

    public List SearchArtists(string searchTerm)
    {
        return this.db.Artist.Where(a => a.Name.Contains(searchTerm)).ToList();
    }
}

We have a private instance of the Chinook data context that controls all of the fetching of data. When the Artist requests its albums then this context is used. This is the same with the tracks.

The intention here is to allow the client to call simple methods to interact with the data and we are able to swap out for another provider if we so wish easily.

The only thing we now need to change is the little test app so that it uses the new data provider (we will hard code the type here but will be using dependency injection in our WPF app).

static IDataProvider dp = new EFCodeFirstDataProvider();

static void Main(string[] args)
{
    var artists = dp.GetArtists();
    foreach (var a in artists)
    {
        Console.WriteLine(a.Name);
        PrintAlbums(a.Albums);
    }

    Console.ReadLine();
}

And that’s all there is to it – we now have a separate data provider to work with our entity framework objects.

The next part of this series (1c) is going to involve writing unit tests for the data provider. This is easier said than done and involves much mocking of the EF classes.

EF Code First and WPF with the Chinook database. Part 1 – the model

Leom Burke — Thu, 13 Jan 2011 14:26:30 +0000

Introduction

I am going to start a series of posts building a simple app using the Chinook database as a back-end and putting a WPF client on the front-end. I am going to keep it loose as I don’t want to commit to blog posts that I may not get chance to complete so I will keep every post self-contained covering 1 detail of the implementation.

The technologies and tools I plan on using for this series are as follows:

As you can see the idea is to use the latest technologies available to build a simple app to display the music details from the Chinook database. As I am not committing to a large series I will say that my intentions for the series include:

Setting up the model using EF4 Code First (this post).
creating a basic screen listing the artists and associated albums.
Creating an album details adorner to show the tracks of individual albums.

Possible future posts will include:

Adding the ability for customers to place an order (creating invoices).
Adding employees to manage the customer invoices (this is a WPF app so the employee will be doing all of the work as this is not a customer facing app).
Adding the ability to create custom playlists that can reviewed.

Note that all of these items already exist in the Chinook database and I will be focusing on the data access and UI layers.

Building the model using EF Code First

The first thing we need to do is create a new solution for our app. Being as we are creating the model first I am going to create a class library.

Once the solution and project are in place we need to get the Code First bits into the project. I am going to use NuGet so you need to have this installed.

In the NuGet package manager window we can find the required package by firing the command:

Get-Package –remote –filter CodeFirst

This will give us the following output:

This shows us the package that we need to install is EFCodeFirst so we issue

Install-Package EFCodeFirst

this should add the EntityFramework reference to your project but it didn’t do that on my class library so I had to add the reference manually ({SolutionFolder}\packages\EFCodeFirst.0.8\lib\EntityFramework.dll).

Now we have the reference we can start to create our POCO objects. I am going to create a model that initially uses the Artist, Album and Track tables as they are going to be used in the first part of this app – I will add more as I go along.

EF Code First allows us to create standard POCOs to represent our model so for my initial model I have:

public class Artist
{
    public int ArtistId { get; set; }
    public string Name { get; set; }
    public virtual ICollection Albums { get; set; }
}

public class Album
{
    public int AlbumId { get; set; }
    public string Title { get; set; }
    public virtual Artist Artist { get; set; }
    public virtual ICollection Tracks { get; set; }
}

public class Track
{
    public int TrackId { get; set; }
    public string Name { get; set; }
    public virtual Album Album { get; set; }
    public string Composer { get; set; }
}

Note the virtual association properties – this is to allow these properties to be lazy-loaded.

The next thing we need is the actual dbContext which is defined as follows:

using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions.Edm.Db;
.
.
.
public class Chinook : DbContext
{
    protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
    {
        modelBuilder.Conventions.Remove();
    }

    public DbSet Artist { get; set; }
    public DbSet Album { get; set; }
    public DbSet Track { get; set; }
}

This is a class that includes one property per table in the database and handles the mapping to our objects. This is using default conventions with the exception of the one removed in the overridden OnModelCreating method. This says that the database we have doesn’t have pluralised names as Code First expects and instead the names match the entities.

Next we need to add an app.config file to the project and add the ConnectionString for the database. I use SQLServer so adjust accordingly.

Notice that the name of the connectionString must be the same as the class name when using the default conventions.

Testing that it works

OK, we have the model built now and can run a crude test to see if it works. Add a console app to your solution and set it as the startup project. Add references to the Model assembly and the Code First assembly and move the app.config to the new project. Now add the following code to the main method.

static void Main(string[] args)
{
    using (Chinook db = new Chinook())
    {
        foreach (var artist in db.Artist)
        {
            Console.WriteLine(artist.Name);
        }

        Console.ReadLine();
    }
}

This will loop through all of the artists and print their name to the screen.

That’s all there is to creating a simple model with Entity Framework Code First CTP5. In the next instalment I plan on writing a simple data provider class that will abstract the actual DbContext calls away from the user and allow the user to simply call methods like provider.GetArtists().

WPF/Silverlight ListBox and equality checking

Leom Burke — Thu, 16 Dec 2010 11:03:39 +0000

In WPF we bind collections of objects to ListBoxes and the like all the time – its part and parcel of the WPF development cycle but this is something that stung me recently.

I bound a collection of objects to the ItemsSource property as usual but the selection was odd. Every time I selected an item the ListBox assumed that the first item was also selected and subsequent selections marked all previous selections as selected, also the SelectedIndex was always 0. It took some time but I tracked it down to the way that ListBoxes use equality.

Something I didn’t know was that the objects that I was using had an overridden Equals method which was simply comparing a single string on the objects to determine if they were equal. Because I only wanted a small subset of of the object I only populated those properties I needed along with the id of the object and not the string being compared.

The below shows an example of what I was doing.

public class MainViewModel : INotifyPropertyChanged
{
    private ObservableCollection foos;

    public ObservableCollection Foos
    {
        get
        {
            return foos;
        }
        set
        {
            foos = value;
        }
    }

    public MainViewModel()
    {
        this.Foos = new ObservableCollection();
        this.Foos.Add(new Foo { id = 1, Display = "First" });
        this.Foos.Add(new Foo { id = 2, Display = "Second" });
        this.Foos.Add(new Foo { id = 3, Display = "Third" });
        this.Foos.Add(new Foo { id = 4, Display = "Fourth" });
        this.Foos.Add(new Foo { id = 5, Display = "Fifth" });
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

public class Foo
{
    public int id { get; set; }

    public string Display { get; set; }

    public string FooCode { get; set; }

    public override bool Equals(object obj)
    {
        return FooCode == (obj as Foo).FooCode;
    }
}

As we can see I have no interest in the FooCode property and as a result don’t use it in my ViewModel.

The problem with this is that now the ListBox has no way of knowing if the objects are different as we have an overriding Equals method that implements value equality rather than reference equality and because the value is always going to be the same (as I don’t set it) then the ListBox will assume that every object is essentially the same object.

A simple change to include the FooCode property in each object in the collection solves this problem and gives us different values for equality testing.

A sample project with 2 lists displaying this different behaviour can be found here.

Skinning in WPF

Leom Burke — Tue, 07 Dec 2010 12:24:58 +0000

I like writing XAML. It gives me a sense of completion when I write a style of template by hand and it just works, I like using blend as well but raw is more fun .

Lets say we have a requirement to change the front-end of a product for different brandings and “products” (that is, the same product with a different ‘skin’). One of the challenges we have is that we don’t want to write new user controls every time the client screen needs to change (especially for something simple such as switching to a different style for certain builds). What follows is a way of using the power of WPF resources to skin an application with little work.

we start off with 2 ListBoxes on a window, for the purposes of this article the list boxes are simple with a list of colours, as follows (they are both the same).

 
    Red 
    Yellow 
    Pink 
    Green 
    Orange 
    Purple 
    Blue

Now, this will just display 2 boring list so lets add a nice style in the app.xaml file for the left hand list as follows:

Adding the ItemContainerStyle ({StaticResource RoundedList}) to the list box will now give us something like the following:

As we can see we now have a nice styled list on the left which will change colour when we click on each item. To demonstrate the skinning I am going to apply the same style to the right hand list but with a different name (so we now have 2 styles in the app.xaml file – RoundedList and RoundedList_skin).

So, for certain builds of this app we want the list buttons to shrink slightly when we click them but we only want it to do that for certain configurations. We can add a new WPF resource dictionary to our project (Skin.xaml) and add the new style to it – it is important that the new style retains the name of the one it is replacing as we shall see shortly.

The transform in this style simply makes the item look as though it had been pressed.

And now for the actual trick of making the new skin available to the app thus replacing the defaults in App.xaml. I need a new Application configuration file (App.config) with an appSetting (skins) to hold the required skins for this application build. This is a comma-separated list of resource dictionaries that we are going to include in this build. In order to allow the new skins to override the existing ones we are required to move the current resources that we have defined into a dictionary of their own (this is due to the scoping rules of merged dictionaries in WPF – the primary dictionary will always take precedence). I am simply going to move them into a new dictionary called OriginalSkin.xaml and include this in my skins appSetting which now looks like this.

We now have the two dictionaries ready to be loaded. In App.xaml.cs we need a new method to load the skins from the config and this should be called from the OnStartup method of the app (its virtual so is available right there in app.xaml.cs to be overridden).

private void LoadSkins()
{
    string skins = ConfigurationManager.AppSettings["skins"];
    if (string.IsNullOrEmpty(skins))
    {
        return;
    }

    string[] resources = skins.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
    foreach (string resource in resources)
    {
        ResourceDictionary dictionary = new ResourceDictionary();
        dictionary.Source = new Uri(resource, UriKind.Relative);
        this.Resources.MergedDictionaries.Add(dictionary);
    }
}

This code loops through the skins in the appSetting and adds them as merged dictionaries. The beauty of this is that merged dictionaries are read in the order that they are added so the latter dictionaries will override the earlier ones resulting in our newly minted RoundedList_skin being called instead of the original one but the original version of RoundedList is still available for the other ListBox:

We can now add any number of skins to this configuration but we will only load the ones listed in the App.config file – this now makes the app very extensible and can be changed at the drop of a hat.

The sample application that I used for this post can be found here

MVVM – The ‘Other’ ViewModel

Leom Burke — Wed, 01 Dec 2010 11:29:07 +0000

Something that we regularly do at work is add additional properties to business objects that are only for use on the client (isDirty, HasChanged …etc). We have always just added these to the business object directly and thought nothing of it, but after listening to a Hanselminutes interview with Laurent Bugnion I discovered the ‘other’ use for a ViewModel – wrapping client side business objects to expose new properties. This is also useful in removing the overhead of viewing objects via a converter.

I have recently started looking at ASP.NET MVC as well and the way to pass things between controller and view is by using a ViewModel class. This overload of the term had not translated into being useable in MVVM as well so what follows is a short, simple example of using a ViewModel to better model some data to fit a view.

Lets say we have a meeting object that we have extracted from a service and it is now ready to display on our client. This business object has no real relation to them ORM version of the same object if we are correctly differentiating between them and client facing business objects so it has no in-built tracking to determine if it has changed and we don’t want to send it back to the service for updating if nothing has changed. Our class looks like this.

public class Meeting
{
    public Meeting()
    {

    }
    public string Subject { get; set; }
    public string Location { get; set; }
    public DateTime StartTime { get; set; }
    public List Attendees { get; set; }
}

This is a very simple class to define our meeting but it has no way of knowing if it has changed and also the StartTime property is stored on the server as UTC but the client could be anywhere.

Taking the latter problem first you may be tempted to bind directly to the StartTime property of this object and use a converter to convert to the appropriate time zone based on the user culture (as I have done many times). As for the problem with a meeting change, there has to be some way of telling an object that it has changed. Both of these problems can be solved with a MeetingViewModel. This is a VM that follows the decorator pattern and could be implemented as follows:

public class MeetingViewModel
    {
        private Meeting inner;
        public MeetingViewModel(Meeting m)
        {
            inner = m;
        }

        public Meeting Inner
        {
            get
            {
                return inner;
            }
        }

        public string Location
        {
            get
            {
                return inner.Location;
            }
            set
            {
                inner.Location = value;
            }
        }
        public DateTime StartTime
        {
            get
            {
                return inner.StartTime;
            }
            set
            {
                inner.StartTime = value;
            }
        }
        public List Attendees
        {
            get
            {
                return inner.Attendees;
            }
            set
            {
                inner.Attendees = value;
            }
        }

        public DateTime LocalStartTime
        {
            get
            {
                return inner.StartTime.ToLocalTime();
            }
            set
            {
                inner.StartTime = value.ToUniversalTime();
            }
        }

        public bool IsDirty { get; set; }
    }

Here we now have a nice property that sorts out the StartTime into a local time for us and a property that determines if this object has changed. In your VM that controls your view you now operate on an object of type MeetingViewModel and all bindings are to this object. When it comes time to save the object you simply need to check if you have set the dirty flag and if so extract the internal Meeting object using the get-only property and send it back to the service.

This is also a nice way of working with business objects that you have no control over such as from an external web service or third party library. Once you start to understand the power of this approach over simply using converters you will find yourself writing VM’s for all of your business objects that you need to modify slightly on the client side when you need properties like the above or other bits of information like calculated properties.

Using JustMock and Dependency Injection to mock data providers

Leom Burke — Mon, 15 Nov 2010 13:56:41 +0000

Justmock is an excellent, fairly new, mocking framework from Telerik that I had the pleasure of getting a free licence for at the launch event. The company I work for has now picked this up and is intending on rolling it out across the development department and I don’t think it can happen soon enough. This is a conversation I have just had (edited and redacted for this blog) with a colleague about using it to mock up the fetching of data.

The current set up was similar to this much more contrived example but it serves to demonstrate the changes we made.

We had a class that depended on the data provider to access the database and return actual values to verify a method was working. For this example I am using simple number checking but the actual problem was much larger. The data provider fetches a list of numbers based on an initial value and then the checker returns the maximum value in the results set. The data provider interface and checker are below.

public interface IDataProvider
{
    List GetNumbers(int start);
}

public class DataProvider : IDataProvider
{
    public List GetNumbers(int start)
    {
        var list = new List();
        // Use EF to access db and return list based on parameter
        // return a new list for this example
        return list;
    }
}

public class NumberChecker
{
    public int Getmax()
    {
        IDataProvider dp = new DataProvider();
        return dp.GetNumbers(5).Max();
    }

    public List GetNumbers()
    {
        IDataProvider dp = new DataProvider();
        return dp.GetNumbers(5);
    }
}

This is very simple code and the associated test went something like this.

[TestMethod()]
public void CheckCheckGeneratorReturnsMaximumValue()
{
    NumberChecker checker = new NumberChecker();
    int expected = checker.GetNumbers().Max();
    int actual = checker.Getmax();
    Assert.AreEqual(expected, actual);
}

This test passes but its not very nice. It calls the generator methods twice and then continues to touch the database in order to get the data.

We really wanted to use JustMock so we broke it out and installed it on his machine.

To refactor this code into something testable we first had to remove that dependency on the data provider. The fact that it has an interface makes this much easier as we can simply inject an implementer of this interface into the method and act on that. So without changing the implementation of the data provider and the interface the NumberChecker class became the following.

public class NumberChecker
{
    public int Getmax(IDataProvider dp)
    {
        return dp.GetNumbers(5).Max();
    }

    public List GetNumbers(IDataProvider dp)
    {
        return dp.GetNumbers(5);
    }
}

Here we have moved the data provider up to a parameter and are now able to inject any implementer we choose into this method.

This now allows us to test these methods without accessing the data or the real data provider (as we are not testing that here).

JustMock has a method that allows you to return any value when calling a method on a mocked object (Returns). Using this we can mock up our data provider to do something that we want it to do rather than access the database. This then allows us to return a custom value so the test now becomes:

[TestMethod()]
public void CheckCheckGeneratorReturnsMaximumValue()
{
    // ARRANGE
    // Create a new list of integers to use as the returns value
    var ints = new List { 1, 2, 3, 4, 5 };

    // Create the data provider object and set it up so that GetNumbers method
    // always returns the list we created above.
    var provider = Mock.Create();
    Mock.Arrange(() => provider.GetNumbers(Arg.IsAny())).Returns(ints);

    // ACT
    // Run the NumberChecker method passing in our mocked data provider
    NumberChecker checker = new NumberChecker();
    int actual = checker.Getmax(provider);

    // ASSERT
    int expected = 5;
    Assert.AreEqual(expected, actual);
}

As we can now see passing in the data provider instance from here makes the test much easier to understand. We have created a new list of integers and are simply returning this from the method on the data provider that we pass in to our NumberChecker.

Binding and styling text to a RichTextBox in WPF

Leom Burke — Fri, 09 Apr 2010 16:03:39 +0000

The RichTextBox in WPF is a great tool for dealing with text that needs to be styled (such as syntax highlighting) but its not so great when it comes to allowing us to bind and edit text on the fly.

I got a feature request from our product manager to change the colour of certain text within a TextBox to match a legacy application. It turns out it is not as straight forward as you might expect.

We have text in an SQL database like this:

this is a title:.\r\n\r\nThis is a normal line\r\n\r\nthis is another title:.\r\n

You can see that the titles end with “:.” so all we need to do is pull out these lines and make them (in my case) blue.

The problem is that this text is on an object that my previous TextBox was able to bind its Text property to with ease, but the RichTextBox has no text property as it displays a flow document. OK, I thought, I will just bind the text to the document as follows:

This doesn’t work because the Document property is not a Dependency Property and therefore can not be bound to. So BindableRichTextBox here I come. I created a very simple control so that I could bind to the Document property. In doing this I discovered that the Document property expects a FlowDocument as its content so I had to convert my text string to a flow document with the relevant parts highlighted. I used a converter to spit out the FlowDocument with the correctly formatted text on a per line basis


public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
    FlowDocument doc = new FlowDocument();

    string s = value as string;
    if (s != null)
    {
        using (StringReader reader = new StringReader(s))
        {
            string newLine;
            while ((newLine = reader.ReadLine()) != null)
            {
                Paragraph paragraph = null;
                if (newLine.EndsWith(":."))
                {
                    paragraph = new Paragraph(new Run(newLine.Replace(":.", string.Empty)));
                    paragraph.Foreground = new SolidColorBrush(Colors.Blue);
                    paragraph.FontWeight = FontWeights.Bold;
                }
                else
                {
                    paragraph = new Paragraph(new Run(newLine));
                }

                doc.Blocks.Add(paragraph);
            }
        }
    }

    return doc;
}

This simply takes the string and reads it line by line. If we have the desired characters at the end of a line (“:.”) then we make the line blue and bold and remove the characters, otherwise we just add the text. Each line is added as a paragraph so to reduce the space between each one I added the following to the control declaration in the XAML

This simply removes the the margin from each paragraph.

The final part of the puzzle is the control that allows binding this is a simple case of adding a dependency property onto a new control that inherits from RichTextBox

public class BindableRichTextBox : RichTextBox
{
    public static readonly DependencyProperty DocumentProperty = DependencyProperty.Register("Document", typeof(FlowDocument), typeof(BindableRichTextBox), new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnDocumentChanged)));

    public new FlowDocument Document
    {
        get
        {
            return (FlowDocument)this.GetValue(DocumentProperty);
        }

        set
        {
            this.SetValue(DocumentProperty, value);
        }
    }

    public static void OnDocumentChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        RichTextBox rtb = (RichTextBox)obj;
        rtb.Document = (FlowDocument)args.NewValue;
    }
}

I hope you find a use for this – I simply need it written down somewhere so I don’t forget!