Design Review and Delegation Vs. Inheritance

This week I want to discuss another bullet from my code review checklist. 

Consider delegation over inheritance.  I have had some pretty heated debates on this topic in the past and I will even take it a step further and say the rule should state that we should favor delegation over inheritance.  Let’s consider the following classic (and intuitive) person/student/teacher example.  A class diagram might look something like this

Person is our base class; Teacher and student derive from person.  We can say that a student Is A person and that a Teacher Is A person.

The up-side of this design is it is simple, intuitive, and it will perform well.  The down side of this approach is that there is a tight coupling between the derived classes and the base class, we are breaking encapsulation by making the functionality of the derived class dependent on the functionality in the base class, and we may even break encapsulation on our Person class by using protected or public access modifiers where we normally wouldn’t do so. 

The problem with breaking encapsulation is that making a change to one class (our base class) can cause unintended changes in other consuming classes (our derived classes).  I can’t begin to tell you how many times I have seen a seemingly small change to a base class break huge pieces of an application.

Now let’s consider using delegation rather than inheritance.  We will change our class diagram to look like the following:

We can say a teacher Has A person and similarly student Has A person.

The down-side of this design is that we have to write more code to create and manage the person class and thus the code will not perform as well (though in most cases I suspect the performance hit is negligible).  We also cannot use polymorphism - we cannot treat a student as a person and we cannot treat a teacher as a person.  The up-side of this design is that we can decrease coupling by defining a person interface and using the interface as the return type for our Person property rather than the concrete Person class, and our design is more robust.  When we use delegation we can have a single instance of a person act as both a student and a teacher.  Try that in C# using the inheritance design!

 

Technorati Tags: Design Review,inheritance,delegation c# code review

Design Review and the DRY Principle

DRY in the DRY principle is an acronym for Don’t Repeat Yourself.  While we are going to focus on applying the principle to code, it can and should be applied to more than just code.  The can be applied to database schemas, tests, documentation, test plans, design documents, build scripts and more.  Any time we start duplicating our work we are signing up for parallel maintenance and chances are we will eventually have the items fall out of synch.

We can use several techniques to avoid duplicate code.  Some obvious things we can do include using classes and methods to organize common code.  We can write an abstract or base class to implement common behaviors for multiple derived classes. 

We can use properties to perform a validation in one place rather than performing the validation anywhere we want to use a member variable:

Code Snippet

