When I started on this project I honestly did not understand how complex it was. When you implement filtering one of the first things you need to decide is what sort of filtering expressions your code will accept. I opted for a sub-set of the DataView.RowFilter format guidelines. I limited my operators to <,> and = to keep things simple. My idea was to give you a jumping off point for more complex filtering. In addition, I opted to only filter types that implement IComparable. Attempts to filter other types will result in an exception. A complication is that I started with a list that already supports single-column sorting. This means that the sorting and filtering implementations need to play nice together. For example, a sorted collection that is later filtered should remain in the same sorted order, or if a list is sorted and filtered, and the sort is removed, it should remain filtered.

Following is some of the code from the paper with a brief explanation. If you want to stop reading this post and go straight to the paper and code, you can find it here.

The are only three APIs exposed by IBindingListView that you need to implement for filtering:

• SupportsFiltering property
• Filter property
• RemoveFilter method

SupportsFiltering is simple. For my implementation this always return true. The get for the Filter property is simple as well. I simply return the value of the backing private field. The filteret is where a lot of heavy lifting happens. When the Filter property is set, the filter is applied to the collection and only items meeting the filter criteria are returned. This means you need to do a lot of work in the set:

• Cache the existing collection in case the filter is removed
• Check for null or empty string; this means the filter has been removed and you need to restore the original collection
• Parse the filter expression to determine if its in the correct format
• Apply the filter, and return on list values that meet the filter criteria
• Reapply the sort if necessary

These steps are further complicated by multi-column filtering.

Here's the code from my Filter set:

set
{
    if (filterValue == value) return;

    // If the value is not null or empty, but doesn't
    // match expected format, throw an exception.
    if (!string.IsNullOrEmpty(value) &&
        !Regex.IsMatch(value,
        BuildRegExForFilterFormat(), RegexOptions.Singleline))
        throw new ArgumentException("Filter is not in " +
              "the format: propName[<>=]'value'.");

    //Turn off list-changed events.
    RaiseListChangedEvents = false;

    // If the value is null or empty, reset list.
    if (string.IsNullOrEmpty(value))
        ResetList();
    else
    {
        int count = 0;
        string[] matches = value.Split(new string[] { " AND " },
            StringSplitOptions.RemoveEmptyEntries);

        while (count < matches.Length)
        {
            string filterPart = matches[count].ToString();

            // Check to see if the filter was set previously.
            // Also, check if current filter is a subset of
            // the previous filter.
            if (!String.IsNullOrEmpty(filterValue)
                    && !value.Contains(filterValue))
                ResetList();

            // Parse and apply the filter.
            SingleFilterInfo filterInfo = ParseFilter(filterPart);
            ApplyFilter(filterInfo);
            count++;
        }
    }
    // Set the filter value and turn on list changed events.
    filterValue = value;
    RaiseListChangedEvents = true;
    OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}

As I said previously, there's a lot happening here. First I check to see if the filter value has changed, if not, I simply return. Then I check for the correct filter format by calling BuildRegExForFilterFormat. Following is the code for this method:

// Build a regular expression to determine if
// filter is in correct format.
public static string BuildRegExForFilterFormat()
{
    StringBuilder regex = new StringBuilder();

    // Look for optional literal brackets,
    // followed by word characters or space.
    regex.Append(@"\[?[\w\s]+\]?\s?");

    // Add the operators: > < or =.
    regex.Append(@"[><=]");

    //Add optional space followed by optional quote and
    // any character followed by the optional quote.
    regex.Append(@"\s?'?.+'?");

   return regex.ToString();
}

If the filter is in the correct format I know I'm in business and turn off change notification so I can manipulate the contents of the list without notifying bound controls.

Next I check for null or an empty string. One of these values indicates the filter has been removed and I need to reset the contents of the list to the unfiltered content. Following is the code for the ResetList method. Once I restore the original list, I reapply the sort, if the list is sorted.

private void ResetList()
{
    this.ClearItems();
    foreach (T t in originalListValue)
        this.Items.Add(t);
    if (IsSortedCore)
        ApplySortCore(SortPropertyCore, SortDirectionCore);
}

