Enter the ICollectionView.  “You can think of a collection view as a layer on top of a binding source collection that allows you to navigate and display the collection based on sort, filter, and group queries, all without having to manipulate the underlying source collection itself.”, says the MSDN documentation. The ICollectionView supports filtering, sorting, grouping, selection, and navigation.

Now the most common way this is used is by creating your collection, populating it with data, then creating an ICollectionView instance from your collection, and then start sorting, filtering, grouping, etc.  The following code show some examples of how to use the ICollectionView.

//get the view

List<MyObject> myList = new List<MyObject>();   

ICollectionView view = CollectionViewSource.GetDefaultView(myList);

//filtering

view.Filter = delegate(object item)

{return item.Contains(searchText);};

//sorting

view.SortDescriptions.Add(new SortDescription("LastName", direction));

//grouping

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

//selection

view.CurrentItem

But I didn’t want to do this every time I had a collection of data I wanted to navigate. I wanted a single generic collection class that encapsulated all this functionality. So I decided to extend the ObservableCollection to allow for this functionality. So the first thing I need to do is create my class, inherit from ObservableCollection, and then create my constructors.

public class MyObservableCollection<T> : ObservableCollection<T>

{

    public MyObservableCollection(List<T> list)

        : base(list)

    {

    }

    public MyObservableCollection(IEnumerable<T> collection)

        : base(collection)

    {

    }

}

Next I want to create my method to return my instance of ICollectionView.

private System.ComponentModel.ICollectionView GetDefaultView()

{

    return System.Windows.Data.CollectionViewSource.GetDefaultView(this);

}

Now, lets create a property to retrieve the currently selected item in the list.

public int CurrentPosition

{

    get

    {

        return GetDefaultView().CurrentPosition;

    }

}

Now lets create our four methods for navigating the items in the collection.

public void MoveFirst()

{

    GetDefaultView().MoveCurrentToFirst();

}

public void MovePrevious()

{

    GetDefaultView().MoveCurrentToPrevious();

}

public void MoveNext()

{

    GetDefaultView().MoveCurrentToNext();

}

public void MoveLast()

{

    GetDefaultView().MoveCurrentToLast();

}

Now, lets use our new collection. First start off by creating and instance of your custom collection.

MyObservableCollection<MyObject> ProgressItemsList = new MyObservableCollection<MyObject>(data);

In this example I am using a WPF Ribbon to hold my navigation controls, and commanding to execute the navigation methods. The center label maintains the current position and the count of the number of items in the collection.

So now, when I click the Next button I first need to check whether or not I can move to the next record in the command’s CanExecute event.

private bool CanMoveNext(object parameter)

{

    bool canExecute = false;

    if (ProgressItemsList != null)

    {

        int currentPosition = ProgressItemsList.CurrentPosition;

        int lastIndex = ProgressItemsList.Count - 1;

        canExecute = currentPosition < lastIndex;

    }

    return canExecute;

}

If I can move to the next record, then execute the Execute method of the command.

private void MoveNext(object sender)

{

    ProgressItemsList.MoveNext();

}

That is it, and because this is an ObservableCollection, all the changes are notified back to the UI for you automatically. Now you can extend your custom collection even more to customize your sorting, filtering and grouping.

First lets start with how to get started with multithreading in WPF. If you don’t want to read how this actually works and just want to get the source and start playing ,here is the Source Code.

Your WPF application may need to perform intensive tasks that consume large amounts of time. Executing these tasks on a separate thread allows you to maintain the responsiveness of the UI while the task is performed. Enter the BackgroundWorker. The BackgroundWorker is the recommended way to run time consuming tasks on a separate, dedicated thread, leaving the UI responsive.

Running a Background Process

The RunWorkerAsync method starts the execution of the background process by raising the DoWork event. The code in the DoWork event handler is executed on a separate thread.

int maxRecords = 1000;

BackgroundWorker worker = new BackgroundWorker();

worker.DoWork += delegate(object s, DoWorkEventArgs args)

{

    for (int x = 1; x < maxRecords; x++)

    {

        System.Threading.Thread.Sleep(10);

    }

};

worker.RunWorkerAsync();

Providing Parameters to the Process

Your background process may required one or more parameters, such as the address of a file to download. You can provide a parameter in the RunWorkerAsync method that will be available as the Argument property in the DoWork event handler.

BackgroundWorker worker = new BackgroundWorker();

