DataGridView绑定BindingList<T>带数据排序的类

时间：2014-03-01 01:27:24 收藏：0 阅读：978

本文章转载：http://yuyingying1986.blog.hexun.com/30905610_d.html

DataGridView绑定List<T>类时候，不会自动的进行排序。

解决办法：一、手动实现DataGridView列标题的点击排序事件。二、自定义实现BinddingList类

我们常常使用DataGridView 控件,这个控件在绑定数据源后,常常不能排序,正好我现在做的项目中也遇上了这个问题,所以上网查了一些资料,解决了这个问题,下面是我解决的方法
 
1.创健一个专门用来排序的类
 
处理手段 
 
　　做排序处理，做本质的办法是继承ICompare接口，重新Compare方法。
 
代码:
 
using 
System;
using 
System.Collections.Generic;
using 
System.Linq;
using 
System.Text;
using 
System.ComponentModel;
 
namespace 
ConcreteMonitor.VehicleManagement
{
    class 
ObjectPropertyCompare<T> : System.Collections.Generic.IComparer<T>　
    {
 
        private 
PropertyDescriptor _property;
        public 
PropertyDescriptor property
        {
            get 
{ return 
_property; }
            set 
{ _property = value; }
        }
 
  
 
        private 
ListSortDirection _direction;
        public 
ListSortDirection direction
        {
            get 
{ return 
_direction; }
            set 
{ _direction = value; }
        }
 
        public 
ObjectPropertyCompare()
        { }
 
        public 
ObjectPropertyCompare(PropertyDescriptor prop, ListSortDirection direction)
        {
            _property = prop;
            _direction = direction;
        }
 
        public 
int Compare(T x, T y)
        {
 
            object 
xValue = x.GetType().GetProperty(property.Name).GetValue(x, null);
            object 
yValue = y.GetType().GetProperty(property.Name).GetValue(y, null);
 
            int 
returnValue;
 
            if 
(xValue == null 
&& yValue == null)
            {
                returnValue = 0;
            }
            else 
if (xValue == null)
            {
                returnValue = -1;
            }
            else 
if (yValue == null)
            {
                returnValue = 1;
            }
            else 
if (xValue is 
IComparable)
            {
                returnValue = ((IComparable)xValue).CompareTo(yValue);
            }
            else 
if (xValue.Equals(yValue))
            {
                returnValue = 0;
            }
            else
            {
                returnValue = xValue.ToString().CompareTo(yValue.ToString());
            }
 
            if 
(direction == ListSortDirection.Ascending)
            {
                return 
returnValue;
            }
            else
            {
                return 
returnValue * -1;
            }
 
        }
    }
}
 
2.创建用于绑定数据源的类
 
using 
System.Text;
using 
System.ComponentModel;
using 
JtxSignal;
using 
JtxSignal.Signals;
using 
ConcreteMonitor.Database;
using 
System.Data;
using 
System.Collections;
using 
ConcreteMonitor.Properties;
 
namespace 
ConcreteMonitor.VehicleManagement
{
    public 
class BindingCollection<T> : BindingList<T>
    {
        protected 
override bool SupportsSortingCore
        {
            get 
{ return 
true; }
        }
 
        protected 
override bool SupportsSearchingCore
        {
            get 
{ return 
true; }
        }
 
        private 
bool isSortedCore = true;
        protected 
override bool IsSortedCore
        {
            get
            {
                return 
isSortedCore;
            }
        }
 
        private 
ListSortDirection sortDirectionCore = ListSortDirection.Ascending;
        protected 
override ListSortDirection SortDirectionCore
        {
            get
            {
                return 
sortDirectionCore;
            }
        }
 
        private 
PropertyDescriptor sortPropertyCore = null;
        protected 
override PropertyDescriptor SortPropertyCore
        {
            get
            {
                return 
sortPropertyCore;
            }
        }
 
        protected 
override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
        {
            List<T> items = this.Items as 
List<T>;
 
            if 
(items != null)
            {
                ObjectPropertyCompare<T> pc = new 
ObjectPropertyCompare<T>(prop, direction);
                items.Sort(pc);
                isSortedCore = true;
                sortDirectionCore = direction;
                sortPropertyCore = prop;
            }
            else
            {
                isSortedCore = false;
            }
 
            this.OnListChanged(new 
ListChangedEventArgs(ListChangedType.Reset, -1));
        }
 
        protected 
override void RemoveSortCore()
        {
            isSortedCore = false;
            this.OnListChanged(new 
ListChangedEventArgs(ListChangedType.Reset, -1));
        }
    }
}
 
 
3.使用
<br>List<T> list=new 
List<T>();
DataGridView.DataSource = new 
BindingCollection<自己定义的类>（list）;
 