Next I split the filter at "AND" to separate the parts of a multi-column filter. I loop through each filter part and parse and apply the filter to the list. I do some checking to see if the current filter part is a subset of a previous filter indicating a portion of a multi-column filter is being removed. In this case, I reset the list before I apply the filter. I created the SingleFilterInfo and FilterOperator enums to aid in parsing and filtering. The actual parsing and filtering are done by the ParseFilter and ApplyFilter methods. Following is the code for  these methods along with the enums and supporting methods.

internal void ApplyFilter(SingleFilterInfo filterParts)
{
    List<T> results;

    // Check to see if the property type we are filtering by implements
    // the IComparable interface.
    Type interfaceType =
        TypeDescriptor.GetProperties(typeof(T))[filterParts.PropName]
        .PropertyType.GetInterface("IComparable");

    if (interfaceType == null)
        throw new InvalidOperationException("Filtered property" +
        " must implement IComparable.");

    results = new List<T>();

    // Check each value and add to the results list.
    foreach (T item in this)
    {
        if (filterParts.PropDesc.GetValue(item) != null)
        {
            IComparable compareValue =
                filterParts.PropDesc.GetValue(item) as IComparable;
            int result =
                compareValue.CompareTo(filterParts.CompareValue);
            if (filterParts.OperatorValue ==
                FilterOperator.EqualTo && result == 0)
                results.Add(item);
            if (filterParts.OperatorValue ==
                FilterOperator.GreaterThan && result > 0)
                results.Add(item);
            if (filterParts.OperatorValue ==
                FilterOperator.LessThan && result < 0)
                results.Add(item);
        }
    }
    this.ClearItems();
    foreach (T itemFound in results)
        this.Add(itemFound);
}

internal SingleFilterInfo ParseFilter(string filterPart)
{
    SingleFilterInfo filterInfo = new SingleFilterInfo();
    filterInfo.OperatorValue = DetermineFilterOperator(filterPart);

    string[] filterStringParts =
        filterPart.Split(new char[] { (char)filterInfo.OperatorValue });

    filterInfo.PropName =
        filterStringParts[0].Replace("[", "").
        Replace("]", "").Replace(" AND ", "").Trim();

    // Get the property descriptor for the filter property name.
    PropertyDescriptor filterPropDesc =
        TypeDescriptor.GetProperties(typeof(T))[filterInfo.PropName];

    // Convert the filter compare value to the property type.
    if (filterPropDesc == null)
        throw new InvalidOperationException("Specified property to " +
            "filter " + filterInfo.PropName +
            " on does not exist on type: " + typeof(T).Name);

    filterInfo.PropDesc = filterPropDesc;

    string comparePartNoQuotes = StripOffQuotes(filterStringParts[1]);
    try
    {
        TypeConverter converter =
            TypeDescriptor.GetConverter(filterPropDesc.PropertyType);
        filterInfo.CompareValue =
            converter.ConvertFromString(comparePartNoQuotes);
    }
    catch (NotSupportedException)
    {
        throw new InvalidOperationException("Specified filter" +
            "value " + comparePartNoQuotes + " can not be converted" +
            "from string. Implement a type converter for " +
            filterPropDesc.PropertyType.ToString());
    }
    return filterInfo;
}

internal FilterOperator DetermineFilterOperator(string filterPart)
{
    // Determine the filter's operator.
    if (Regex.IsMatch(filterPart, "[^>^<]="))
        return FilterOperator.EqualTo;
    else if (Regex.IsMatch(filterPart, "<[^>^=]"))
        return FilterOperator.LessThan;
    else if (Regex.IsMatch(filterPart, "[^<]>[^=]"))
        return FilterOperator.GreaterThan;
    else
        return FilterOperator.None;
}

