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