worker.DoWork += delegate(object s, DoWorkEventArgs args)

{

    string path = (string)args.Argument;

    //do something

};

worker.RunWorkerAsync("c:\\myFile.txt");

Returning a Value from the Process

You might want to return a value from a background process, such as a result from a calculation. You can return a value by setting the Result property of the DoWorkEventArgs in the DoWork event handler. Then, this value can be retrieved from the Result property of the RunWorkerCompletedEventArgs parameter int the RunWorkerCompleted event handler.

BackgroundWorker worker = new BackgroundWorker();

worker.DoWork += delegate(object s, DoWorkEventArgs args)

{

    args.Result = CalculationMethod();

};

worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)

{

    object result = args.Result;

};

worker.RunWorkerAsync();

Cancelling the Background Process

You may want to allow the user to cancel a long running process. In order to support this you must first set the WorkerSupportsCancellation to true. You call the CancelAsync mtehod to attempt to cancel the process. When you call the CancelAsync method it sets the CancellationPending property of the BackgroundWorker to true. Then you must check for the value of the CancellationPending property in the DoWork event handler, and if it is true, set the Cancel property of the DoWorkEventArgs parameter to true.

int maxRecords = 1000;

BackgroundWorker worker = new BackgroundWorker();

worker.WorkerSupportsCancellation = true;

worker.DoWork += delegate(object s, DoWorkEventArgs args)

{

    for (int x = 1; x < maxRecords; x++)

    {

        //check if there is a cancelat

        if (worker.CancellationPending)

        {

            args.Cancel = true;

            return;

        }

        System.Threading.Thread.Sleep(10);

    }

};

worker.RunWorkerAsync();

Reporting the Progress of a Background Process

You can report the progress of a background process back to the primary thread by calling the ReportProgress method. This method raises the ProgressChanged event and allows you to pass a parameter that indicated the percentage of progress that has been completed. Make sure you set the WorkerReportsProgess property of the BackgroundWorker to true.

int maxRecords = 1000;

BackgroundWorker worker = new BackgroundWorker();

worker.WorkerReportsProgress = true;

worker.DoWork += delegate(object s, DoWorkEventArgs args)

{

    for (int x = 1; x < maxRecords; x++)

    {

        System.Threading.Thread.Sleep(10);

        worker.ReportProgress(Convert.ToInt32(((decimal)x / (decimal)maxRecords) * 100));

    }

};

worker.ProgressChanged += delegate(object s, ProgressChangedEventArgs args)

{

    int percentage = args.ProgressPercentage;

};

worker.RunWorkerAsync();

Using the Dispatcher to Access Controls on Another Thread

At times, you may want to change the user interface from a worker thread. For example, you may want to enable or disable buttons, or show a modal ProgressBar that provides more detailed progress information than is allowed by the ReportProgress method. The WPF threading model provides the Dispatcher class for cross thread calls. By using the Dispatcher, you can safely update your user interface from background worker threads.

You can get a reference to the Dispacther object for a UI element from its Dispatcher property.

System.Windows.Threading.Dispatcher aDisp = Button1.Dispatcher;

Dispatcher provides two main methods that you will use; Invoke and BeginInvoke. Both methods allows you to call a method safely on the UI thread. The BeginInvoke method allows you to call a method asynchronously, and the Invoke method allows you to call a method synchronously.

Putting It All Together

Lets say I have a time consuming task in my application.  I want to execute this time consuming task on a background thread, but I also want to show a modal progress dialog that shows a message and the percent of the completed task. I also want to allow the user to cancel the process at anytime. So the first thing I need to do is create my progress dialog window that has a label to display my percent completed, a progress bar to graphically show the progress, and a cancel button so the user can cancel the process.

<Window x:Class="MultiThreading.ProgressDialog"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    Title="ProgressDialog" Height="115" Width="300" WindowStyle="ToolWindow" WindowStartupLocation="CenterOwner">

    <Grid>

        <StackPanel>

            <Label x:Name="lblProgress" Content="0%"/>

            <ProgressBar x:Name="progress" Height="25" IsIndeterminate="False"></ProgressBar>

            <StackPanel Orientation="Horizontal" HorizontalAlignment="Right">

                <Button x:Name="btnCancel" Click="btnCancel_Click">Cancel</Button>

            </StackPanel>

        </StackPanel>

    </Grid>