internal static string StripOffQuotes(string filterPart)
{
    // Strip off quotes in compare value if they are present.
    if (Regex.IsMatch(filterPart, "'.+'"))
    {
        int quote = filterPart.IndexOf('\'');
        filterPart = filterPart.Remove(quote, 1);
        quote = filterPart.LastIndexOf('\'');
        filterPart = filterPart.Remove(quote, 1);
        filterPart = filterPart.Trim();
    }
    return filterPart;
}

      
public struct SingleFilterInfo
{
    internal string PropName;
    internal PropertyDescriptor PropDesc;
    internal Object CompareValue;
    internal FilterOperator OperatorValue;
}

// Enum to hold filter operators. The chars
// are converted to their integer values.
public enum FilterOperator
{
    EqualTo = '=',
    LessThan = '<',
    GreaterThan = '>',
    None = ' '
}

There's a lot in my paper that I am leaving out of this post. Hopefully, I've whet your appetite and you'll download the code and paper. The paper is included as part of the zip file. You can get it all here: Implementing Filtering for Windows Forms Data Binding. Enjoy!

In case you are not familiar with this behavior, a watermark is typically a bit of help text that appears in a text box when it is "empty". For example, the search box in the upper-right corner of IE7 says "Live Search" by default, and the MSDN Library search box says "Search MSDN with Live Search". Typically, the text is in italics or is grey to differentiate it from an ordinary textbox value. As soon as you click in the text box, the help text disappears so that you can type your search terms without distraction.

This seemed like an interesting challenge, so I implemented the DataGridViewWatermarkCell and DataGridViewWatermarkColumn classes shown at the end of this post. All the action is in the cell's Paint method. The main bit of code just sets the formattedValue parameter in the Paint method to the watermark text and tweaks the cell styles.

Of course, the watermark code is only used at run time when there is no cell value, the watermark text has been set, and the cell is not in edit mode. The first part of the if statement in the cell Paint method prevents painting issues in the designer:

