Dado que la función de paginación que viene con .net es extremadamente rígida y poco personalizable, no puede satisfacer las necesidades. Pasé más de una semana escribiendo una
función de control de paginación de .net:
1. Admite cuadrícula de datos, lista de datos y otros tipos de controles de visualización de datos. En teoría, siempre que exista un control de fuente de datos, se puede utilizar.
2. Admite la paginación de URL. Los motores de búsqueda pueden buscar cada página en la paginación de URL y admite la reescritura de URL.
3. El estilo de control se puede personalizar
4. El paquete está completo. Si ha utilizado el programa, sólo necesita escribir una línea de código
1 /*************************. *************** *******************************
2 ** Nombre de archivo: Pager.cs
3 ** Fundador: Yang Xiangwu
4** Fecha: 27 de julio de 2005
5 ** Modificado por:
6** Fecha:
7 ** Descripción:
8**
9 **----------------------------------------------- -- ------------------
10*************************************************** ***** *******************/
11
12 usando el 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 espacio de nombres MyCompany.Controls
20 {
21 /// <resumen>
22 /// Control de paginación
23 /// </summary>
Buscapersonas de clase pública 24: Etiqueta, INamingContainer
25 {
26 variables miembro de #región y constructores
27 contexto HttpContext = HttpContext.Current;
28 Recuento de etiquetasEtiqueta;
29 Hipervínculo botón anterior;
30 Hipervínculo siguienteBotón;
31 Hipervínculo primer botón;
32 Hipervínculo último botón;
33 HyperLink[] botones de enlace de paginación;
34
35 controles públicos de anulación ControlCollection
36 {
37 conseguir
38 {
39 GarantizarChildControls();
40 base de retorno.Controles;
41 }
42 }
43
44 anulación protegida anulada CreateChildControls()
45 {
46 Controles.Clear();
47
48 AgregarCountLabel();
49
50 botones AgregarPágina();
51
52 AgregarHyperEnlacesAnteriorSiguiente();
53
54 AgregarPrimerosÚltimosHyperEnlaces();
55 }
56 #endregion
57
58 método de representación de #región
59 anulación protegida Renderizado vacío (escritor HtmlTextWriter)
60 {
61 // No se mostrará ningún control cuando el número total de páginas modificadas sea menor o igual a 1
62 // int páginas totales = CalcularPáginasTotales();
63 //
64 // si (total de páginas <= 1)
65 // regresar;
66
67 AddAttributesToRender(escritor);
68
69 escritor.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClass, falso);
70
71 RenderCountLabel(escritor);
72
73 RenderFirst(escritor);
74
75 RenderPrevious(escritor);
76
77 RenderPagingButtons(escritor);
78
79 RenderSiguiente(escritor);
80
81 RenderLast(escritor);
82}
83
84 vacío RenderCountLabel (escritor HtmlTextWriter)
85 {
86 countLabel.RenderControl(escritor);
87
88 LiteralControl l = nuevo LiteralControl(" ");
89 l.RenderControl(escritor);
90}
91
92 void RenderFirst (escritor HtmlTextWriter)
93 {
94 primerButton.RenderControl(escritor);
95
96 LiteralControl l = nuevo LiteralControl(" ");
97 l.RenderControl(escritor);
98 }
99
100 RenderLast vacío (escritor HtmlTextWriter)
101 {
102 últimoButton.RenderControl(escritor);
103
104 LiteralControl l = nuevo LiteralControl(" ");
105 l.RenderControl(escritor);
106 }
107
108 void RenderPrevious (escritor HtmlTextWriter)
109 {
110 botón anterior.RenderControl(escritor);
111
112 LiteralControl l = nuevo LiteralControl(" ");
113 l.RenderControl(escritor);
114 }
115
116 void RenderNext (escritor HtmlTextWriter)
117 {
118 nextButton.RenderControl(escritor);
119
120 LiteralControl l = nuevo LiteralControl(" ");
121 l.RenderControl(escritor);
122 }
123
124 vacío privado RenderButtonRange (int inicio, int fin, escritor HtmlTextWriter)
125 {
126 para (int i = inicio; i < final; i++)
127 {
128 si (índice de página == i)
129 {
130 Literal l = nuevo Literal();
131 l.Text = "<color de fuente =rojo>" + (i + 1).ToString() + "</font>";
132
133 l.RenderControl(escritor);
134}
135 más
136 {
137 pagingLinkButtons[i].RenderControl(escritor);
138 }
139 si (i < (fin - 1))
140 escritor.Write(" ");
141 }
142
143 LiteralControl l1 = nuevo LiteralControl(" ");
144 l1.RenderControl(escritor);
145 }
146
147 RenderPagingButtons vacíos privados (escritor HtmlTextWriter)
148 {
149 páginas en total;
150
151 páginas totales = Calcular páginas totales();
152
153 si (total de páginas <= 10)
154 {
155 RenderButtonRange(0, totalPages, escritor);
156 }
157 más
158 {
159 int límite inferior = (índice de página - 4);
160 int superiorBount = (PageIndex + 6);
161
162 si (límite inferior <= 0)
163 límite inferior = 0;
164
165 si (índice de página <= 4)
166 RenderButtonRange(0, 10, escritor);
167
168 más si (PageIndex < (totalPages - 5))
169 RenderButtonRange(límite inferior, (PageIndex + 6), escritor);
170
171 más si (PageIndex >= (totalPages - 5))
172 RenderButtonRange((totalPages - 10), totalPages, escritor);
173}
174 }
175
176 #endregion
177
178 #método del árbol de control de región
179 /// <resumen>
180 /// Etiqueta de información
181 /// </summary>
182 anular AddCountLabel()
183 {
184 countLabel = nueva etiqueta();
185 countLabel.ID = "countLabel";
186 countLabel.Text = string.Format(texto, CalculateTotalPages().ToString("n0"));
187
188 Controles.Add(countLabel);
189 }
190
191 AddPageButtons vacíos privados()
192 {
193 pagingLinkButtons = nuevo HyperLink[CalculateTotalPages()];
194
195 para (int i = 0; i < pagingLinkButtons.Length; i++)
196 {
197 pagingLinkButtons[i] = nuevo hipervínculo();
198 pagingLinkButtons[i].EnableViewState = falso;
199 pagingLinkButtons[i].Texto = (i + 1).ToString();
200 pagingLinkButtons[i].ID = i.ToString();
201 pagingLinkButtons[i].CssClass = linkCss;
202 pagingLinkButtons[i].NavigateUrl = GetHrefString(i);
203
204 Controles.Add(pagingLinkButtons[i]);
205 }
206 }
207
208 /// <resumen>
209 /// Página de inicio última página
210 /// </summary>
211 anular AddFirstLastHyperLinks()
212 {
213 primerBotón = nuevo Hipervínculo();
214 primerBotón.ID = "Primero";
215 primerButton.Text = "Inicio";
216 si(PageIndex!= 0 && CalculateTotalPages() > 0)
217 {
218 primerButton.NavigateUrl = GetHrefString(0);
219 }
220 más
221 {
222 primerBotón.Enabled = falso;
223 }
224
225 Controles.Add(primerBotón);
226
227 último botón = nuevo hipervínculo();
228 últimoBotón.ID = "Último";
229 lastButton.Text = "Última página";
230 si(PageIndex!= CalculateTotalPages() - 1)
231 {
232 lastButton.NavigateUrl = GetHrefString(CalculateTotalPages() - 1);
233 }
234 más
235 {
236 último botón.Enabled = falso;
237 }
238 Controles.Add(últimoBotón);
239 }
240
241 /// <resumen>
242 /// Página anterior Página siguiente
243 /// </summary>
244 anular AgregarHyperEnlacesAnteriorSiguiente()
245 {
246 botón anterior = nuevo hipervínculo();
247 botón anterior.ID = "Anterior";
248 anteriorButton.Text = "Página anterior";
249 si (tiene anterior)
250 {
251 botón anterior.NavigateUrl = GetHrefString(PageIndex - 1);
252 }
253 más
254 {
255 botón anterior.Enabled = falso;
256 }
257 Controles.Add(botónanterior);
258
259 nextButton = nuevo Hipervínculo();
260 nextButton.ID = "Siguiente";
261 nextButton.Text = "Página siguiente";
262 si(TieneSiguiente)
263 {
264 nextButton.NavigateUrl = GetHrefString(PageIndex + 1);
265 }
266 más
267 {
268 nextButton.Enabled = falso;
269 }
270 Controles.Agregar(siguienteBotón);
271 }
272 #endregion
273
274 #región Propiedades privadas
275 bool privado TieneAnterior
276 {
277 obtener
278 {
279 si (índice de página > 0)
280 devuelve verdadero;
281
282 devuelve falso;
283}
284 }
285
286 bool privado HasNext
287 {
288 obtener
289 {
290 si (PageIndex + 1 <CalcularTotalPáginas())
291 devuelve verdadero;
292
293 devuelven falso;
294 }
295 }
296 #endregion
297
298 #region Métodos auxiliares y propiedades públicas
299
300 /// <resumen>
301 /// Obtener la cadena de hipervínculo del botón de navegación de paginación
302 /// </summary>
303 /// <param name="pageIndex">El índice de página correspondiente al botón de paginación</param>
304 /// <returns>Cadena de hipervínculo del botón de navegación de paginación</returns>
305 cadena privada GetHrefString (int pageIndex)
306 {
URL de cadena 307 = Page.Request.RawUrl;
308
309 si (Regex.IsMatch(url, @"(d+).shtml", RegexOptions.IgnoreCase))
310 {
311 URL = Regex.Replace(url, @"(d+).shtml", pageIndex + ".shtml");
312 }
313
314 si (Regex.IsMatch(url, @"PageIndex=(d+)", RegexOptions.IgnoreCase))
315 {
316 URL = Regex.Replace(url, @"PageIndex=(d+)", "PageIndex=" + pageIndex.ToString());
317 }
318
319 retorno Page.Server.UrlPathEncode(url);
320 }
321
322 público int CalcularTotalPages()
323 {
324 int totalPáginas disponibles;
325
326 si (TotalRecords == 0)
327 devuelve 0;
328
329 totalPagesAvailable = TotalRecords / Tamaño de página;
330
331 si ((TotalRecords % Tamaño de página) > 0)
332 páginas en total disponibles++;
333
334 retorno totalPagesAvailable;
335 }
336
337 /// <resumen>
338 /// Página actual
339 /// </summary>
340 índice de página int público
341 {
342 obtener
343 {
344 int _pageIndex = 0;
345
346 si ((!Page.IsPostBack) && (context.PageIndex > 0))
347 _pageIndex = contexto.PageIndex;
348 más
349 _pageIndex = Convert.ToInt32(ViewState["PageIndex"]);
350
351 si (_pageIndex <0)
352 devuelve 0;
353 más
354 {
355 si (_pageIndex > CalculateTotalPages()-1)
356 return CalculateTotalPages()-1;
357 más
358 retorno _pageIndex;
359 }
360 }
361 conjunto
362 {
363 ViewState["PageIndex"] = valor;
364 }
365 }
366
367 /// <resumen>
368 ///Número de registros por página
369 /// </summary>
370 público int Tamaño de página
371 {
372 obtener
373 {
374 int tamaño de página = Convert.ToInt32(ViewState["Tamaño de página"]);
375
376 si (tamaño de página == 0)
377 {
378 devuelve 10;
379 }
380
381 volver tamaño de página;
382 }
383 juegos
384 {
385 ViewState["Tamaño de página"] = valor;
386 }
387
388 }
389
390 /// <resumen>
391 ///Número total de registros
392 /// </summary>
393 registros totales públicos int
394 {
395 obtener
396 {
397 return Convert.ToInt32(ViewState["TotalRecords"]);
398 }
399 juegos
400 {
401 ViewState["TotalRecords"] = valor;
402 }
403 }
404
405 texto de cadena privada = "Total {0} páginas";
406
407 cadena privada linkCss = "";
408 /// <resumen>
409 /// Estilo de enlace
410 /// </summary>
411 cadena pública LinkCss
412 {
413 obtener {enlace de retornoCss}
414 conjunto {enlaceCss = valor;}
415 }
416
417 cadena privada textCss = "";
418 /// <resumen>
419 /// Estilo de texto
420 /// </summary>
421 cadena pública TextCss
422 {
423 obtener {return textCss}
424 conjunto {textCss = valor;}
425 }
426
427 formato de texto de cadena pública
428 {
429 obtener
430 {
431 texto de retorno;
432 }
433 juegos
434 {
435 texto = valor;
436 }
437 }
438
439 #regiónend
440 }
441 }
442
Simplemente escribe esto en la página:
1 <%@ Idioma de control="c#" %>
2 <%@ Registrar TagPrefix="Anchor" Namespace="MiEmpresa.Controls" Asamblea="MiEmpresa.Controles" %>
3 <ANCHOR:PAGER id="Pager1" runat="servidor"></ANCHOR:PAGER>
4