</Window>

I need to expose two properties; ProgressText to set my label, and ProgressValue to set the progress bar value. I also need to expose an event so when the user hits the cancel button the process will stop.

   1: public string ProgressText

   2: {

   3:     set

   4:     {

   5:         this.lblProgress.Content = value;

   6:     }

   7: }

   8:  

   9: public int ProgressValue

  10: {

  11:     set

  12:     {

  13:         this.progress.Value = value;

  14:     }

  15: }

  16:  

  17: public event EventHandler Cancel = delegate { };

  18:  

  19: private void btnCancel_Click(object sender, RoutedEventArgs e)

  20: {

  21:     Cancel(sender, e);

  22: }

Now on my main application I need a button to execute this long running process and show my progress dialog.

<Button Height="23" Name="btnDispacther" Click="btnDispacther_Click">Using Dispatcher</Button>

Now lets code the background worker.

//our bg worker

BackgroundWorker worker;

//our progress dialog window

ProgressDialog pd;

private void btnDispacther_Click(object sender, RoutedEventArgs e)

{

    int maxRecords = 1000;

    pd = new ProgressDialog();

    //hook into the cancel event

    pd.Cancel += CancelProcess;

    //get our dispatcher

    System.Windows.Threading.Dispatcher pdDispatcher = pd.Dispatcher;

    //create our background worker and support cancellation

    worker = new BackgroundWorker();

    worker.WorkerSupportsCancellation = true;

    worker.DoWork += delegate(object s, DoWorkEventArgs args)

    {

        for (int x = 1; x < maxRecords; x++)

        {

            if (worker.CancellationPending)

            {

                args.Cancel = true;

                return;

            }

            System.Threading.Thread.Sleep(10);

            //create a new delegate for updating our progress text

            UpdateProgressDelegate update = new UpdateProgressDelegate(UpdateProgressText);

            //invoke the dispatcher and pass the percentage and max record count

            pdDispatcher.BeginInvoke(update, Convert.ToInt32(((decimal)x / (decimal)maxRecords) * 100), maxRecords);

        }

    };

    worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)

    {

        pd.Close();

    };

    //run the process then show the progress dialog

    worker.RunWorkerAsync();

    pd.ShowDialog();

}

//our delegate used for updating the UI

public delegate void UpdateProgressDelegate(int percentage, int recordCount);

//this is the method that the deleagte will execute

public void UpdateProgressText(int percentage, int recordCount)

{

    //set our progress dialog text and value

    pd.ProgressText = string.Format("{0}% of {1} Records", percentage.ToString(), recordCount);

    pd.ProgressValue = percentage;

}

void CancelProcess(object sender, EventArgs e)

{

    //cancel the process

    worker.CancelAsync();

}

That’s it. See, I told you it wasn’t that bad. Now that you have a basic understanding of multithreading, try to see how creative you can get on implementing it in your WPF application.

public class SortableObservableCollection<T> : ObservableCollection<T>
{
  public SortableObservableCollection(List<T> list)
     : base(list)
  {
  }

  public SortableObservableCollection(IEnumerable<T> collection)
     : base(collection)
  {
  }

  public void Sort<TKey>(Func<T, TKey> keySelector, System.ComponentModel.ListSortDirection direction)
  {
     switch (direction)
     {
        case System.ComponentModel.ListSortDirection.Ascending:
           {
              ApplySort(Items.OrderBy(keySelector));
              break;
           }
        case System.ComponentModel.ListSortDirection.Descending:
           {
              ApplySort(Items.OrderByDescending(keySelector));
              break;
           }
     }
  }

  public void Sort<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer)
  {
     ApplySort(Items.OrderBy(keySelector, comparer));
  }

  private void ApplySort(IEnumerable<T> sortedItems)
  {
     var sortedItemsList = sortedItems.ToList();

     foreach (var item in sortedItemsList)
     {
        Move(IndexOf(item), sortedItemsList.IndexOf(item));
     }
  }
}

Now we can create a new SortableObservableCollection<T> and sort it either direction without having to return a new IOrderedEnumerable and rebind the DataContext/ItemsSource.

//sort ascending
MySortableList.Sort(x => x.Name, ListSortDirection.Ascending);

//sort descending
MySortableList.Sort(x => x.Name, ListSortDirection.Descending);

When you sort your collection, the UI is notified that something has changed and updates itself automatically.