if ((OwningColumn.Site == null || !OwningColumn.Site.DesignMode) && ...

It appears that the OwningColumn only has a Site in design mode, but I included the DesignMode check to make the code more readable. The rest of the if statement checks for edit mode (but only if the cell's row is not shared - in which case RowIndex == -1), checks whether the watermark text has been set, and checks whether there is a cell value (using GetValue in case the row is shared).

There are a few other tasks needed to make the code usable in the Visual Studio designer. The column class, for example, is simply a column specialized to use watermark cells by default, and enables you to use the designer to add a watermark column and set the WatermarkText property. Like all specialized DataGridView column types, setting the property at the column level propogates the value to the cell template and to all existing cells in that column. You can override the column value for individual cells by setting the cell WatermarkText property only after you set the column property.

Another important designer consideration is the cell's Clone method override. You must override Clone to copy the WatermarkText value. If you leave out the Clone method, you can change the column WatermarkText value in the designer, but the value won't stick. Note that the column does not have to override Clone because the column always gets its WatermarkText value from the template cell. The cell's Clone method does the work for both the cell and the column.

So there you have it! Clearly, this is a primitive implementation, but it should give you the basic idea if you want to take it further. For example, you might want to make more of the watermark properties (such as styles) available to the client programmer, or allow an Image watermark.

Enjoy!

using System;

using System.ComponentModel;

using System.Drawing;

using System.Windows.Forms;

namespace DataGridViewWatermark

{

    public class DataGridViewWatermarkColumn : DataGridViewTextBoxColumn

    {

        public DataGridViewWatermarkColumn()

        {

            CellTemplate = new DataGridViewWatermarkCell();

        }

        public String WatermarkText

        {

            get

            {

                if (((DataGridViewWatermarkCell)CellTemplate) == null)

                {

                    throw new InvalidOperationException("cell template required");

                }

                return ((DataGridViewWatermarkCell)CellTemplate).WatermarkText;

            }

            set

            {

                if (this.WatermarkText != value)

                {

                    ((DataGridViewWatermarkCell)CellTemplate).WatermarkText = value;

                    if (this.DataGridView != null)

                    {

                        DataGridViewRowCollection dataGridViewRows =

                            this.DataGridView.Rows;

                        int rowCount = dataGridViewRows.Count;

                        for (int rowIndex = 0; rowIndex < rowCount; rowIndex++)

                        {

                            DataGridViewRow dataGridViewRow =

                                dataGridViewRows.SharedRow(rowIndex);

                            DataGridViewWatermarkCell cell =

                                dataGridViewRow.Cells[this.Index]

                                as DataGridViewWatermarkCell;

                            if (cell != null)

                            {

                                cell.WatermarkText = value;

                            }

                        }

                    }

                }

            }

        }

    }

    public class DataGridViewWatermarkCell : DataGridViewTextBoxCell

    {

        private String watermarkTextValue;

        public String WatermarkText

        {

            get { return watermarkTextValue; }

            set { watermarkTextValue = value; }

        }

        public override object Clone()

        {

            DataGridViewWatermarkCell cell = (DataGridViewWatermarkCell)base.Clone();

            cell.WatermarkText = this.WatermarkText;

            return cell;

        }

        protected override void Paint(Graphics graphics, Rectangle clipBounds,

            Rectangle cellBounds, int rowIndex, DataGridViewElementStates cellState,

            object value, object formattedValue, string errorText,

            DataGridViewCellStyle cellStyle,

            DataGridViewAdvancedBorderStyle advancedBorderStyle,

            DataGridViewPaintParts paintParts)

        {
            if ((OwningColumn.Site == null || !OwningColumn.Site.DesignMode) &&
                (RowIndex < 0 || !IsInEditMode) && !String.IsNullOrEmpty(WatermarkText) &&
                (GetValue(rowIndex) == null || GetValue(rowIndex) == DBNull.Value))

            {

                cellStyle.Font = new Font(cellStyle.Font, FontStyle.Italic);

                cellStyle.ForeColor = Color.Gray;

                formattedValue = WatermarkText;

            }

            base.Paint(graphics, clipBounds, cellBounds, rowIndex,

                cellState, value, formattedValue, errorText,

                cellStyle, advancedBorderStyle, paintParts);

        }

    }

}

However, there is a peculiarity in WPF that prevents things from just working without a small adjustment. After authentication using CAS, the static Thread.CurrentPrincipal property gets set to an instance of ClientRolePrincipal. Internally, CAS checks for this value to determine whether a user is still logged in. Unfortunately, in WPF, Thread.CurrentPrincipal reverts to the default value (a GenericPrincipal instance) some time after the Window.Loaded event.

For details, see this forum post. The fix for CAS is simple, however: just add the following line of code after your Membership.ValidateUser call in your App.Startup or Window.Loaded event handler:

AppDomain.CurrentDomain.SetThreadPrincipal(Thread.CurrentPrincipal);

At this point, Thread.CurrentPrincipal is still set to the ClientRolePrincipal object. The SetThreadPrincipal method call is what makes it stay there.

For the simple filtering, I start with my generic implementation of searching and sorting demonstrated in my article published in summer 2006. I then use the FindCore method to find matches for the filter value. The code listing is lengthy so I've posted the complete listing here.

That said; I want to walk you through some of the code. The filtering expression my code handles follows a subset of the guidelines established by the DataColumn.Expression property. I'll look for a property name followed by an equals followed by the filter value, typically in quotes. For example, LastName="Smith". In this simple example, I am only concerned with values equal to the filter value. My upcoming article will cover more complex filtering.

The IBindingListView interface contains three members related to filter; the SupportsFiltering and Filter properties as well as the RemoveFilter method. The first step is to implement the SupportsFiltering property to always return true.

Implementing the Filter property is more difficult and requires some preliminary steps. When the filter value is set, the filter is applied to the list and the list returns the items that meets the filter criteria. In addition, the original list must be cached because the filter can be removed, in which case, the list should revert to its original contents. Therefore, the unfiltered list is stored in a read-only property named UnfilteredList. I chose a read-only property to allow for the code to be unit-tested. The following code shows the declaration for the unfiltered list.

Next is the Filter property itself.

private string filterValue = null;

 The getter for the filter property is straightforward.

get

However, the setter is more complicated and requires some explanantion. The first step in setting the Filter property is to check whether the filter value has changed. If the filter value is unchanged, the set operation should not do anything. If the Filter value has changed, I temporarily disable change notifications for the list. It is important that I do this step because I will be manipulating the contents of the list. In the context of an application, bound controls should not be notified of these internal changes. To disable change notifications, I set the RaiseListChangedEvents property to false; This property is set back to true when the set call is finished. Next, I'll check for a filter value of null. Null indicates the filter has been removed and the original list contents should be reset. I must also check the filter value to see whether it matches the expected format, which I do with a regular expression. If the filter value does not match the expected format, or the filter expression indicates multi-column filtering, an ArgumentException is thrown. If the filter complies with the expected format, I parse the filter string and apply it to the data source. Finally, I set the RaiseListChangedEvents property back to true and call raise a ListChanged event to signal bound controls to refresh. In the following code, the filter parsing and application is accomplished by two separate methods; GetFilterParts and ApplyFilter, which I'll discuss next.

set

In this example, parsing the filter is straightforward. I look for the "=" and grab the property name and filter value. The filter value is converted to the same type as the specified property. If the property is not found, or the conversion cannot be performed, an exception is thrown.

First, I expose some properties and private fields to store the filter parts.

Then I get the parts.

Following is the ApplyFilter method.  This method is pretty simple; I loop through the items using the FindCore method to get all of the matches to the filter value.

The final step is to implement RemoveFilter. This is simple; set Filter to null.

Hopefully this helps you get started with filtering and please look for my upcoming article that shows a more complex filtering implementation.

using System;

using System.Collections.Generic;

using System.Text;

using System.ComponentModel;

using System.Windows.Forms;

using System.Text.RegularExpressions;

using System.Reflection;

using System.Collections;

public class SimpleFilteredList<T> : BindingList<T>, IBindingListView

    public SimpleFilteredList() {}

#region Searching

protected override bool SupportsSearchingCore

{

    get

    {

       return true;

    }

}

protected override int FindCore(PropertyDescriptor prop, object key)

{

    return FindCore(0, prop, key);

}

protected int FindCore(int startIndex, PropertyDescriptor prop, object key)

{

    // Get the property info for the specified property.

    PropertyInfo propInfo = typeof(T).GetProperty(prop.Name);

    T item;

    if (key != null)

    {

    // Loop through the items to see if the key

    // value matches the property value.

        for (int i = startIndex; i < Count; ++i)

        {

             item = (T)Items[i];

             if (propInfo.GetValue(item, null).Equals(key))

             return i;

        }

     }

    return -1;

}

public int Find(int startIndex, string property, object key)

{

    // Check the properties for a property with the specified name.

    PropertyDescriptorCollection properties =

    TypeDescriptor.GetProperties(typeof(T));

    PropertyDescriptor prop = properties.Find(property, true);

    // If there is not a match, return -1 otherwise pass search to

    // FindCore method.

    if (prop == null)

    return -1;

   else

   if (startIndex <= 0)

    return FindCore(prop, key);

   else

   return FindCore(startIndex, prop, key);

}

#endregion Searching

#region Sorting

ArrayList sortedList;

ArrayList unsortedItems;

bool isSortedValue;

ListSortDirection sortDirectionValue;

PropertyDescriptor sortPropertyValue;

protected override bool SupportsSortingCore

{

    get { return true; }

}

protected override bool IsSortedCore

{

    get { return isSortedValue; }

}

protected override PropertyDescriptor SortPropertyCore

{

     get { return sortPropertyValue; }

}

protected override ListSortDirection SortDirectionCore

{

     get { return sortDirectionValue; }

}

 

public void ApplySort(string propertyName, ListSortDirection direction)

{

    // Check the properties for a property with the specified name.

    PropertyDescriptor prop = TypeDescriptor.GetProperties(typeof(T))[propertyName];

    // If there is not a match, return -1 otherwise pass search to

    // FindCore method.

    if (prop == null)

    throw new ArgumentException(propertyName +

    " is not a valid property for type:" + typeof(T).Name);

    else

    ApplySortCore(prop, direction);

}

protected override void ApplySortCore(PropertyDescriptor prop,

ListSortDirection direction)

{

    RaiseListChangedEvents = false;

    sortedList = new ArrayList();

    // Check to see if the property type we are sorting by implements

    // the IComparable interface.

    Type interfaceType = prop.PropertyType.GetInterface("IComparable");

    if (interfaceType != null)

    {

         // If so, set the SortPropertyValue and SortDirectionValue.

         sortPropertyValue = prop;

         sortDirectionValue = direction;

         unsortedItems = new ArrayList(this.Count);

         // Loop through each item, adding it the the sortedItems ArrayList.

         foreach (Object item in this.Items)

         {

              sortedList.Add(prop.GetValue(item));

              unsortedItems.Add(item);

         }

         // Call Sort on the ArrayList.

         sortedList.Sort();

         T temp;

         // Check the sort direction and then copy the sorted items

         // back into the list.

         if (direction == ListSortDirection.Descending)

         sortedList.Reverse();

         for (int i = 0; i < this.Count; i++)

         {

             int position = Find(0, prop.Name, sortedList[i]);

             if (position != i)

             {

                  temp = this[i];

                  this[i] = this[position];

                  this[position] = temp;

             }

       }

      RaiseListChangedEvents = true;

      isSortedValue = true;

      // Raise the ListChanged event so bound controls refresh their

      // values.

      OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));

  }

  else

  // If the property type does not implement IComparable, let the user

  // know.

  throw new NotSupportedException("Cannot sort by " + prop.Name +

  ". This" + prop.PropertyType.ToString() +

  " does not implement IComparable");

}