4.完成

第二种写法：

  public 
class SortableBindingList<T> : BindingList<T>
    {
        private 
readonly Dictionary<Type, PropertyComparer<T>> comparers;
        private 
bool isSorted;
        private 
ListSortDirection listSortDirection;
        private 
PropertyDescriptor propertyDescriptor;
 
        public 
SortableBindingList()
            : base(new 
List<T>())
        {
            this.comparers = new 
Dictionary<Type, PropertyComparer<T>>();
        }
 
        public 
SortableBindingList(IEnumerable<T> enumeration)
            : base(new 
List<T>(enumeration))
        {
            this.comparers = new 
Dictionary<Type, PropertyComparer<T>>();
        }
 
        protected 
override bool SupportsSortingCore
        {
            get 
{ return 
true; }
        }
 
        protected 
override bool IsSortedCore
        {
            get 
{ return 
this.isSorted; }
        }
 
        protected 
override PropertyDescriptor SortPropertyCore
        {
            get 
{ return 
this.propertyDescriptor; }
        }
 
        protected 
override ListSortDirection SortDirectionCore
        {
            get 
{ return 
this.listSortDirection; }
        }
 
        protected 
override bool SupportsSearchingCore
        {
            get 
{ return 
true; }
        }
 
        protected 
override void ApplySortCore(PropertyDescriptor property, ListSortDirection direction)
        {
            List<T> itemsList = (List<T>)this.Items;
 
            Type propertyType = property.PropertyType;
            PropertyComparer<T> comparer;
            if 
(!this.comparers.TryGetValue(propertyType, out 
comparer))
            {
                comparer = new 
PropertyComparer<T>(property, direction);
                this.comparers.Add(propertyType, comparer);
            }
 
            comparer.SetPropertyAndDirection(property, direction);
            itemsList.Sort(comparer);
 
            this.propertyDescriptor = property;
            this.listSortDirection = direction;
            this.isSorted = true;
 
            this.OnListChanged(new 
ListChangedEventArgs(ListChangedType.Reset, -1));
        }
 
        protected 
override void RemoveSortCore()
        {
            this.isSorted = false;
            this.propertyDescriptor = base.SortPropertyCore;
            this.listSortDirection = base.SortDirectionCore;
 
            this.OnListChanged(new 
ListChangedEventArgs(ListChangedType.Reset, -1));
        }
 
        protected 
override int FindCore(PropertyDescriptor property, object 
key)
        {
            int 
count = this.Count;
            for 
(int 
i = 0; i < count; ++i)
            {
                T element = this[i];
                if 
(property.GetValue(element).Equals(key))
                {
                    return 
i;
                }
            }
 
            return 
-1;
        }
    }
 
public 
class PropertyComparer<T> : IComparer<T>
    {
        private 
readonly IComparer comparer;
        private 
PropertyDescriptor propertyDescriptor;
        private 
int reverse;
 
        public 
PropertyComparer(PropertyDescriptor property, ListSortDirection direction)
        {
            this.propertyDescriptor = property;
            Type comparerForPropertyType = typeof(Comparer<>).MakeGenericType(property.PropertyType);
            this.comparer = (IComparer)comparerForPropertyType.InvokeMember("Default", BindingFlags.Static | BindingFlags.GetProperty | BindingFlags.Public, null, null, null);
            this.SetListSortDirection(direction);
        }
 
        #region IComparer<T> Members
 
        public 
int Compare(T x, T y)
        {
            return 
this.reverse * this.comparer.Compare(this.propertyDescriptor.GetValue(x), this.propertyDescriptor.GetValue(y));
        }
 
        #endregion
 
        private 
void SetPropertyDescriptor(PropertyDescriptor descriptor)
        {
            this.propertyDescriptor = descriptor;
        }
 
        private 
void SetListSortDirection(ListSortDirection direction)
        {
            this.reverse = direction == ListSortDirection.Ascending ? 1 : -1;
        }
 
        public 
void SetPropertyAndDirection(PropertyDescriptor descriptor, ListSortDirection direction)
        {
            this.SetPropertyDescriptor(descriptor);
            this.SetListSortDirection(direction);
        }
    }<br><br>调用：   List<Model.EmailList> emails = (List<Model.EmailList>)e.Data;<br>        dgvEmails.DataSource =new 
SortableBindingList<Model.EmailList>(emails);

DataGridView绑定BindingList<T>带数据排序的类,布布扣,bubuko.com

原文：http://www.cnblogs.com/zfanlong1314/p/3573371.html

DataGridView绑定BindingList&lt;T&gt;带数据排序的类

DataGridView绑定BindingList<T>带数据排序的类