1.         [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
2.         int aComplexInteger;
3.         public int AComplexInteger
4.         {
5.             get { return aComplexInteger; }
6.             set
7.             {
8.                 if (value == 0)
9.                     throw new ArgumentOutOfRangeException("AComplexInteger");
10.                 if (value != aComplexInteger)
11.                 {
12.                     aComplexInteger = value;
13.                     //Maybe raise a value changed event
14.                 }
15.             }
16.         \

One of my favorite techniques is constructor chaining.  If we have multiple constructors that perform similar logic , we should use constructor chaining to avoid duplicating code:

Code Snippet

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
6. namespace CicMaster
7. {
8.     class BetterConstructorLogic
9.     {
10.         #region WhyItIsBetter
11.         //No duplicate code, this is called constructor chaining
12.         //step through this
13.         #endregion
14.         string someString = string.Empty;
15.         int someInteger = 0;
16.         List<int> myIntegers = new List<int>();
18.         public BetterConstructorLogic():this("A Default Value")
19.         {
20.             //someString = "A Default Value";
21.             System.Diagnostics.Debug.WriteLine("In Default Constructor");
22.         }
24.         public BetterConstructorLogic(string aString):this(aString,123)
25.         {
26.             //someInteger = 123;
27.             System.Diagnostics.Debug.WriteLine("In one param constructor");
28.         }
30.         public BetterConstructorLogic(string aString, int anInteger)
31.         {
32.             System.Diagnostics.Debug.WriteLine("In two param constructor");
34.             someString = aString;
35.             someInteger = anInteger;
36.             myIntegers.Add(someInteger);
37.             myIntegers.Add(someInteger ^ 3);
38.             myIntegers.Add((int)(2 * 3.14 * someInteger));
39.         }
40.     }
41. }

The final technique I would like to mention is use a factory to create all but the simplest objects.  The following (admittedly nonsensical) code needs to execute maybe a half dozen lines of code to construct an Order object. 

Code Snippet

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Threading;
7. namespace BusinessLayer
8. {
9.     class ObjectContext
10.     {
11.         public ObjectContext(String username)
12.         {
13.             //Look up the user permissions
14.         }
15.         public bool IsInTranaction { get; set; }
16.         public bool BeginTransaction()
17.         {
18.             //do some transaction logic
19.             return true;
20.         }
21.     }
22.     class Order
23.     {
24.         public Order(ObjectContext theContext)
25.         {
27.         }
29.     }
30.     class Consumer
31.     {
32.         public Consumer()
33.         {
34.             ObjectContext ctx = new ObjectContext(Thread.CurrentPrincipal.Identity.Name);
35.             if (!ctx.IsInTranaction)
36.             {
37.                 if (ctx.BeginTransaction())
38.                 {
39.                     //...
40.                 }
41.             }
42.             Order order = new Order(ctx);
44.         }
45.     }
47. }

Duplicating these few lines of code in a couple places is not that difficult.  Now say the application is enhanced and grows for a few years and suddenly we see this code duplicated dozens or hundreds of times.  At some point it is likely that we want to change the construction logic, finding and changing all the code we use to create the order is difficult, time consuming, and a QA burden. 

A better approach would be to encapsulate the logic required to build a new order.  Here is an implementation using a simple factory.  It is much easier to find, change, and test this code:

Code Snippet

1.     static class OrderFactory
2.     {
3.         public static Order GetOrder()
4.         {
5.             ObjectContext ctx = new ObjectContext(Thread.CurrentPrincipal.Identity.Name);
6.             if (!ctx.IsInTranaction)
7.             {
8.                 if (ctx.BeginTransaction())
9.                 {
10.                     //...
11.                 }
12.             }
13.             return new Order(ctx);
14.         }
15.     }
16.     class DryConsumer
17.     {
18.         public DryConsumer()
19.         {
20.             Order order = OrderFactory.GetOrder();
21.         }
22.     \

If we recognize that we are duplicating even a few lines of code over and over we need to take a serious look at the code and figure out a way to encapsulate the logic.

 

My design review checklist

Technorati Tags: DRY,Design Review,Agile principles,Don't Repeat Yourself

Silverlight 3, the CollectionViewSource and sorting

In my previous post we were introduced to the CollectionViewSource. We have multiple ItemSources binding to the same collection using a CollectionViewSource – very powerful.  Now what if we want to sort the items displayed in one of our grid cells?  We will focus on row one and column one for the rest of this post.

I’ve added some more default data to the Control’s constructor to make things a little more interesting and also notice I have added a few buttons to the bottom of our control:

The Sort by Name button adds a sort description to the CollectionViewSource

theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeName",ListSortDirection.Ascending));

This code tells the CollectionViewSource to sort the items in it’s view by the SomeName property in ascending order.  Click the button and we see the following:

Click the Clear Sort Descriptions button.

The Sort By Value button tells the CollectionViewSource to sort the items in the view by the SomeValue Property in ascending order.

theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeValue", ListSortDirection.Ascending));

Click the button to see the following:

This time our list is sorted by the SomeValue property.

Where things get interesting is that you can add multiple sort descriptions.  Try clearing the filter, then adding the name and value filter (in that order) and we see the following:

The collection is first sorted by name, then by value.

Clear the filter and click the Value, then name button and we see this:

The collection is first sorted by SomeValue, then by SomeName.

The order is important!  If you want to add a sort description to the top of the sort order, simply use the Insert method as follows:

theDataContext[0].Column1.View.SortDescriptions.Insert(0,new SortDescription("SomeValue", ListSortDirection.Ascending));

Here is the modified XAML:

Code Snippet

1. <UserControl xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data" x:Class="SilverlightApplication1.MainPage"
2.    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3.    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4.    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
5.    mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480">
    <UserControl.Resources>
        <Style TargetType="Button">
            <Setter Property="FontSize" Value="9"/>
        </Style>
    </UserControl.Resources>
  <Grid x:Name="LayoutRoot">
        <ScrollViewer VerticalScrollBarVisibility="Auto">
            <StackPanel Orientation="Vertical">
            <data:DataGrid x:Name="TheMainDataGrid"  AutoGenerateColumns="False" ItemsSource="{Binding}" HeadersVisibility="Column">
                <data:DataGrid.Columns>
                    <data:DataGridTemplateColumn Header="Column 1">
                        <data:DataGridTemplateColumn.CellTemplate>
                            <DataTemplate>
                                <ListBox MinHeight="15" ItemsSource="{Binding Path=Column1.View}" >
                                    <ListBox.ItemTemplate>
                                        <DataTemplate>
                                            <StackPanel Orientation="Horizontal">
                                                <TextBlock Margin="10" Text="{Binding Path=SomeName}" />
                                                <TextBlock Margin="10" Text="{Binding SomeValue}" />
                                            </StackPanel>
                                        </DataTemplate>
                                    </ListBox.ItemTemplate>
                                </ListBox>
                            </DataTemplate>
                        </data:DataGridTemplateColumn.CellTemplate>
                    </data:DataGridTemplateColumn>
                    <data:DataGridTemplateColumn Header="Column 2">
                        <data:DataGridTemplateColumn.CellTemplate>
                            <DataTemplate>
                                <ListBox MinHeight="15" ItemsSource="{Binding Path=Column2.View}" >
                                    <ListBox.ItemTemplate>
                                        <DataTemplate>
                                            <StackPanel Orientation="Horizontal">
                                                <TextBlock Margin="10" Text="{Binding SomeName}" />
                                                <TextBlock Margin="10" Text="{Binding SomeValue}" />
                                            </StackPanel>
                                        </DataTemplate>
                                    </ListBox.ItemTemplate>
                                </ListBox>
                            </DataTemplate>
                        </data:DataGridTemplateColumn.CellTemplate>
                    </data:DataGridTemplateColumn>
                </data:DataGrid.Columns>
            </data:DataGrid>
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
                <TextBlock Margin="5" Text="Name:"/>
                <TextBox x:Name="tbNAme" Margin="5" Width="100"></TextBox>
                <TextBlock Margin="5" Width="100" Text="Value:"/>
                <TextBox x:Name="tbValue" Margin="5" Width="100"></TextBox>
                <Button x:Name="AddButton" Margin="5" Content="Add" Click="AddButton_Click"/>
            </StackPanel>
            <StackPanel HorizontalAlignment="Left">
                <Button x:Name="ChangeNameButton" Width="150" Content="Change Name" Click="ChangeNameButton_Click"/>
                <Button x:Name="ChangeValueButton" Width="150" Content="Change Value" Click="ChangeValueButton_Click"/>
                <Button x:Name="refresh" Width="150" Content="Refresh CVS" Click="refresh_Click" />
                <Button x:Name="AddNameSort" Width="150" Content="Sort by Name" Click="AddNameSort_Click"/>
                <Button x:Name="AddValueSort" Width="150" Content="Sort by Value" Click="AddValueSort_Click"/>
                <Button x:Name="ClearSort" Width="150" Content="Clear Sort Descriptions" Click="ClearSort_Click"/>
            </StackPanel>
        </StackPanel>
            </ScrollViewer>
  </Grid>
68. </
UserControl>

Here is the modified code behind:

Code Snippet

1. using System.Collections.ObjectModel;
2. using System.Windows.Controls;
3. using System.Windows.Data;
4. using System.ComponentModel;
6. namespace SilverlightApplication1
7. {
8.     public partial class MainPage : UserControl
9.     {
10.         ObservableCollection<TestClass> theMainCollection ;
11.         ObservableCollection<TheRowClass> theDataContext;
12.         public MainPage()
13.         {
14.             InitializeComponent();
15.             theMainCollection = new ObservableCollection<TestClass>()
16.                 { new TestClass() {SomeName="A",SomeValue=11},
17.                     new TestClass() {SomeName="A",SomeValue=12},
18.                     new TestClass() {SomeName="A",SomeValue=10},
19.                     new TestClass() {SomeName="AB",SomeValue=21},
20.                     new TestClass() {SomeName="A",SomeValue=13},
21.                     new TestClass() {SomeName="B",SomeValue=13},
22.                     new TestClass() {SomeName="B",SomeValue=14},
24.                     new TestClass() {SomeName="AB",SomeValue=11},
25.                     new TestClass() {SomeName="BC",SomeValue=22},
26.                     new TestClass() {SomeName="AB",SomeValue=23},
27.                     new TestClass() {SomeName="BC",SomeValue=24}
28.                 };
29.           
30.             theDataContext = new ObservableCollection<TheRowClass>();
31.             theDataContext.Add(new TheRowClass(theMainCollection));
32.             theDataContext.Add(new TheRowClass(theMainCollection));
34.             TheMainDataGrid.DataContext = theDataContext;
35.             AddFilter(theDataContext[0].Column1, 1, 1);
36.             AddFilter(theDataContext[0].Column2, 1, 2);
37.             AddFilter(theDataContext[1].Column1, 2, 1);
38.             AddFilter(theDataContext[1].Column2, 2, 2);
39.            
41.         }
42.         private void AddFilter(CollectionViewSource cvs, int row, int column)
43.         {
44.             cvs.Filter += delegate(object o, FilterEventArgs eArgs)
45.             {
46.                 //Simple filter saying if column = 1 look for an A in the SomeName property
47.                 //Else look for a B.  If we are in Row 1 look for a 1 in the SomeValue property
48.                 //Else look for a 2
49.                 string columnFilter;
50.                 if (row == 1)
51.                     columnFilter = "A";
52.                 else
53.                     columnFilter = "B";
54.                 if ((eArgs.Item as TestClass).SomeValue.ToString().Contains(column.ToString()) && (eArgs.Item as TestClass).SomeName.Contains(columnFilter))
55.                     eArgs.Accepted = true;
56.                 else
57.                     eArgs.Accepted = false;
58.             };
60.         }
62.         private void AddButton_Click(object sender, System.Windows.RoutedEventArgs e)
63.         {
64.             TestClass tc = new TestClass();
65.             tc.SomeName = tbNAme.Text;
66.             tc.SomeValue = int.Parse(tbValue.Text);
67.             theMainCollection.Add(tc);
68.         }
70.         private void ChangeNameButton_Click(object sender, System.Windows.RoutedEventArgs e)
71.         {
72.             theMainCollection[theMainCollection.Count-1].SomeName = "B";
73.         }
75.         private void ChangeValueButton_Click(object sender, System.Windows.RoutedEventArgs e)
76.         {
77.             theMainCollection[theMainCollection.Count - 1].SomeValue = 25;
78.         }
80.         private void refresh_Click(object sender, System.Windows.RoutedEventArgs e)
81.         {
82.             theDataContext[0].Column1.View.Refresh();
83.             theDataContext[1].Column1.View.Refresh();
84.             theDataContext[0].Column2.View.Refresh();
85.             theDataContext[1].Column2.View.Refresh();
86.         }
88.         private void AddNameSort_Click(object sender, System.Windows.RoutedEventArgs e)
89.         {
90.             theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeName",ListSortDirection.Ascending));
91.         }
93.         private void AddValueSort_Click(object sender, System.Windows.RoutedEventArgs e)
94.         {
95.             theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeValue", ListSortDirection.Ascending));
96.         }
98.         private void ClearSort_Click(object sender, System.Windows.RoutedEventArgs e)
99.         {
100.             theDataContext[0].Column1.View.SortDescriptions.Clear();
101.         }
102.     }
103. }
104. 
     

See my previous post to get the supporting code.

Technorati Tags: Silverlight 3,CollectionViewSource,ObservableCollection,DataGrid,SortDescription

Silverlight 3 and the CollectionViewSource

I have been working on a really cool Silverlight application for the last several weeks.  The application is a graphically intensive businesses application with some pretty challenging lists nested in a grid and some very cool drag and drop functionality.  Here is the scenario: 

When the app starts up we make a call to a WCF service and get several hundred to several thousand objects back in an observable Collection.  We slice, dice, and manipulate the ObservableCollection<T> and now the challenge is we have to present several dozen to several hundred different views into this same data.  Throwing several hundred different views of the same data at a user all at once is not particularly useful so the views are stored in cells of a scrollable grid.  As I mentioned, each cell in the grid is a list of items that needs to be generated based on some attributes of the column and row in the grid.  Conceptually I want to break my original collection into a bunch of smaller collections but I didn’t want to physically break the collection  into multiple collections because the drag and drop functionality I spoke of would force me to get into the business of removing an item from one collection and adding it to another.  Additionally once the items are placed where we want them I would have to reassemble the master collection and send it back to the server.  Using a single ObservableCollection<T>) collection is a good fit.  How do we get multiple independent views into this ObservableCollection<T>) ? 

Enter the CollectionViewSource.  The CollectionViewSource allows us to set a source property (in our case the ObservableCollection<T> we got from the WCF call) then set one or many filters and finally we bind each cell to the View property of the CollectionViewSource to allow us to get a list of objects that satisfy our filter criteria.

Let’s whip up a very simple application and demonstrate the behavior. 

Here is the screen:  We have a grid with 2 rows and 2 columns.  Each Cell represents a list of type TestClass.  TestClass has two properties, SomeName – a string property, and SomeValue an integer property.  Below the grid we have two text boxes and and add button.  This will allow us to demonstrate that we can add items to the observable collection and have the UI automatically update.  Ignore the bottom 3 buttons for the moment.

Rather than make a WCF call we are building the “Main” collection of objects  in the MainPage constructor:

Code Snippet

1.             theMainCollection = new ObservableCollection<TestClass>()
2.                 { new TestClass() {SomeName="A",SomeValue=11},
3.                     new TestClass() {SomeName="A",SomeValue=12},
4.                     new TestClass() {SomeName="B",SomeValue=13},
5.                     new TestClass() {SomeName="B",SomeValue=14},
6.                     new TestClass() {SomeName="AB",SomeValue=21},
7.                     new TestClass() {SomeName="BC",SomeValue=22},
8.                     new TestClass() {SomeName="AB",SomeValue=23},
9.                     new TestClass() {SomeName="BC",SomeValue=24}
10.                 };

Now we need to create a collection for the grid to bind to.  Remember, what we want is for each grid cell to be a view into our “main” collection.  In our Example we are using a DataGrid object to display our views and we want the DataGrid to automatically update if we add an object to or remove an object from the main collection .  What we need here is an ObeservableCollection of objects with a CollectionViewSource property for each column.  In our example we have called the object TheRowClass. TheRowClass has two properties of type CollectionViewSource; Column1 and Column2.

Here is the code I use to initialize the ObservableCollection<TheRowClass>:

Code Snippet

1.             theDataContext = new ObservableCollection<TheRowClass>();
2.             theDataContext.Add(new TheRowClass(theMainCollection));
3.             theDataContext.Add(new TheRowClass(theMainCollection));

We have two items in the ObservableCollection<TheRowClass>, each item has two properties of type CollectionViewSource for a total of four CollectionViewSource objects – one for each cell.  We are passing the main collection into the constructor and using it as the Source property for all of our CollectionViewSources.  All we have left to do is add a filter to each of these collections.  The filter we are adding is very simple:

if TestClass.SomeName contains the letter A and TestClass.SomeValue contains the number 1 display the item in row 1, column 1

if TestClass.SomeName contains the letter A and TestClass.SomeValue contains the number 2 display the item in row 1, column 2

if TestClass.SomeName contains the letter B and TestClass.SomeValue contains the number 1 display the item in row 2, column 1

if TestClass.SomeName contains the letter B and TestClass.SomeValue contains the number 2 display the item in row 2, column 2

Here is the code to pull that off:

Code Snippet

1.             AddFilter(theDataContext[0].Column1, 1, 1);
2.             AddFilter(theDataContext[0].Column2, 1, 2);
3.             AddFilter(theDataContext[1].Column1, 2, 1);
4.             AddFilter(theDataContext[1].Column2, 2, 2);

And the AddFilter method:

Code Snippet

1.         private void AddFilter(CollectionViewSource cvs, int row, int column)
2.         {
3.             cvs.Filter += delegate(object o, FilterEventArgs eArgs)
4.             {
5.                 //Simple filter saying if column = 1 look for an A in the SomeName property
6.                 //Else look for a B.  If we are in Row 1 look for a 1 in the SomeValue property
7.                 //Else look for a 2
8.                 string columnFilter;
9.                 if (row == 1)
10.                     columnFilter = "A";
11.                 else
12.                     columnFilter = "B";
13.                 if ((eArgs.Item as TestClass).SomeValue.ToString().Contains(column.ToString()) && (eArgs.Item as TestClass).SomeName.Contains(columnFilter))
14.                     eArgs.Accepted = true;
15.                 else
16.                     eArgs.Accepted = false;
17.             };
19.         \

Run the app, notice that the item with SomeName=’AB’ and SomeValue=21 is in all of the cells, this is because that item satisfies the filter criteria for each CollectionViewSource in each cell.  Very cool. 

 

Add the letter ‘A’ to the first textbox and 111 to the second textbox and click the add button.  Notice that an item is added to column 1 and row 1 of the grid without doing anything more than making a call to Collection.Add.

Play around with a few more combinations and see how the grid updates.

Now let’s look at the bottom 3 buttons, the first button changes the SomeName value of the last item in the main collection to “B”.  Here is the event handler:

theMainCollection[theMainCollection.Count-1].SomeName = "B";

Again, add the letter ‘A’ to the first textbox and 111 to the second textbox and click the add button.  Now click the Change Name button.  Notice that nothing happens.  I assure The item has changed.

Now click the Change Value button.  Notice that the last item in row 1 cell 1 has changed, the value has become 25.

We changed the SomeValue property to 25 in the button click event handler.   Here is the event handler:

theMainCollection[theMainCollection.Count - 1].SomeValue = 25;

Why did SomeValue change while SomeName remained the same?  Take a look at the TestClass and you will notice that it implements the INotifyPropertyChanged interface and in the SomeValue setter we call NotifyPropertyChanged which raises an event.  Silverlight has a Pub/Sub eventing system that the UI uses to determine when to update databound objects.  With just a few lines of code we were able to wire TestClass into this eventing system and force the UI to update anytime our SomeValue property changes.

This is all fine and good, call that event for SomeName and we are good to go, well…almops.  We still have a problem with the UI!  The last item in cell 1 column 1 is displaying an incorrect SomeName value, and since we changed SomeValue to 25 it should no longer be visible in this cell.  What is happening is that the Filter on the collection view source is applied when an item is added to or removed from the collection but NOT when an item changes.  To manually reapply the filter call CollectionViewSource.View.Refresh (for each CollectionViewSource) and you will see the grid display correctly.  Click the Refresh CVS button to see this functionality in action:

 

Below is all of the source code.

Click here to see how to sort the grid cells.

Here is the XAML:

Code Snippet

1. <UserControl xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data" x:Class="SilverlightApplication1.MainPage"
2.    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3.    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4.    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
5.    mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480">
6.     <UserControl.Resources>
8.     </UserControl.Resources>
9.   <Grid x:Name="LayoutRoot">
10.         <StackPanel Orientation="Vertical">
11.             <data:DataGrid x:Name="TheMainDataGrid"   AutoGenerateColumns="False" ItemsSource="{Binding}" HeadersVisibility="Column">
12.                 <data:DataGrid.Columns>
13.                     <data:DataGridTemplateColumn Header="Column 1">
14.                         <data:DataGridTemplateColumn.CellTemplate>
15.                             <DataTemplate>
16.                                 <ListBox MinHeight="15" ItemsSource="{Binding Path=Column1.View}" >
17.                                     <ListBox.ItemTemplate>
18.                                         <DataTemplate>
19.                                             <StackPanel Orientation="Horizontal">
20.                                                 <TextBlock Margin="10" Text="{Binding Path=SomeName}" />
21.                                                 <TextBlock Margin="10" Text="{Binding SomeValue}" />
22.                                             </StackPanel>
23.                                         </DataTemplate>
24.                                     </ListBox.ItemTemplate>
25.                                 </ListBox>
26.                             </DataTemplate>
27.                         </data:DataGridTemplateColumn.CellTemplate>
28.                     </data:DataGridTemplateColumn>
29.                     <data:DataGridTemplateColumn Header="Column 2">
30.                         <data:DataGridTemplateColumn.CellTemplate>
31.                             <DataTemplate>
32.                                 <ListBox MinHeight="15" ItemsSource="{Binding Path=Column2.View}" >
33.                                     <ListBox.ItemTemplate>
34.                                         <DataTemplate>
35.                                             <StackPanel Orientation="Horizontal">
36.                                                 <TextBlock Margin="10" Text="{Binding SomeName}" />
37.                                                 <TextBlock Margin="10" Text="{Binding SomeValue}" />
38.                                             </StackPanel>
39.                                         </DataTemplate>
40.                                     </ListBox.ItemTemplate>
41.                                 </ListBox>
42.                             </DataTemplate>
43.                         </data:DataGridTemplateColumn.CellTemplate>
44.                     </data:DataGridTemplateColumn>
45.                 </data:DataGrid.Columns>
46.             </data:DataGrid>
47.             <StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
48.                 <TextBlock Margin="5" Text="Name:"/>
49.                 <TextBox x:Name="tbNAme" Margin="5" Width="100"></TextBox>
50.                 <TextBlock Margin="5" Width="100" Text="Value:"/>
51.                 <TextBox x:Name="tbValue" Margin="5" Width="100"></TextBox>
52.                 <Button x:Name="AddButton" Margin="5" Content="Add" Click="AddButton_Click"/>
53.             </StackPanel>
54.             <StackPanel HorizontalAlignment="Left">
55.                 <Button x:Name="ChangeNameButton" Width="100" Content="Change Name" Click="ChangeNameButton_Click"/>
56.                 <Button x:Name="ChangeValueButton" Width="100" Content="Change Value" Click="ChangeValueButton_Click"/>
57.                 <Button x:Name="refresh" Width="100" Content="Refresh CVS" Click="refresh_Click" />
58.             </StackPanel>
59.         </StackPanel>
60.   </Grid>
61. </UserControl>

Here is the code behind:

Code Snippet

1. using System.Collections.ObjectModel;
2. using System.Windows.Controls;
3. using System.Windows.Data;
5. namespace SilverlightApplication1
6. {
7.     public partial class MainPage : UserControl
8.     {
9.         ObservableCollection<TestClass> theMainCollection ;
10.         ObservableCollection<TheRowClass> theDataContext;
11.         public MainPage()
12.         {
13.             InitializeComponent();
14.             theMainCollection = new ObservableCollection<TestClass>()
15.                 { new TestClass() {SomeName="A",SomeValue=11},
16.                     new TestClass() {SomeName="A",SomeValue=12},
17.                     new TestClass() {SomeName="B",SomeValue=13},
18.                     new TestClass() {SomeName="B",SomeValue=14},
19.                     new TestClass() {SomeName="AB",SomeValue=21},
20.                     new TestClass() {SomeName="BC",SomeValue=22},
21.                     new TestClass() {SomeName="AB",SomeValue=23},
22.                     new TestClass() {SomeName="BC",SomeValue=24}
23.                 };
24.           
25.             theDataContext = new ObservableCollection<TheRowClass>();
26.             theDataContext.Add(new TheRowClass(theMainCollection));
27.             theDataContext.Add(new TheRowClass(theMainCollection));
29.             TheMainDataGrid.DataContext = theDataContext;
30.             AddFilter(theDataContext[0].Column1, 1, 1);
31.             AddFilter(theDataContext[0].Column2, 1, 2);
32.             AddFilter(theDataContext[1].Column1, 2, 1);
33.             AddFilter(theDataContext[1].Column2, 2, 2);
34.             
36.         }
37.         private void AddFilter(CollectionViewSource cvs, int row, int column)
38.         {
39.             cvs.Filter += delegate(object o, FilterEventArgs eArgs)
40.             {
41.                 //Simple filter saying if column = 1 look for an A in the SomeName property
42.                 //Else look for a B.  If we are in Row 1 look for a 1 in the SomeValue property
43.                 //Else look for a 2
44.                 string columnFilter;
45.                 if (column == 1)
46.                     columnFilter = "A";
47.                 else
48.                     columnFilter = "B";
49.                 if ((eArgs.Item as TestClass).SomeValue.ToString().Contains(column.ToString()) && (eArgs.Item as TestClass).SomeName.Contains(columnFilter))
50.                     eArgs.Accepted = true;
51.                 else
52.                     eArgs.Accepted = false;
53.             };
55.         }
57.         private void AddButton_Click(object sender, System.Windows.RoutedEventArgs e)
58.         {
59.             TestClass tc = new TestClass();
60.             tc.SomeName = tbNAme.Text;
61.             tc.SomeValue = int.Parse(tbValue.Text);
62.             theMainCollection.Add(tc);
63.         }
65.         private void ChangeNameButton_Click(object sender, System.Windows.RoutedEventArgs e)
66.         {
67.             theMainCollection[theMainCollection.Count-1].SomeName = "B";
68.         }
70.         private void ChangeValueButton_Click(object sender, System.Windows.RoutedEventArgs e)
71.         {
72.             theMainCollection[theMainCollection.Count - 1].SomeValue = 25;
73.         }
75.         private void refresh_Click(object sender, System.Windows.RoutedEventArgs e)
76.         {
77.             theDataContext[0].Column1.View.Refresh();
78.             theDataContext[1].Column1.View.Refresh();
79.             theDataContext[0].Column2.View.Refresh();
80.             theDataContext[1].Column2.View.Refresh();
81.         }
82.     }
83. }

Here is the TestClass Code:

Code Snippet

1. using System;
2. using System.ComponentModel;
4. namespace SilverlightApplication1
5. {
6.     public class TestClass:INotifyPropertyChanged
8.     {
9.         public String SomeName { get; set; }
11.         private int _someValue;
12.         public int SomeValue
13.         {
14.             get
15.             {
16.                 return _someValue;
17.             }
18.             set
19.             {
20.                 if (value != this._someValue)
21.                 {
22.                     this._someValue = value;
23.                     NotifyPropertyChanged("SomeValue");
24.                 }
25.             }
26.         }
28.         #region INotifyPropertyChanged Members
30.         public event PropertyChangedEventHandler PropertyChanged;
34.         #endregion
36.         private void NotifyPropertyChanged(String info)
37.         {
38.             if (PropertyChanged != null)
39.             {
40.                 PropertyChanged(this, new PropertyChangedEventArgs(info));
41.             }
42.         }
43.     }
44. }

Here is TheRowClass:

Code Snippet

1. using System.Windows.Data;
2. using System.Collections;
4. namespace SilverlightApplication1
5. {
6.     public class TheRowClass
7.     {
8.         public TheRowClass(IEnumerable source)
9.         {
10.             Column1 = new CollectionViewSource();
11.             Column1.Source = source;
12.             Column2 = new CollectionViewSource();
13.             Column2.Source = source;
14.         }
15.         public CollectionViewSource Column1 { get; set; }
16.         public CollectionViewSource Column2 { get; set; }
17.     }
18. }

Technorati Tags: Silverlight 3,CollectionViewSource,ObservableCollection,DataGrid