protected override void RemoveSortCore()

    {

     int position;

    object temp;

    RaiseListChangedEvents = false;

    // Ensure the list has been sorted.

    if (unsortedItems != null)

    {

          // Loop through the unsorted items and reorder the

         // list per the unsorted list.

        for (int i = 0; i < unsortedItems.Count; )

         {

             position = this.Find(0, SortPropertyCore.Name,

             unsortedItems[i].GetType().

             GetProperty(SortPropertyCore.Name).GetValue(unsortedItems[i], null));

             if (position >= 0 && position != i)

             {

                   temp = this[i];

                   this[i] = this[position];

                   this[position] = (T)temp;

                   i++;

              }

              else if (position == i)

               i++;

              else

             // If an item in the unsorted list no longer exists, delete it.

             unsortedItems.RemoveAt(i);

        }

        RaiseListChangedEvents = true;

        OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));

    }

}

public void RemoveSort()

{

     RemoveSortCore();

}

public override void EndNew(int itemIndex)

{

    // Check to see if the item is added to the end of the list,

    // and if so, re-sort the list.

    if (sortPropertyValue != null && itemIndex > 0 && itemIndex == this.Count - 1)

         ApplySortCore(this.sortPropertyValue, this.sortDirectionValue);

     base.EndNew(itemIndex);

}

