MyORM的使用(四) 实现Winform下的分页

其实这篇跟MyOrm的关系并不太大，只是分页时使用了MyOrm的查询，不过Winform中分页也是比较实用的，也作为一个例子吧。

不知道为什么MS并没有考虑在Winform中提供分页的功能，虽然Winform不像Webform需要考虑减少数据量的交互，但是在数据量很大时或者网络条件不好时还是需要分页的。

在Winform中实现分页的麻烦主要在于MS没有给分页定义事件或设置，所以想要做到Webform那样易用比较困难。实现分页的一个简单的方法是，写一个控制页码的用户控件，在控件触发的页码更改事件里绑定DataSource。这样的缺点在于，实际使用的时候还是需要手动写一些代码，包括获取总记录数、分页查询。另外，Winform里有多种需要绑定数据的控件（虽然最常用的就是DataGridView），还有第三方控件或者自定义的控件，通用性不够好。

为了使用的方便，自己定义一个数据源的类比较好，继承BindingSource是个不错的选择。BindingSource具备了基本的功能，我们只需要再增加分页功能。

定义PagedBindingSource：

 

 

1.     public class PagedBindingSource : BindingSource, INotifyPropertyChanged
2.     {
3.         protected const int DefaultPageSize = 20;
4.         private bool _autoRefresh = true;
5.         private int _totalCount;
6.         private int _startIndex;
7.         private int _pageSize = DefaultPageSize;
8.         //private PropertyDescriptor _sortProperty;
9.         //private ListSortDirection _sortDirection;
11.         //public override bool SupportsSorting
12.         //{
13.         //    get { return true; }
14.         //}
16.         //public override void ApplySort(PropertyDescriptor property, ListSortDirection sort)
17.         //{
18.         //    if (property == _sortProperty) sort = _sortDirection ^ ListSortDirection.Descending;
19.         //    _sortProperty = property;
20.         //    _sortDirection = sort;
21.         //    RefreshCurrentPage();
22.         //}
24.         //public override void RemoveSort()
25.         //{
26.         //    _sortProperty = null;
27.         //    RefreshCurrentPage();
28.         //}
30.         //public override bool IsSorted
31.         //{
32.         //    get { return _sortProperty != null; }
33.         //}
35.         //public override PropertyDescriptor SortProperty
36.         //{
37.         //    get { return _sortProperty; }
38.         //}
40.         //public override ListSortDirection SortDirection
41.         //{
42.         //    get { return _sortDirection; }
43.         //}
45.         protected virtual object GetDataSource(int startIndex, int pageSize, PropertyDescriptor orderby, ListSortDirection direction)
46.         {
47.             if (PageChanged != null)
48.             {
49.                 PageChangedEventArgs arg = new PageChangedEventArgs(startIndex, pageSize, orderby, direction);
50.                 PageChanged(this, arg);
51.                 return arg.ReturnSource;
52.             }
53.             return null;
54.         }
56.         protected virtual int GetTotalCount()
57.         {
58.             if (CountNeeded != null)
59.             {
60.                 CountEventArgs arg = new CountEventArgs();
61.                 CountNeeded(this, arg);
62.                 return arg.TotalCount;
63.             }
64.             return 0;
65.         }
67.         [DefaultValue(true)]
68.         public bool AutoRefresh
69.         {
70.             get { return _autoRefresh; }
71.             set { _autoRefresh = value; }
72.         }
74.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
75.         public int TotalCount
76.         {
77.             get { return _totalCount; }
78.         }
80.         [DefaultValue(DefaultPageSize)]
81.         public int PageSize
82.         {
83.             get { return _pageSize; }
84.             set
85.             {
86.                 if (_pageSize != value)
87.                 {
88.                     _pageSize = value;
89.                     OnPropertyChanged("PageSize");
90.                     if (AutoRefresh) RefreshCurrentPage();
91.                 }
92.             }
93.         }
95.         [DefaultValue(0)]
96.         public int StartIndex
97.         {
98.             get { return _startIndex; }
99.             set
100.             {
101.                 if (_startIndex != value)
102.                 {
103.                     _startIndex = value;
104.                     OnPropertyChanged("StartIndex");
105.                     if (AutoRefresh) RefreshCurrentPage();
106.                 }
107.             }
108.         }
110.         public override void Clear()
111.         {
112.             _totalCount = 0;
113.             _startIndex = 0;
114.             OnPropertyChanged(null);
115.             DataSource = null;
116.         }
118.         public virtual void RefreshSource()
119.         {
120.             _totalCount = GetTotalCount();
121.             _startIndex = 0;
122.             OnPropertyChanged(null);
123.             RefreshCurrentPage();
124.         }
126.         public virtual void RefreshCurrentPage()
127.         {
128.             DataSource = GetDataSource(StartIndex, PageSize, SortProperty, SortDirection);
129.         }
131.         protected void OnPropertyChanged(string propertyName)
132.         {
133.             if (PropertyChanged != null) PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
134.         }
136.         #region INotifyPropertyChanged Members
138.         public event PropertyChangedEventHandler PropertyChanged;
139.         public event PageChangedEventHandler PageChanged;
140.         public event GetCountEventHandler CountNeeded;
142.         #endregion
143.     }
145.     public delegate void PageChangedEventHandler(object sender, PageChangedEventArgs e);
146.     public delegate void GetCountEventHandler(object sender, CountEventArgs e);
148.     public class CountEventArgs : EventArgs
149.     {
150.         private int totalCount;
151.         public int TotalCount
152.         {
153.             get { return totalCount; }
154.             set { totalCount = value; }
155.         }
156.     }
158.     public class PageChangedEventArgs : EventArgs
159.     {
160.         internal PageChangedEventArgs(int startIndex, int pageSize, PropertyDescriptor orderby, ListSortDirection direction)
161.         {
162.             this.startIndex = startIndex;
163.             this.pageSize = pageSize;
164.             this.orderby = orderby;
165.             this.direction = direction;
166.         }
167.         private int startIndex;
168.         public int StartIndex
169.         {
170.             get { return startIndex; }
171.         }
173.         private int pageSize;
174.         public int PageSize
175.         {
176.             get { return pageSize; }
177.         }
179.         private PropertyDescriptor orderby;
180.         public PropertyDescriptor Orderby
181.         {
182.             get { return orderby; }
183.         }
185.         private ListSortDirection direction;
186.         public ListSortDirection Direction
187.         {
188.             get { return direction; }
189.         }
191.         private object returnSource;
192.         public object ReturnSource
193.         {
194.             get { return returnSource; }
195.             set { returnSource = value; }
196.         }
197.     }

