DataGridView 绑定List 时 排序问题的解决

1. public   class   SortableBindingList <T>   :   BindingList <T>
2.         {
3.                 private   bool   isSortedCore   =   true;
4.                 private   ListSortDirection   sortDirectionCore   =   ListSortDirection.Ascending;
5.                 private   PropertyDescriptor   sortPropertyCore   =   null;
6.                 private   string   defaultSortItem;
8.                 public   SortableBindingList()   :   base()   {   }
10.                 public   SortableBindingList(IList <T>   list)   :   base(list)   {   }
11.                              
12.                 protected   override   bool   SupportsSortingCore
13.                 {
14.                         get   {   return   true;   }
15.                 }
17.                 protected   override   bool   SupportsSearchingCore
18.                 {
19.                         get   {   return   true;   }
20.                 }
22.                 protected   override   bool   IsSortedCore
23.                 {
24.                         get   {   return   isSortedCore;   }
25.                 }
27.                 protected   override   ListSortDirection   SortDirectionCore
28.                 {
29.                         get   {   return   sortDirectionCore;   }
30.                 }
32.                 protected   override   PropertyDescriptor   SortPropertyCore
33.                 {
34.                         get   {   return   sortPropertyCore;   }
35.                 }
37.                 protected   override   int   FindCore(PropertyDescriptor   prop,   object   key)
38.                 {
39.                         for   (int   i   =   0;   i   <   this.Count;   i++)
40.                         {
41.                                 if   (Equals(prop.GetValue(this[i]),   key))   return   i;
42.                         }
43.                         return   -1;
44.                 }
46.                 protected   override   void   ApplySortCore(PropertyDescriptor   prop,   ListSortDirection   direction)
47.                 {
48.                         isSortedCore   =   true;
49.                         sortPropertyCore   =   prop;
50.                         sortDirectionCore   =   direction;
51.                         Sort();
52.                 }
54.                 protected   override   void   RemoveSortCore()
55.                 {
56.                         if   (isSortedCore)
57.                         {
58.                                 isSortedCore   =   false;
59.                                 sortPropertyCore   =   null;
60.                                 sortDirectionCore   =   ListSortDirection.Ascending;
61.                                 Sort();
62.                         }
63.                 }
65.                 public   string   DefaultSortItem
66.                 {
67.                         get   {   return   defaultSortItem;   }
68.                         set
69.                         {
70.                                 if   (defaultSortItem   !=   value)
71.                                 {
72.                                         defaultSortItem   =   value;
73.                                         Sort();
74.                                 }
75.                         }
76.                 }
78.                 private   void   Sort()
79.                 {
80.                         List <T>   list   =   (this.Items   as   List <T> );
81.                         list.Sort(CompareCore);
82.                         ResetBindings();
83.                 }
85.                 private   int   CompareCore(T   o1,   T   o2)
86.                 {
87.                         int   ret   =   0;
88.                         if   (SortPropertyCore   !=   null)
89.                         {
90.                                 ret   =   CompareValue(SortPropertyCore.GetValue(o1),   SortPropertyCore.GetValue(o2),   SortPropertyCore.PropertyType);
91.                         }
92.                         if   (ret   ==   0   &&   DefaultSortItem   !=   null)
93.                         {
94.                                 PropertyInfo   property   =   typeof(T).GetProperty(DefaultSortItem,   BindingFlags.Public   |   BindingFlags.GetProperty   |   BindingFlags.Instance   |   BindingFlags.IgnoreCase,   null,   null,   new   Type[0],   null);
95.                                 if   (property   !=   null)
96.                                 {
97.                                         ret   =   CompareValue(property.GetValue(o1,   null),   property.GetValue(o2,   null),   property.PropertyType);
98.                                 }
99.                         }
100.                         if   (SortDirectionCore   ==   ListSortDirection.Descending)   ret   =   -ret;
101.                         return   ret;
102.                 }
104.                 private   static   int   CompareValue(object   o1,   object   o2,   Type   type)
105.                 {
106.                         //这里改成自己定义的比较
107.                         if(o1   ==   null)return   o2==null   ?   0   :   -1;
108.                         else   if(o2   ==   null)   return   1;
109.                         else   if   (type.IsPrimitive   ||   type.IsEnum)   return   Convert.ToDouble(o1).CompareTo(Convert.ToDouble(o2));
110.                         else   if   (type   ==   typeof(DateTime))   return   Convert.ToDateTime(o1).CompareTo(o2);
111.                         else   return   String.Compare(o1.ToString().Trim(),   o2.ToString().Trim());
112.                 }
113.         }