#endregion Sorting

#region AdvancedSorting

public bool SupportsAdvancedSorting

{

    get { return false; }

}

public ListSortDescriptionCollection SortDescriptions

{

    get { return null; }

}

public void ApplySort(ListSortDescriptionCollection sorts)

{

     throw new NotImplementedException();

}

#endregion AdvancedSorting

#region Filtering

private string filterValue = "";

/// <summary>

/// Should be in the format columnName ='desiredValue'

/// </summary>

private string filterPropertyNameValue;

private Object filterCompareValue;

List<T> unfilteredListValue = new List<T>();

public List<T> UnfilteredList

{

    get { return unfilteredListValue; }

}

public bool SupportsFiltering

{

     get { return true; }

}

 

public void RemoveFilter()

{

     if (Filter != null) Filter = null;

}

public string FilterPropertyName

{

     get { return filterPropertyNameValue; }

}

public Object FilterCompare

{

    get { return filterCompareValue; }

}

 

public string Filter

{

    get

    {

        return filterValue;

    }

    set

    {

        if (filterValue != value)

        {

  RaiseListChangedEvents = false;

  // If filter value is null, reset list.

  if (value == null)

  {

      this.ClearItems();

      foreach (T t in unfilteredListValue)

          this.Items.Add(t);

      filterValue = value;

   }

   // If the value is empty string, do nothing.

   // This behavior is compatible with DataGridView

   // AutoFilter code.

   else if (value == ""){}

 

   // If the value is not null or string, than process

   // normal.

   else if (Regex.Matches(value,

    "[?[\\w ]+]? ?[=] ?'?[\\w|/: ]+'?",

    RegexOptions.Singleline).Count == 1 && value != "")

   {

      // If the filter is not set.

       unfilteredListValue.Clear();

       unfilteredListValue.AddRange(this.Items);

       filterValue = value;

       GetFilterParts();

       ApplyFilter();

     }

     else if (Regex.Matches(value,

       "[?[\\w ]+]? ?[=] ?'?[\\w|/: ]+'?",

       RegexOptions.Singleline).Count > 1)

           throw new ArgumentException("Multi-column" +

             "filtering is not implemented.");

    else throw new ArgumentException("Filter is not" +

           "in the format: propName = 'value'.");

RaiseListChangedEvents = true;

OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));

}

}

}   

