Como a função de paginação que vem com o .net é extremamente rígida e pouco personalizável, ela não pode atender às necessidades. Passei mais de uma semana escrevendo um
recurso de controle de paginação do .net:
1. Suporta datagrid, datalist e outros tipos de controles de exibição de dados. Em teoria, desde que haja um controle de fonte de dados, ele pode ser usado.
2. Suporta paginação de URL Cada página na paginação de URL pode ser pesquisada por mecanismos de pesquisa e suporta reescrita de URL.
3. O estilo de controle pode ser personalizado
4. O pacote está completo Se você usou o programa, você só precisa escrever uma linha de código
1 /***************************. *************** *******************************
2 ** Nome do arquivo: Pager.cs
3 ** Fundador: Yang Xiangwu
4 ** Data: 27 de julho de 2005
5 ** Modificado por:
6** Data:
7 ** Descrição:
8**
9 **---------------------------------------------------------- -- ------------------
10************************************************* ***** *******************/
11
12 usando Sistema;
13 usando System.Web.UI.WebControls;
14 usando System.Web.UI.HtmlControls;
15 usando System.Web;
16 usando System.Web.UI;
17 usando System.Text.RegularExpressions;
18
19 namespace MinhaEmpresa.Controles
20 {
21 /// <resumo>
22 /// Controle de paginação
23 /// </summary>
24 Pager de classe pública: Label, INamingContainer
25 {
26 #region variáveis de membro e construtores
27 Contexto HttpContext = HttpContext.Current;
28 Contagem de rótulosRótulo;
29 Botão anterior do HyperLink;
30 Próximo botão HyperLink;
31 HyperLink primeiro botão;
32 HiperLink lastButton;
33 HyperLink[] paginaçãoLinkButtons;
34
35 controles de substituição pública ControlCollection
36 {
37 obter
38 {
39 GarantaChildControls();
40 base de retorno.Controles;
41}
42}
43
44 substituição protegida void CreateChildControls()
45 {
46Controls.Clear();
47
48 AddCountLabel();
49
50 AddPageButtons();
51
52 AddPreviousNextHyperLinks();
53
54 AddFirstLastHyperLinks();
55}
56 #regiãofinal
57
58 #método de renderização de região
59 substituição protegida void Render (gravador HtmlTextWriter)
60 {
61 // Nenhum controle será exibido quando o número total de páginas modificadas for menor ou igual a 1
62 // int totalPages = CalculaTotalPages();
63 //
64 // if (totalPáginas <= 1)
65 // retorno;
66
67 AddAttributesToRender(escritor);
68
69 escritor.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClass, false);
70
71 RenderCountLabel(escritor);
72
73 RenderFirst(escritor);
74
75 RenderAnterior(escritor);
76
77 RenderPagingButtons(escritor);
78
79 RenderNext(escritor);
80
81 RenderLast(escritor);
82}
83
84 void RenderCountLabel (escritor HtmlTextWriter)
85 {
86 countLabel.RenderControl(escritor);
87
88 LiteralControl l = new LiteralControl(" ");
89 l.RenderControl(gravador);
90}
91
92 void RenderFirst (gravador HtmlTextWriter)
93 {
94 firstButton.RenderControl(escritor);
95
96 LiteralControl l = new LiteralControl(" ");
97 l.RenderControl(gravador);
98}
99
100 void RenderLast (gravador HtmlTextWriter)
101 {
102 lastButton.RenderControl(gravador);
103
104 LiteralControl l = new LiteralControl(" ");
105 l.RenderControl(gravador);
106}
107
108 void RenderPrevious (gravador HtmlTextWriter)
109 {
110 previousButton.RenderControl(escritor);
111
112 LiteralControl l = new LiteralControl(" ");
113 l.RenderControl(gravador);
114}
115
116 void RenderNext (escritor HtmlTextWriter)
117 {
118 nextButton.RenderControl(escritor);
119
120 LiteralControl l = new LiteralControl(" ");
121 l.RenderControl(gravador);
122}
123
124 privado void RenderButtonRange(int início, int fim, escritor HtmlTextWriter)
125 {
126 for (int i = início; i < fim; i++)
127 {
128 se (PageIndex == i)
129 {
130 Literal l = novo Literal();
131 l.Text = "<font color =red>" + (i + 1).ToString() + "</font>";
132
133 l.RenderControl(gravador);
134}
135 mais
136 {
137 pagingLinkButtons[i].RenderControl(writer);
138}
139 se (i <(fim - 1))
140 escritor.Write(" ");
141}
142
143 LiteralControl l1 = new LiteralControl(" ");
144 l1.RenderControl(gravador);
145}
146
147 RenderPagingButtons vazios privados (escritor HtmlTextWriter)
148 {
149 int totalPáginas;
150
151 totalPages = CalculaTotalPages();
152
153 se (totalPáginas <= 10)
154 {
155 RenderButtonRange(0, totalPages, escritor);
156}
157 mais
158 {
159 int limite inferior = (PageIndex - 4);
160 int UpperBount = (PageIndex + 6);
161
162 se (limite inferior <= 0)
163 limite inferior = 0;
164
165 se (PageIndex <= 4)
166 RenderButtonRange(0, 10, escritor);
167
168 else if (PageIndex < (totalPages - 5))
169 RenderButtonRange(lowerBound, (PageIndex + 6), escritor);
170
171 else if (PageIndex >= (totalPages - 5))
172 RenderButtonRange((totalPages - 10), totalPages, escritor);
173}
174}
175
176 #regiãofinal
177
178 #método de árvore de controle de região
179 /// <resumo>
180 /// Etiqueta de informações
181 /// </summary>
182 vazio AddCountLabel()
183 {
184 contagemLabel = new Label();
185 contagemLabel.ID = "contagemLabel";
186 countLabel.Text = string.Format(texto, CalculaTotalPages().ToString("n0"));
187
188 Controls.Add(contarLabel);
189}
190
191 AddPageButtons vazios privados()
192 {
193 pagingLinkButtons = new HyperLink[CalculateTotalPages()];
194
195 para (int i = 0; i <pagingLinkButtons.Length; i++)
196 {
197 pagingLinkButtons[i] = new HyperLink();
198 pagingLinkButtons[i].EnableViewState = false;
199 pagingLinkButtons[i].Text = (i + 1).ToString();
200 pagingLinkButtons[i].ID = i.ToString();
201 pagingLinkButtons[i].CssClass = linkCss;
202 pagingLinkButtons[i].NavigateUrl = GetHrefString(i);
203
204 Controls.Add(pagingLinkButtons[i]);
205}
206}
207
208 /// <resumo>
209 /// Última página da página inicial
210 /// </summary>
211 void AddFirstLastHyperLinks()
212 {
213 primeiroBotão = novo HiperLink();
214 firstButton.ID = "Primeiro";
215 firstButton.Text = "Home";
216 if(PageIndex != 0 && CalculaTotalPages() > 0)
217 {
218 firstButton.NavigateUrl = GetHrefString(0);
219}
220 mais
221 {
222 firstButton.Enabled = falso;
223}
224
225 Controls.Add(primeiroButton);
226
227 lastButton = novo HiperLink();
228 lastButton.ID = "Último";
229 lastButton.Text = "Última página";
230 if(PageIndex! = CalculaTotalPages() - 1)
231 {
232 lastButton.NavigateUrl = GetHrefString(CalculateTotalPages() - 1);
233}
234 mais
235 {
236 lastButton.Enabled = falso;
237}
238 Controls.Add(últimoBotão);
239}
240
241 /// <resumo>
242 /// Página anterior Próxima página
243 /// </summary>
244 void AdicionarAnteriorPróximoHyperLinks()
245 {
246 anteriorButton = novo HiperLink();
247 previousButton.ID = "Anterior";
248 previousButton.Text = "Página anterior";
249 se (HasAnterior)
250 {
251 previousButton.NavigateUrl = GetHrefString(PageIndex - 1);
252}
253 mais
254 {
255 anteriorButton.Enabled = falso;
256}
257 Controls.Add(botãoanterior);
258
259 nextButton = novo HiperLink();
260 nextButton.ID = "Próximo";
261 nextButton.Text = "Próxima página";
262 se(HasNext)
263 {
264 nextButton.NavigateUrl = GetHrefString(PageIndex + 1);
265}
266 mais
267 {
268 nextButton.Enabled = falso;
269}
270 Controls.Add(nextButton);
271}
272 #regiãofinal
273
274 #region Propriedades privadas
275 bool privado HasAnterior
276 {
277 obter
278 {
279 se (PageIndex > 0)
280 retorna verdadeiro;
281
282 retorna falso;
283}
284}
285
286 bool privado HasNext
287 {
288 obter
289 {
290 if (PageIndex + 1 < CalculaTotalPages() )
291 retorna verdadeiro;
292
293 retorna falso;
294}
295}
296 #regiãofinal
297
298 #region Métodos auxiliares e propriedades públicas
299
300 /// <resumo>
301 /// Obtém a string do hiperlink do botão de navegação de paginação
302 /// </summary>
303 /// <param name="pageIndex">O índice da página correspondente ao botão de paginação</param>
304 /// <returns>Sequência de hiperlink do botão de navegação de paginação</returns>
305 string privada GetHrefString (int pageIndex)
306 {
307 string url = Page.Request.RawUrl;
308
309 if (Regex.IsMatch(url, @"(d+).shtml", RegexOptions.IgnoreCase))
310 {
311 url = Regex.Replace(url, @"(d+).shtml", pageIndex + ".shtml");
312}
313
314 if (Regex.IsMatch(url, @"PageIndex=(d+)", RegexOptions.IgnoreCase))
315 {
316 url = Regex.Replace(url, @"PageIndex=(d+)", "PageIndex=" + pageIndex.ToString());
317}
318
319 retornar Page.Server.UrlPathEncode(url);
320}
321
322 público int CalculaTotalPages()
323 {
324 int totalPagesAvailable;
325
326 se (RegistrosTotais == 0)
327 retorna 0;
328
329 totalPagesAvailable = TotalRecords / PageSize;
330
331 se ((TotalRecords% PageSize) > 0)
332 total de páginas disponíveis++;
333
334 return totalPagesAvailable;
335}
336
337 /// <resumo>
338 /// Página atual
339 /// </summary>
340 público int PageIndex
341 {
342 obter
343 {
344 int _pageIndex = 0;
345
346 if ((!Page.IsPostBack) && (context.PageIndex > 0))
347 _pageIndex = context.PageIndex;
348 mais
349 _pageIndex = Convert.ToInt32(ViewState["PageIndex"]);
350
351 se (_pageIndex <0)
352 retorna 0;
353 mais
354 {
355 if (_pageIndex > CalculaTotalPages()-1)
356 return CalculaTotalPages()-1;
357 mais
358 return _pageIndex;
359}
360}
361 conjunto
362 {
363 ViewState["PageIndex"] = valor;
364}
365}
366
367 /// <resumo>
368 ///Número de registros por página
369 /// </summary>
370 público int PageSize
371 {
372 obter
373 {
374 int pageSize = Convert.ToInt32(ViewState["PageSize"]);
375
376 se (tamanho da página == 0)
377 {
378 retorna 10;
379}
380
381 retornar pageSize;
382}
383 conjuntos
384 {
385 ViewState["PageSize"] = valor;
386}
387
388}
389
390 /// <resumo>
391 ///Número total de registros
392 /// </summary>
393 público int TotalRecords
394 {
395 obter
396 {
397 return Convert.ToInt32(ViewState["TotalRecords"]);
398}
399 conjuntos
400 {
401 ViewState["TotalRecords"] = valor;
402}
403}
404
405 string privada text = "Total de {0} páginas";
406
407 string privada linkCss = "";
408 /// <resumo>
409 /// Estilo do link
410 /// </summary>
411 string pública LinkCss
412 {
413 obter {retornar linkCss};
414 conjunto { linkCss = valor;}
415}
416
417 string privada textCss = "";
418 /// <resumo>
419 /// Estilo do texto
420 /// </summary>
421 string pública TextCss
422 {
423 obter { retornar textoCss }
424 conjunto {textCss = valor;}
425}
426
427 string pública TextFormat
428 {
429 obter
430 {
431 texto de retorno;
432}
433 conjuntos
434 {
435 texto = valor;
436}
437}
438
439 #regiãofinal
440}
441}
442
Basta escrever isto na página:
1 <%@ Linguagem de Controle="c#" %>
2 <%@ Register TagPrefix="Anchor" Namespace="MinhaEmpresa.Controles" Assembly="MinhaEmpresa.Controles" %>
3 <ANCHOR:PAGER id="Pager1" runat="server"></ANCHOR:PAGER>
4