注意到其中有2个事件PageChanged和CountNeeded，一个是分页的查询，一个是获取记录总数。底层的实现不同，这2个事件的实现也不同。比如在MyOrm里提供了分页查询的SearchSection方法，对ProductsView的分页查询可能像这样：

1.         private void pagedBindingSource1_CountNeeded(object sender, CountEventArgs e)
2.         {
3.             e.TotalCount = new ProductsViewDAO().Count(SearchCondition);
4.         }
6.         private void pagedBindingSource1_PageChanged(object sender, PageChangedEventArgs e)
7.         {
8.             e.ReturnSource = new ProductsViewDAO().SearchSection(SearchCondition, e.StartIndex, e.PageSize, e.Orderby == null ? null : e.Orderby.Name, e.Direction);
9.         }

另外还可以继承PagedBindingSource，自己实现GetTotalCount方法和GetDataSource方法，可以不需要在事件中添加代码。例如可以为MyOrm定制一个ConditionPagedSource：

1.    public class ConditionPagedSource : PagedBindingSource
2.     {
3.         private IObjectViewDAO _objectViewDAO;
4.         private Condition _condition;
5.         private Type _objectType;
7.         protected override int GetTotalCount()
8.         {
9.             return ObjectViewDAO.Count(Condition);
10.         }
12.         protected override object GetDataSource(int startIndex, int pageSize, PropertyDescriptor orderby, ListSortDirection direction)
13.         {
14.             return ObjectViewDAO.SearchSection(Condition, startIndex, pageSize, orderby == null ? null : orderby.Name, direction);
15.         }
17.         [DefaultValue(null), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
18.         public Condition Condition
19.         {
20.             get
21.             {
22.                 return _condition;
23.             }
24.             set
25.             {
26.                 _condition = value;
27.                 RefreshSource();
28.             }
29.         }
31.         [DefaultValue(null), TypeConverter(typeof(TypeTypeConverter)), RefreshProperties(RefreshProperties.Repaint)]
32.         public Type ObjectType
33.         {
34.             get { return _objectType; }
35.             set
36.             {
37.                 if (_objectType != value)
38.                 {
39.                     _objectType = value;
40.                     DataSource = value;
41.                 }
42.             }
43.         }
45.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
46.         public IObjectViewDAO ObjectViewDAO
47.         {
48.             get { return _objectViewDAO == null ? DAOFactoryUtil.GetObjectViewDAO(NorthwindFactory.DAOFactory, ObjectType) : _objectViewDAO; }
49.             set { _objectViewDAO = value; }
50.         }
51.     }

这样就完成了分页查询的数据源。ObjectType使用了TypeTypeConverter来实现设计时支持，其实就是可以把输入的类型名称转化为Type。再在ObjectType的内部DataSource = value也是为了在设计时能自动添加数据列，Winform中添加Object类型的DataSource其实就是BindingSource绑定到对象的Type，这里也照样。

TypeTypeConverter定义：

1. public class TypeTypeConverter : TypeConverter
2.     {
3.         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
4.         {
5.             return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
6.         }
8.         public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
9.         {
10.             return destinationType == typeof(string) || base.CanConvertTo(context, destinationType);
11.         }
13.         public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
14.         {
15.             if (value is string) return Type.GetType((string)value);
16.             return base.ConvertFrom(context, culture, value);
17.         }
19.         public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
20.         {
21.             if (destinationType == typeof(string)) return ((Type)value).FullName;
22.             return base.ConvertTo(context, culture, value, destinationType);
23.         }
24.     }

分页数据源有了，但是在界面上还需要提供一个控件来控制翻页。也许有现成的控件可以用，我这里仿造BindingNavigator提供了一个PageNavigator：

1. public class PageNavigator : BindingNavigator
2.     {
3.         private ToolStripItem _currentPageItem;
4.         private ToolStripItem _moveFirstPageItem;
5.         private ToolStripItem _moveLastPageItem;
6.         private ToolStripItem _moveNextPageItem;
7.         private ToolStripItem _movePreviousPageItem;
8.         private string _pageCountFormat;
9.         private ToolStripItem _pageCountItem;
10.         private PagedBindingSource _pageSource;
12.         public override void AddStandardItems()
13.         {
14.             MoveFirstPageItem = new ToolStripButton();
15.             MovePreviousPageItem = new ToolStripButton();
16.             MoveNextPageItem = new ToolStripButton();
17.             MoveLastPageItem = new ToolStripButton();
18.             CurrentPageItem = new ToolStripTextBox();
19.             PageCountItem = new ToolStripLabel();
20.             ToolStripSeparator separator = new ToolStripSeparator();
21.             ToolStripSeparator separator2 = new ToolStripSeparator();
22.             char ch = string.IsNullOrEmpty(base.Name) || char.IsLower(base.Name[0]) ? 'p' : 'P';
23.             MoveFirstPageItem.Name = ch + "ageNavigatorMoveFirstPageItem";
24.             MovePreviousPageItem.Name = ch + "ageNavigatorMovePreviousPageItem";
25.             MoveNextPageItem.Name = ch + "ageNavigatorMoveNextPageItem";
26.             MoveLastPageItem.Name = ch + "ageNavigatorMoveLastPageItem";
27.             CurrentPageItem.Name = ch + "ageNavigatorCurrentPageItem";
28.             PageCountItem.Name = ch + "ageNavigatorPageCountItem";
29.             separator.Name = ch + "ageNavigatorSeparator";
30.             separator2.Name = ch + "ageNavigatorSeparator";
31.             MoveFirstPageItem.Text = "PageNavigatorMoveFirstPageItemText";
32.             MovePreviousPageItem.Text = "PageNavigatorMovePreviousPageItemText";
33.             MoveNextPageItem.Text = "PageNavigatorMoveNextPageItemText";
34.             MoveLastPageItem.Text = "PageNavigatorMoveLastPageItemText";
35.             PageCountItem.ToolTipText = "PageNavigatorPageCountItemTip";
36.             CurrentPageItem.ToolTipText = "PageNavigatorCurrentPageItemTip";
37.             PageCountItem.AutoToolTip = false;
38.             PageCountItem.Text = "/0";
39.             CurrentPageItem.AutoToolTip = false;
40.             CurrentPageItem.Text = "0";
41.             CurrentPageItem.AccessibleName = "PageNavigatorPositionAccessibleName";
42.             PageCountFormat = "/{0}";
43.             Bitmap bitmap1 = new Bitmap(typeof(BindingNavigator), "BindingNavigator.MoveFirst.bmp");
44.             Bitmap bitmap2 = new Bitmap(typeof(BindingNavigator), "BindingNavigator.MovePrevious.bmp");
45.             Bitmap bitmap3 = new Bitmap(typeof(BindingNavigator), "BindingNavigator.MoveNext.bmp");
46.             Bitmap bitmap4 = new Bitmap(typeof(BindingNavigator), "BindingNavigator.MoveLast.bmp");
47.             bitmap1.MakeTransparent(Color.Magenta);
48.             bitmap2.MakeTransparent(Color.Magenta);
49.             bitmap3.MakeTransparent(Color.Magenta);
50.             bitmap4.MakeTransparent(Color.Magenta);
51.             MoveFirstPageItem.Image = bitmap1;
52.             MovePreviousPageItem.Image = bitmap2;
53.             MoveNextPageItem.Image = bitmap3;
54.             MoveLastPageItem.Image = bitmap4;
55.             MoveFirstPageItem.RightToLeftAutoMirrorImage = true;
56.             MovePreviousPageItem.RightToLeftAutoMirrorImage = true;
57.             MoveNextPageItem.RightToLeftAutoMirrorImage = true;
58.             MoveLastPageItem.RightToLeftAutoMirrorImage = true;
59.             MoveFirstPageItem.DisplayStyle = ToolStripItemDisplayStyle.Image;
60.             MovePreviousPageItem.DisplayStyle = ToolStripItemDisplayStyle.Image;
61.             MoveNextPageItem.DisplayStyle = ToolStripItemDisplayStyle.Image;
62.             MoveLastPageItem.DisplayStyle = ToolStripItemDisplayStyle.Image;
63.             CurrentPageItem.AutoSize = false;
64.             CurrentPageItem.Width = 50;
65.             Items.AddRange(new ToolStripItem[] { MoveFirstPageItem, MovePreviousPageItem, separator, CurrentPageItem, PageCountItem, separator2, MoveNextPageItem, MoveLastPageItem });
66.         }
68.         private void AcceptNewPage()
69.         {
70.             if (CurrentPageItem != null && _pageSource != null)
71.             {
72.                 int currentPage;
73.                 int.TryParse(CurrentPageItem.Text, out currentPage);
74.                 currentPage--;
75.                 if (currentPage >= 0)
76.                 {
77.                     int startIndex = currentPage * _pageSource.PageSize;
78.                     if (((((startIndex != _pageSource.StartIndex) && (startIndex >= 0)) && (startIndex < _pageSource.TotalCount)) ? 1 : 0) != 0)
79.                     {
80.                         _pageSource.StartIndex = startIndex;
81.                         if (!_pageSource.AutoRefresh) _pageSource.RefreshCurrentPage();
82.                         return;
83.                     }
84.                 }
85.                 CancelNewPage();
86.             }
87.         }
89.         private void CancelNewPage()
90.         {
91.             RefreshPageProperty();
92.         }
94.         private void OnCurrentPageKey(object sender, KeyEventArgs e)
95.         {
96.             Keys keyCode = e.KeyCode;
97.             if (keyCode != Keys.Return)
98.             {
99.                 if (keyCode != Keys.Escape)
100.                 {
101.                     return;
102.                 }
103.             }
104.             else
105.             {
106.                 AcceptNewPage();
107.                 return;
108.             }
109.             CancelNewPage();
110.         }
112.         private void OnCurrentPageLostFocus(object sender, EventArgs e)
113.         {
114.             AcceptNewPage();
115.         }
117.         private void OnMoveFirstPage(object sender, EventArgs e)
118.         {
119.             if (Validate() && _pageSource != null)
120.             {
121.                 _pageSource.StartIndex = 0;
122.                 if (!_pageSource.AutoRefresh) _pageSource.RefreshCurrentPage();
123.             }
124.         }
126.         private void OnMoveLastPage(object sender, EventArgs e)
127.         {
128.             if (Validate() && _pageSource != null)
129.             {
130.                 _pageSource.StartIndex = (_pageSource.TotalCount / _pageSource.PageSize) * _pageSource.PageSize;
131.                 if (!_pageSource.AutoRefresh) _pageSource.RefreshCurrentPage();
132.             }
133.         }
135.         private void OnMoveNextPage(object sender, EventArgs e)
136.         {
137.             if (Validate() && _pageSource != null)
138.             {
139.                 _pageSource.StartIndex += _pageSource.PageSize;
140.                 if (!_pageSource.AutoRefresh) _pageSource.RefreshCurrentPage();
141.             }
142.         }
144.         private void OnMovePreviousPage(object sender, EventArgs e)
145.         {
146.             if (Validate() && _pageSource != null)
147.             {
148.                 _pageSource.StartIndex -= _pageSource.PageSize;
149.                 if (!_pageSource.AutoRefresh) _pageSource.RefreshCurrentPage();
150.             }
151.         }
154.         public void RefreshPageProperty()
155.         {
156.             if (_pageSource != null)
157.             {
158.                 int pageSize = _pageSource.PageSize;
159.                 if (pageSize > 0)
160.                 {
161.                     int currentPage = _pageSource.StartIndex / pageSize;
162.                     int totalPage = ((_pageSource.TotalCount + pageSize) - 1) / pageSize;
163.                     PageCountItem.Text = string.Format(PageCountFormat, totalPage);
164.                     if (totalPage == 0)
165.                     {
166.                         CurrentPageItem.Text = "0";
167.                     }
168.                     else
169.                     {
170.                         CurrentPageItem.Text = Convert.ToString(currentPage + 1);
171.                     }
172.                     if (currentPage <= 0)
173.                     {
174.                         MoveFirstPageItem.Enabled = false;
175.                         MovePreviousPageItem.Enabled = false;
176.                     }
177.                     else
178.                     {
179.                         MoveFirstPageItem.Enabled = true;
180.                         MovePreviousPageItem.Enabled = true;
181.                     }
182.                     if (currentPage >= (totalPage - 1))
183.                     {
184.                         MoveLastPageItem.Enabled = false;
185.                         MoveNextPageItem.Enabled = false;
186.                     }
187.                     else
188.                     {
189.                         MoveLastPageItem.Enabled = true;
190.                         MoveNextPageItem.Enabled = true;
191.                     }
192.                 }
193.             }
194.         }
196.         private void WireUpButton(ref ToolStripItem oldButton, ToolStripItem newButton, EventHandler clickHandler)
197.         {
198.             if (oldButton != newButton)
199.             {
200.                 if (oldButton != null)
201.                 {
202.                     oldButton.Click -= clickHandler;
203.                 }
204.                 if (newButton != null)
205.                 {
206.                     newButton.Click += clickHandler;
207.                 }
208.                 oldButton = newButton;
209.             }
210.         }
212.         private void WireUpTextBox(ref ToolStripItem oldTextBox, ToolStripItem newTextBox, KeyEventHandler keyUpHandler, EventHandler lostFocusHandler)
213.         {
214.             if (oldTextBox != newTextBox)
215.             {
216.                 ToolStripControlHost host = oldTextBox as ToolStripControlHost;
217.                 ToolStripControlHost host2 = newTextBox as ToolStripControlHost;
218.                 if (host != null)
219.                 {
220.                     host.KeyUp -= keyUpHandler;
221.                     host.LostFocus -= lostFocusHandler;
222.                 }
223.                 if (host2 != null)
224.                 {
225.                     host2.KeyUp += keyUpHandler;
226.                     host2.LostFocus += lostFocusHandler;
227.                 }
228.                 oldTextBox = newTextBox;
229.             }
230.         }
232.         public ToolStripItem CurrentPageItem
233.         {
234.             get
235.             {
236.                 return _currentPageItem;
237.             }
238.             set
239.             {
240.                 WireUpTextBox(ref _currentPageItem, value, new KeyEventHandler(OnCurrentPageKey), new EventHandler(OnCurrentPageLostFocus));
241.             }
242.         }
244.         public ToolStripItem MoveFirstPageItem
245.         {
246.             get
247.             {
248.                 return _moveFirstPageItem;
249.             }
250.             set
251.             {
252.                 WireUpButton(ref _moveFirstPageItem, value, new EventHandler(OnMoveFirstPage));
253.             }
254.         }
256.         public ToolStripItem MoveLastPageItem
257.         {
258.             get
259.             {
260.                 return _moveLastPageItem;
261.             }
262.             set
263.             {
264.                 WireUpButton(ref _moveLastPageItem, value, new EventHandler(OnMoveLastPage));
265.             }
266.         }
268.         public ToolStripItem MoveNextPageItem
269.         {
270.             get
271.             {
272.                 return _moveNextPageItem;
273.             }
274.             set
275.             {
276.                 WireUpButton(ref _moveNextPageItem, value, new EventHandler(OnMoveNextPage));
277.             }
278.         }
280.         public ToolStripItem MovePreviousPageItem
281.         {
282.             get
283.             {
284.                 return _movePreviousPageItem;
285.             }
286.             set
287.             {
288.                 WireUpButton(ref _movePreviousPageItem, value, new EventHandler(OnMovePreviousPage));
289.             }
290.         }
292.         public string PageCountFormat
293.         {
294.             get
295.             {
296.                 return _pageCountFormat;
297.             }
298.             set
299.             {
300.                 if (!(_pageCountFormat == value))
301.                 {
302.                     _pageCountFormat = value;
303.                 }
304.             }
305.         }
307.         public ToolStripItem PageCountItem
308.         {
309.             get
310.             {
311.                 return _pageCountItem;
312.             }
313.             set
314.             {
315.                 _pageCountItem = value;
316.             }
317.         }
319.         public PagedBindingSource PageSource
320.         {
321.             get
322.             {
323.                 return _pageSource;
324.             }
325.             set
326.             {
327.                 if (value != _pageSource)
328.                 {
329.                     if (_pageSource != null)
330.                     {
331.                         _pageSource.PropertyChanged -= new PropertyChangedEventHandler(PageSource_PropertyChanged);
332.                     }
333.                     _pageSource = value;
334.                     RefreshPageProperty();
335.                     if (_pageSource != null)
336.                     {
337.                         _pageSource.PropertyChanged += new PropertyChangedEventHandler(PageSource_PropertyChanged);
338.                     }
339.                 }
340.             }
341.         }
343.         void PageSource_PropertyChanged(object sender, PropertyChangedEventArgs e)
344.         {
345.             RefreshPageProperty();
346.         }
347.     }

定义比较繁琐，继承BindingNavigator是为了获得良好的设计时支持，自己写个设计控件实在不是个小工程，所以虽然别扭就凑合一下吧。

这是PagedBindingSource、DataGridView、PageNavigator之间的关系图：

 

因为DataGridView不提供分页的功能，只能通过PageNavigator控制PagedBindingSource的翻页。

在设计界面中设定PageNavigator的PageSource和DataGridView的DataSource为创建好的ConditionPagedSource后，分页查询就完成了，很简单。（DataGridView在设置DataSource后为自动把AutoGenerateColumns设为false，有可能造成没有列显示出来，需要把InitializeComponent方法中的dataGridView1.AutoGenerateColumns = false;删掉再编辑界面就可以，一个比较烦人的问题）

最后的效果：

示例代码可以到CodePlex/MyOrm下载。