void FilteredListView_ListChanged(object sender, ListChangedEventArgs e)

{

   MessageBox.Show(RaiseListChangedEvents.ToString());

   // Add the new item

   if (e.ListChangedType == ListChangedType.ItemAdded)

      unfilteredListValue.Add(this[e.NewIndex]);

  // Remove the new item

   if (e.ListChangedType == ListChangedType.ItemDeleted)

     unfilteredListValue.RemoveAt(e.NewIndex);

}

 

private void ApplyFilter()

{

    unfilteredListValue.Clear();

    unfilteredListValue.AddRange(this.Items);

    List<T> results = new List<T>();

    PropertyDescriptor propDesc = TypeDescriptor.GetProperties(typeof(T))[FilterPropertyName];

    if (propDesc != null)

    {

        int tempResults = -1;

       do

       {

            tempResults = FindCore(tempResults + 1, propDesc, FilterCompare);

            if (tempResults != -1)

            results.Add(this[tempResults]);

       } while (tempResults != -1);

    }

   this.ClearItems();

   if (results != null && results.Count > 0)

   {

        foreach (T itemFound in results)

        this.Add(itemFound);

   }

}

 

public void GetFilterParts()

{

    string[] filterParts = Filter.Split(new char[] { '=' }, StringSplitOptions.RemoveEmptyEntries);

    filterPropertyNameValue = filterParts[0].Replace("[", "").Replace("]", "").Trim();

    PropertyDescriptor propDesc =

    TypeDescriptor.GetProperties(typeof(T))[filterPropertyNameValue.ToString()];

    if (propDesc != null)

   {

       try

       {

            TypeConverter converter = TypeDescriptor.GetConverter(propDesc.PropertyType);

             filterCompareValue = converter.ConvertFromString(filterParts[1].Replace("'", "").Trim());

       }

      catch (NotSupportedException)

      {

          throw new ArgumentException("Specified filter value " +

          FilterCompare + " can not be converted from string." +

              "..Implement a type converter for " + propDesc.PropertyType.ToString());

       }

}

    else throw new ArgumentException("Specified property '" +

       FilterPropertyName + "' is not found on type " +

       typeof(T).Name + ".");

    }

#endregion Filtering

Here's a summary of the fixes:

• The code that populates the drop-down list now does a case-insensitive match between the column's DataPropertyName and the data source properties. This is necessary because data-source property-access APIs are case-sensitive but DataPropertyName is case-insensitive. This caused problems with columns that are manually bound using a different casing than is used in the data source.
• The code that populates the drop-down now does a null-value check before resetting the filter. The previous version caused some issues when binding to an lBindingListView implementation that my colleague Cheryl is working on for a forthcoming whitepaper.
• The drop-down button size is now constrained by the header cell width as well as the height. Previously, the drop-down button for a very narrow column would overlap the adjacent column.
• The drop-down button painting code is no longer executed if the button is of zero size. Previously, this caused an exception, for example when using the mouse to reduce the height of the column headers row to zero.

Additionally, the final documentation is now available on MSDN. See:

• Client Application Services
• System.Web.ClientServices
• System.Web.ClientServices.Providers

If you have used a previous version of the sample, you might need to deal with its remnants if you run into problems with this new version. Here are a few things you can try:

• If you get a CookieException when accessing the remote services, try clearing your IE cookie cache.
• If your application does not seem to be accessing the remote services, but everything looks properly configured, try deleting the application data folder. This folder location is indicated by the static Application.UserAppDataPath property - the default location for Vista is C:\Users\<username>\AppData\Roaming\MSIT.

I have now replaced the original UsingClientApplicationServices.zip file, so if you'd like to preview the RTM version of this walkthrough and run the sample on the Beta 2 release, you can download the new UsingClientApplicationServices.zip. Updates include:

• A "remember me" feature for the login dialog box.
• A logout button.
• More robust code throughout, demonstrating extensive exception handling for fallback scenarios such as login expiration and server unavailability.

Enjoy!

UPDATE (12/04/2007): UsingClientApplicationServices.zip now includes VB and C# projects that will work with the Visual Studio 2008 RTM release. Additionally, the full documentation is now available on MSDN. See:

• Client Application Services
• System.Web.ClientServices
• System.Web.ClientServices.Providers 

A few of you reported your frustration with the Smart Client Orcas Features lab, as you were not able to cut and paste from the lab document to Visual Studio. In addition to viewing and downloading the lab from the Tech-Ed site, you can check it out right on this blog, as Karl posted the walkthrough a couple of weeks ago.

If you didn't have the chance to attend Tech-Ed, or did attend, but want to revisit your favorite parts, make sure and check out Virtual Tech-Ed.

The documentation for client application services is still in progress, but we have created an end-to-end walkthrough to demonstrate the key features. This walkthrough will be used as a lab session at the upcoming TechEd 2007 conference, but if you want a sneak peek, download the attached zip file, which contains the walkthrough and sample projects in Visual Basic and C#.

(From the walkthrough introduction:) In this walkthrough, you perform the following tasks:

• Create a Windows Forms application and use the Visual Studio project designer to enable and configure client application services. 
• Create a simple ASP.NET Web Service application to host the application services and test your client configuration.
• Add forms authentication to your application. You will start by using a hard-coded user name and password to test the service. You will then add a login form by specifying it as a credentials provider in your application configuration. 
• Add role-based functionality, enabling and displaying a button only for users in the "manager" role. 
• Access Web settings. You will start by loading Web settings for an authenticated (test) user on the Settings page of the project designer. You will then use the Windows Forms Designer to bind a text box to a Web setting. Finally, you will save the modified value back to the server. 
• Enable offline mode. You will provide a check box so that users can specify their connection status. You will then use this value to specify whether the client application service providers will use locally cached data instead of accessing their Web services. Finally, you will re-authenticate the current user when the application returns to online mode.

UPDATE (9/27/2007): I have extensively revised and updated this walkthrough for the Visual Studio 2008 RTM documentation. To preview these updates, download the attached UsingClientApplicationServices.zip file, which includes the new walkthrough plus VB and C# projects containing updated Visual Studio solutions that work with the Visual Studio 2008 (formerly code-named "Orcas") Beta 2 release. These updates include a "remember me" login feature, a logout button, and more robust code that demonstrates appropriate exception handling for cases such as login expiration and server unavailability. Enjoy!

UPDATE (12/04/2007): The attached UsingClientApplicationServices.zip now includes VB and C# projects that will work with the Visual Studio 2008 RTM release. Additionally, the full documentation is now available on MSDN. See:

• Client Application Services
• System.Web.ClientServices
• System.Web.ClientServices.Providers

UsingClientApplicationServices.zip