擴展方法學習發展之路

時間 2019-11-18

標籤擴展方法學習發展之路简体版

原文原文鏈接

大學學習的java,工做後轉成了C#，因爲工做須要，全力去學習了C#，學習中，相信你們都會有相同的疑惑，在判斷一個字符串是否爲空的時候總會用到string.IsNullOrEmpty(s)這個方法，最開始就想到了是否是反射，後面才知道這是c#的擴展方法，後面的內容慢慢講解我對擴展方法由淺到深的理解與用法。javascript

1：擴展方法的自定義實現，我這裏特別用到了判斷類型是否爲數值類型的方法（能夠去比較學習下），裏面子定義了4個擴展方法html

 1 namespace ConsoleApplication1
 2 {
 3     class Program
 4     {
 5         static void Main(string[] args)
 6         {
 7             var i = 32;  
 8             System.Console.WriteLine(i.GetType().IsNumericType());
 9             System.Console.ReadKey();     
10         }
11     }
12 
13     public static class TestExtension
14     {
15         //老外的代碼
16         public static bool IsNumeric(this Type dataType)
17         {
18             if (dataType == null)
19                 throw new ArgumentNullException("dataType");
20 
21             return (dataType == typeof(int)
22                     || dataType == typeof(double)
23                     || dataType == typeof(long)
24                     || dataType == typeof(short)
25                     || dataType == typeof(float)
26                     || dataType == typeof(Int16)
27                     || dataType == typeof(Int32)
28                     || dataType == typeof(Int64)
29                     || dataType == typeof(uint)
30                     || dataType == typeof(UInt16)
31                     || dataType == typeof(UInt32)
32                     || dataType == typeof(UInt64)
33                     || dataType == typeof(sbyte)
34                     || dataType == typeof(Single)
35                    );
36         }
37         /// <summary>
38         /// 判斷是否爲數值類型。
39         /// </summary>
40         /// <param name="t">要判斷的類型</param>
41         /// <returns>是否爲數值類型</returns>
42         public static bool IsNumericType(this Type t)
43         {
44             var tc = Type.GetTypeCode(t);
45             return (t.IsPrimitive && t.IsValueType && !t.IsEnum && tc != TypeCode.Char && tc != TypeCode.Boolean) || tc == TypeCode.Decimal;
46         }
47 
48         /// <summary>
49         /// 判斷是否爲可空數值類型。
50         /// </summary>
51         /// <param name="t">要判斷的類型</param>
52         /// <returns>是否爲可空數值類型</returns>
53         public static bool IsNumericOrNullableNumericType(this Type t)
54         {
55             return t.IsNumericType() || (t.IsNullableType() && t.GetGenericArguments()[0].IsNumericType());
56         }
57 
58         /// <summary>
59         /// 判斷是否爲可空類型。
60         /// 注意，直接調用可空對象的.GetType()方法返回的會是其泛型值的實際類型，用其進行此判斷確定返回false。
61         /// </summary>
62         /// <param name="t">要判斷的類型</param>
63         /// <returns>是否爲可空類型</returns>
64         public static bool IsNullableType(this Type t)
65         {
66             return t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>);
67         }
68 
69     }
70 }

2：經過上面的列子可能就只能看出它使用上更爲便捷而已，但當我接觸到Linq,才發現擴展方法的強大，本身也學着參考改造下Linq的構造方法以增長增長所須要的功能前端

 1 public static class QueryableExtensions
 2     {
 3         public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName)
 4         {
 5             return QueryableHelper<T>.OrderBy(queryable, propertyName, false);
 6         }
 7         public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName, bool desc)
 8         {
 9             return QueryableHelper<T>.OrderBy(queryable, propertyName, desc);
10         }
11      
12         static class QueryableHelper<T>
13         {
14             //爲了緩存表達式樹
15             private static Dictionary<string, LambdaExpression> cache = new Dictionary<string, LambdaExpression>();
16             public static IQueryable<T> OrderBy(IQueryable<T> queryable, string propertyName, bool   desc)
17             {
18 
19                 dynamic keySelector = GetLambdaExpression(propertyName);
20                 return desc ? Queryable.OrderByDescending(queryable, keySelector) : Queryable.OrderBy(queryable, keySelector);
21             }
22             private static LambdaExpression GetLambdaExpression(string propertyName)
23             {
24                 if (cache.ContainsKey(propertyName)) return cache[propertyName];
25                 var param = Expression.Parameter(typeof(T));
26                 var body = Expression.Property(param, propertyName);
27                 var keySelector = Expression.Lambda(body, param);
28                 cache[propertyName] = keySelector;
29                 return keySelector;
30             }
31         }
32     }

4：對於數據庫的操做，也可使用擴展方法，我上篇隨筆也說了，項目用了IOC，沒有在數據庫這塊用到擴展方法，這能夠參考http://www.cnblogs.com/xiaotuni/archive/2012/05/29/2523683.htmljava

5：當使用到MVC框架的時候，看到前端的頁面使用Html.BeginForm等一些相同格式語法的時候，我立刻意識到這就是MVC裏面的擴展方法，轉而想是否能夠本身也寫一些擴展方法，方便本身使用，首先我想到前端Table的遍歷，分頁等，並着手所有實現，並應用於項目中web

Table的遍歷，咱們在後臺寫好一個擴展方法類數據庫

 1  public static class RazorExtensions
 2     {
 3         public static HelperResult /*List*/ Repeat<T>(this IEnumerable<T> items,
 4             Func<T, HelperResult> template)
 5         {
 6             if (items == null) 
 7                 return new HelperResult(t => t.Write(""));
 8 
 9             return new HelperResult(writer =>
10             {
11                 foreach (var item in items)
12                 {
13                     template(item).WriteTo(writer);
14                 }
15             });
16         }
17 }

前端咱們引用他的命名空間，以下方式調用：c#

<tbody>
                @Model.Repeat(
                    @<tr>
                         <td><ahref="/order/catalog/new/@item.ContractNo">@item.ContractNo</a></td>  
                         <td>@item.StrokeNo</td>
                         <td>@item.StrokeDesc</td>                  
                         <td>@item.ContractStatus</td>
                         <td>@item.DeptNo</td>
                         <td>@item.Season</td>
                         <td>@item.SupplierSeries</td>
                         <td>@item.CountryCode</td>
                         <td>@item.ProductDesc</td>
                         <td>@item.DateLastModified</td>
                         <td>@item.CreatedTime.Format()</td>
                     </tr>)
            </tbody>

分頁控件的實現：緩存

後臺：首先咱們必須有一個page類app

namespace WebPrint.Web.Mvc.Pager
{
    public class PagerOptions
    {
        public PagerOptions()
        {
            AutoHide = true;
            PageIndexParameterName = "pageindex";
            NumericPagerItemCount = 10;
            AlwaysShowFirstLastPageNumber = false;
            ShowPrevNext = true;
            NextPageText = "&gt;";
            PrevPageText = "&lt;";
            ShowNumericPagerItems = true;
            ShowFirstLast = true;
            FirstPageText = "&lt;&lt;";
            LastPageText = "&gt;&gt";
            ShowMorePagerItems = true;
            MorePageText = "...";
            ShowDisabledPagerItems = true;
            PagerItemsSeperator = "  ";
            ContainerTagName = "div";
            InvalidPageIndexErrorMessage = "頁索引無效";
            PageIndexOutOfRangeErrorMessage = "頁索引超出範圍";
            MaxPageIndex = 0;
            FirstPageRouteName = null;
        }
        /// <summary>
        /// 首頁使用的路由名稱（無頁索引參數）
        /// </summary>
        public string FirstPageRouteName { get; set; }
        /// <summary>
        /// 當總頁數只有一頁時是否自動隱藏
        /// </summary>
        public bool AutoHide { get; set; }
        /// <summary>
        /// 頁索引超出範圍時顯示的錯誤消息
        /// </summary>
        public string PageIndexOutOfRangeErrorMessage { get; set; }
        /// <summary>
        /// 頁索引無效時顯示的錯誤消息
        /// </summary>
        public string InvalidPageIndexErrorMessage { get; set; }
        /// <summary>
        /// url中頁索引參數的名稱
        /// </summary>
        public string PageIndexParameterName { get; set; }

        private string _containerTagName;
        /// <summary>
        /// 分頁控件html容器標籤名，默認爲div
        /// </summary>
        public string ContainerTagName
        {
            get
            {
                return _containerTagName;
            }
            set
            {
                if (string.IsNullOrEmpty(value))
                    throw new System.ArgumentException("ContainerTagName不能爲null或空字符串", "ContainerTagName");
                _containerTagName = value;
            }
        }
        /// <summary>
        /// whether or not show first and last numeric page number
        /// </summary>
        public bool AlwaysShowFirstLastPageNumber { get; set; }
        /// <summary>
        /// 顯示的最大數字頁索引按鈕數
        /// </summary>
        public int NumericPagerItemCount { get; set; }
        /// <summary>
        /// 是否顯示上頁和下頁
        /// </summary>
        public bool ShowPrevNext { get; set; }
        /// <summary>
        /// 上一頁文本
        /// </summary>
        public string PrevPageText { get; set; }
        /// <summary>
        /// 下一頁文本
        /// </summary>
        public string NextPageText { get; set; }
        /// <summary>
        /// 是否顯示數字頁索引按鈕及更多頁按鈕
        /// </summary>
        public bool ShowNumericPagerItems { get; set; }
        /// <summary>
        /// 是否顯示第一頁和最後一頁
        /// </summary>
        public bool ShowFirstLast { get; set; }
        /// <summary>
        /// 第一頁文本
        /// </summary>
        public string FirstPageText { get; set; }
        /// <summary>
        /// 最後一頁文本
        /// </summary>
        public string LastPageText { get; set; }
        /// <summary>
        /// 是否顯示更多頁按鈕
        /// </summary>
        public bool ShowMorePagerItems { get; set; }
        /// <summary>
        /// 更多頁按鈕文本
        /// </summary>
        public string MorePageText { get; set; }
        /// <summary>
        /// 包含分頁控件的父容器標籤的ID
        /// </summary>
        public string Id { get; set; }
        /// <summary>
        /// CSS樣式類
        /// </summary>
        public string CssClass { get; set; }
        /// <summary>
        /// whether or not show disabled navigation buttons
        /// </summary>
        public bool ShowDisabledPagerItems { get; set; }
        /// <summary>
        /// 分頁元素之間的分隔符，默認爲兩個html空格（  ）
        /// </summary>
        public string PagerItemsSeperator { get; set; }
        /// <summary>
        /// 限制顯示的最大頁數，默認值爲0，即根據總記錄數算出的總頁數
        /// </summary>
        public int MaxPageIndex { get; set; }
    }
}

2個生成分頁控件HTML代碼的類框架

using System;
using System.Web.Mvc;
using System.Web.Routing;
using WebPrint.Model.Helper;

namespace WebPrint.Web.Mvc.Pager
{
    public static class PagerHelper
    {
        #region Html Pager

        private static MvcHtmlString Pager(this HtmlHelper helper, int totalItemCount, int pageSize, int pageIndex,
            string actionName, string controllerName,
            PagerOptions pagerOptions, string routeName, object routeValues, object htmlAttributes)
        {
            var totalPageCount = (int) Math.Ceiling(totalItemCount/(double) pageSize);
            var builder = new PagerBuilder
                (
                helper,
                actionName,
                controllerName,
                totalItemCount,
                totalPageCount,
                pageIndex,
                pageSize,
                pagerOptions,
                routeName,
                new RouteValueDictionary(routeValues),
                new RouteValueDictionary(htmlAttributes)
                );
            return builder.RenderPager();
        }

        public static MvcHtmlString Pager(this HtmlHelper helper, IPagedList pagedList, PagerOptions pagerOptions)
        {
            //if (pagedList == null)
            //    return Pager(helper, pagerOptions, null);
            return Pager(helper, pagedList.RecordsCount, pagedList.PageSize, pagedList.PageIndex, null, null,
                pagerOptions, null, null, null);
        }

        #endregion
    }
}


/*
 ASP.NET MvcPager 分頁組件
 Copyright@楊濤\Webdiyer (http://www.webdiyer.com)
 Source code released under Ms-PL license
 */

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace WebPrint.Web.Mvc.Pager
{
    internal class PagerBuilder
    {
        private readonly HtmlHelper html;
        private readonly string actionName;
        private readonly string controllerName;
        private readonly int totalPageCount = 1;
        private readonly int totalRecordCount = 1;
        private readonly int pageIndex;
        private readonly int pageSize;
        private readonly PagerOptions pagerOptions;
        private readonly RouteValueDictionary routeValues;
        private readonly string routeName;
        private readonly int startPageIndex = 1;
        private readonly int endPageIndex = 1;
        private IDictionary<string, object> htmlAttributes;

        private const string CopyrightText =
            "\r\n<!--MvcPager v2.0 for ASP.NET MVC 4.0+ © 2009-2013 Webdiyer (http://www.webdiyer.com)-->\r\n";

        /// <summary>
        /// 適用於PagedList爲null時
        /// </summary>
        //internal PagerBuilder(HtmlHelper html,PagerOptions pagerOptions, IDictionary<string, object> htmlAttributes)
        //{
        //    if (pagerOptions == null)
        //        pagerOptions = new PagerOptions();
        //    this.html = html;
        //    this.pagerOptions = pagerOptions;
        //    this.htmlAttributes = htmlAttributes;
        //}
        internal PagerBuilder(HtmlHelper html, string actionName, string controllerName, int totalRecordCount,
            int totalPageCount, int pageIndex, int pageSize, PagerOptions pagerOptions, string routeName,
            RouteValueDictionary routeValues,
            IDictionary<string, object> htmlAttributes)
        {
            if (pagerOptions == null)
                pagerOptions = new PagerOptions();
            this.html = html;
            this.actionName = actionName;
            this.controllerName = controllerName;
            this.totalRecordCount = totalRecordCount;
            if (pagerOptions.MaxPageIndex == 0 || pagerOptions.MaxPageIndex > totalPageCount)
                this.totalPageCount = totalPageCount;
            else
                this.totalPageCount = pagerOptions.MaxPageIndex;
            this.pageIndex = pageIndex;
            this.pageSize = pageSize;
            this.pagerOptions = pagerOptions;
            this.routeName = routeName;
            this.routeValues = routeValues;
            this.htmlAttributes = htmlAttributes;
            // start page index
            startPageIndex = pageIndex - (pagerOptions.NumericPagerItemCount/2);
            if (startPageIndex + pagerOptions.NumericPagerItemCount > this.totalPageCount)
                startPageIndex = this.totalPageCount + 1 - pagerOptions.NumericPagerItemCount;
            if (startPageIndex < 1)
                startPageIndex = 1;
            // end page index
            endPageIndex = startPageIndex + this.pagerOptions.NumericPagerItemCount - 1;
            if (endPageIndex > this.totalPageCount)
                endPageIndex = this.totalPageCount;
        }

        private void AddPrevious(ICollection<PagerItem> results)
        {
            var item = new PagerItem(pagerOptions.PrevPageText, pageIndex - 1, pageIndex == 1, PagerItemType.PrevPage);
            if (!item.Disabled || (item.Disabled && pagerOptions.ShowDisabledPagerItems))
                results.Add(item);
        }

        private void AddFirst(ICollection<PagerItem> results)
        {
            var item = new PagerItem(pagerOptions.FirstPageText, 1, pageIndex == 1, PagerItemType.FirstPage);
            //只有導航按鈕未被禁用，或導航按鈕被禁用但ShowDisabledPagerItems=true時才添加
            if (!item.Disabled || (item.Disabled && pagerOptions.ShowDisabledPagerItems))
                results.Add(item);
        }

        private void AddMoreBefore(ICollection<PagerItem> results)
        {
            if (startPageIndex > 1 && pagerOptions.ShowMorePagerItems)
            {
                var index = startPageIndex - 1;
                if (index < 1) index = 1;
                var item = new PagerItem(pagerOptions.MorePageText, index, false, PagerItemType.MorePage);
                results.Add(item);
            }
        }

        private void AddPageNumbers(ICollection<PagerItem> results)
        {
            for (var pageIndex = startPageIndex; pageIndex <= endPageIndex; pageIndex++)
            {
                var text = pageIndex.ToString(CultureInfo.InvariantCulture);
                //if (pageIndex == this.pageIndex && !string.IsNullOrEmpty(pagerOptions.CurrentPageNumberFormatString))
                //    text = String.Format(pagerOptions.CurrentPageNumberFormatString, text);
                //else if (!string.IsNullOrEmpty(pagerOptions.PageNumberFormatString))
                //    text = String.Format(pagerOptions.PageNumberFormatString, text);
                var item = new PagerItem(text, pageIndex, false, PagerItemType.NumericPage);
                results.Add(item);
            }
        }

        private void AddMoreAfter(ICollection<PagerItem> results)
        {
            if (endPageIndex < totalPageCount)
            {
                var index = startPageIndex + pagerOptions.NumericPagerItemCount;
                if (index > totalPageCount)
                {
                    index = totalPageCount;
                }
                var item = new PagerItem(pagerOptions.MorePageText, index, false, PagerItemType.MorePage);
                results.Add(item);
            }
        }

        private void AddNext(ICollection<PagerItem> results)
        {
            var item = new PagerItem(pagerOptions.NextPageText, pageIndex + 1, pageIndex >= totalPageCount,
                PagerItemType.NextPage);
            if (!item.Disabled || (item.Disabled && pagerOptions.ShowDisabledPagerItems))
                results.Add(item);
        }

        private void AddLast(ICollection<PagerItem> results)
        {
            var item = new PagerItem(pagerOptions.LastPageText, totalPageCount, pageIndex >= totalPageCount,
                PagerItemType.LastPage);
            if (!item.Disabled || (item.Disabled && pagerOptions.ShowDisabledPagerItems))
                results.Add(item);
        }

        /// <summary>
        /// 根據頁索引生成分頁導航Url
        /// </summary>
        /// <param name="pageIndex">要生成導航連接的頁索引</param>
        /// <returns>分頁導航連接Url</returns>
        private string GenerateUrl(int pageIndex)
        {
            ViewContext viewContext = html.ViewContext;
            //若要生成url的頁索引小於1或大於總頁數或等於當前頁索引時，無需生成分頁導航連接
            if (pageIndex > totalPageCount || pageIndex == this.pageIndex)
                return null;
            var routeValues1 = new RouteValueDictionary(viewContext.RouteData.Values);
            AddQueryStringToRouteValues(routeValues1, viewContext);
            if (this.routeValues != null && this.routeValues.Count > 0)
            {
                foreach (var de in this.routeValues)
                {
                    if (!routeValues1.ContainsKey(de.Key))
                    {
                        routeValues1.Add(de.Key, de.Value);
                    }
                    else
                    {
                        routeValues1[de.Key] = de.Value; //手動添加的RouteValues具備高優先級
                    }
                }
            }
            var pageValue = viewContext.RouteData.Values[pagerOptions.PageIndexParameterName];
            string routeName = this.routeName;
            // 設置Route Value中的分頁導航Url參數值，pageIndex爲0時生成適用於腳本的導航連接
            if (pageIndex == 0)
                routeValues1[pagerOptions.PageIndexParameterName] = "__" + pagerOptions.PageIndexParameterName + "__";
            else
            {
                if (pageIndex == 1)
                {
                    if (!string.IsNullOrWhiteSpace(pagerOptions.FirstPageRouteName))
                        //若是顯式指定了FirstPageRouteName，則使用此Route
                    {
                        routeName = pagerOptions.FirstPageRouteName;
                        routeValues1.Remove(pagerOptions.PageIndexParameterName); //去除頁索引參數
                        viewContext.RouteData.Values.Remove(pagerOptions.PageIndexParameterName);
                    }
                    else
                    {
                        var curRoute = viewContext.RouteData.Route as Route;
                        //判斷當前Route是否爲Route類型，若是是，則判斷該Route中頁索引參數默認值是否爲UrlParameter.Optional，或頁索引參數是否存在於該Route Url的參數列表中，若是參數默認值爲UrlParameter.Optional或分頁參數名不存在於Route Url參數中，則從當前的RouteValue列表中去除該參數
                        if (curRoute != null &&
                            (curRoute.Defaults[pagerOptions.PageIndexParameterName] == UrlParameter.Optional ||
                             !curRoute.Url.Contains("{" + pagerOptions.PageIndexParameterName + "}")))
                        {
                            routeValues1.Remove(pagerOptions.PageIndexParameterName); //去除頁索引參數
                            viewContext.RouteData.Values.Remove(pagerOptions.PageIndexParameterName);
                        }
                        else
                        {
                            routeValues1[pagerOptions.PageIndexParameterName] = pageIndex;
                        }
                    }
                }
                else
                {
                    routeValues1[pagerOptions.PageIndexParameterName] = pageIndex;
                }
            }
            var routes = html.RouteCollection;
            string url;
            if (!string.IsNullOrEmpty(routeName))
                url = UrlHelper.GenerateUrl(routeName, actionName, controllerName, routeValues1, routes,
                    viewContext.RequestContext, false);
            else
                url = UrlHelper.GenerateUrl(null, actionName, controllerName, routeValues1, routes,
                    viewContext.RequestContext, false);
            if (pageValue != null)
                viewContext.RouteData.Values[pagerOptions.PageIndexParameterName] = pageValue;
            return url;
        }

        /// <summary>
        /// 生成最終的分頁Html代碼
        /// </summary>
        /// <returns></returns>
        internal MvcHtmlString RenderPager()
        {
            //return null if total page count less than or equal to 1
            if (totalPageCount <= 1 && pagerOptions.AutoHide)
                return MvcHtmlString.Create(CopyrightText);
            //Display error message if pageIndex out of range
            if ((pageIndex > totalPageCount && totalPageCount > 0) || pageIndex < 1)
            {
                return
                    MvcHtmlString.Create(string.Format("{0}<div style=\"color:red;font-weight:bold\">{1}</div>{0}",
                        CopyrightText, pagerOptions.PageIndexOutOfRangeErrorMessage));
            }

            var pagerItems = new List<PagerItem>();
            //First page
            if (pagerOptions.ShowFirstLast)
                AddFirst(pagerItems);
            // Prev page
            if (pagerOptions.ShowPrevNext)
                AddPrevious(pagerItems);
            if (pagerOptions.ShowNumericPagerItems)
            {
                if (pagerOptions.AlwaysShowFirstLastPageNumber && startPageIndex > 1)
                    pagerItems.Add(new PagerItem("1", 1, false, PagerItemType.NumericPage));
                // more page before numeric page buttons
                if (pagerOptions.ShowMorePagerItems &&
                    ((!pagerOptions.AlwaysShowFirstLastPageNumber && startPageIndex > 1) ||
                     (pagerOptions.AlwaysShowFirstLastPageNumber && startPageIndex > 2)))
                    AddMoreBefore(pagerItems);
                // numeric page
                AddPageNumbers(pagerItems);
                // more page after numeric page buttons
                if (pagerOptions.ShowMorePagerItems &&
                    ((!pagerOptions.AlwaysShowFirstLastPageNumber && endPageIndex < totalPageCount) ||
                     (pagerOptions.AlwaysShowFirstLastPageNumber && totalPageCount > endPageIndex + 1)))
                    AddMoreAfter(pagerItems);
                if (pagerOptions.AlwaysShowFirstLastPageNumber && endPageIndex < totalPageCount)
                    pagerItems.Add(new PagerItem(totalPageCount.ToString(CultureInfo.InvariantCulture), totalPageCount,
                        false,
                        PagerItemType.NumericPage));
            }
            // Next page
            if (pagerOptions.ShowPrevNext)
                AddNext(pagerItems);
            //Last page
            if (pagerOptions.ShowFirstLast)
                AddLast(pagerItems);
            var sb = new StringBuilder();

            foreach (PagerItem item in pagerItems)
            {
                sb.Append(GeneratePagerElement(item));
            }

            var tb = new TagBuilder(pagerOptions.ContainerTagName);
            if (!string.IsNullOrEmpty(pagerOptions.Id))
                tb.GenerateId(pagerOptions.Id);
            if (!string.IsNullOrEmpty(pagerOptions.CssClass))
                tb.AddCssClass(pagerOptions.CssClass);
            tb.MergeAttributes(htmlAttributes, true);
            sb.Length -= pagerOptions.PagerItemsSeperator.Length;

            var startRecords = ((pageIndex - 1)*pageSize) + 1;
            var endRecords = pageIndex*pageSize;
            if (endRecords > totalRecordCount)
                endRecords = totalRecordCount;

            var recordsCountText =
                string.Format("<span class=\"summary\">{0}&nbsp;-&nbsp;{1},&nbsp;{2}&nbsp;records</span>",
                    startRecords, endRecords, totalRecordCount);
            tb.InnerHtml = sb.ToString() + recordsCountText;

            return
                MvcHtmlString.Create(CopyrightText + /*pagerScript +*/ tb.ToString(TagRenderMode.Normal) + CopyrightText);
        }

        private MvcHtmlString GeneratePagerElement(PagerItem item)
        {
            //pager item link
            string url = GenerateUrl(item.PageIndex);
            if (item.Disabled) //first,last,next or previous page
                return CreateWrappedPagerElement(item,
                    String.Format("<a class=\"disabled\" disabled=\"disabled\">{0}</a>", item.Text));
            return CreateWrappedPagerElement(item,
                string.IsNullOrEmpty(url)
                    ? HttpUtility.HtmlEncode(item.Text)
                    : String.Format("<a href=\"{0}\">{1}</a>", url, item.Text));
        }

        private MvcHtmlString CreateWrappedPagerElement(PagerItem item, string el)
        {
            string navStr = el;
            switch (item.Type)
            {
                case PagerItemType.FirstPage:
                case PagerItemType.LastPage:
                case PagerItemType.NextPage:
                case PagerItemType.PrevPage:
                    break;
                case PagerItemType.MorePage:
                    break;
                case PagerItemType.NumericPage:
                    if (item.PageIndex == pageIndex)
                    {
                        navStr = string.Format("<a href=\"javascript:void(0);\" class=\"current\">{0}</a>", el);
                    }
                    break;
            }
            return MvcHtmlString.Create(navStr + pagerOptions.PagerItemsSeperator);
        }

        private void AddQueryStringToRouteValues(RouteValueDictionary routeValues, ViewContext viewContext)
        {
            if (routeValues == null)
                routeValues = new RouteValueDictionary();
            var rq = viewContext.HttpContext.Request.QueryString;
            if (rq != null && rq.Count > 0)
            {
                var invalidParams = new[]
                {"x-requested-with", "xmlhttprequest", pagerOptions.PageIndexParameterName.ToLower()};
                foreach (string key in rq.Keys)
                {
                    // 添加url參數到路由中
                    if (!string.IsNullOrEmpty(key) && Array.IndexOf(invalidParams, key.ToLower()) < 0)
                    {
                        var kv = rq[key];
                        routeValues[key] = kv;
                    }
                }
            }
        }
    }
}

使用擴展方法：

public static MvcHtmlString Paginaton(this HtmlHelper helper, IPagedList pagedList)
        {
            var pagerOptions = new PagerOptions
            {
                PageIndexParameterName = "page",
                CssClass = "pagination",
                ShowFirstLast = false,
                AlwaysShowFirstLastPageNumber = true,
                ShowMorePagerItems = true,
                NumericPagerItemCount = 5,
                PagerItemsSeperator = string.Empty,
            };

            return helper.Pager(pagedList, pagerOptions);
        }

前端直接引用調用：

<div class="pagination_div">
   @Html.Paginaton(Model)
</div>

總結：相對於鶴沖天大哥的看法，我對於擴張方法的使用差的太遠，但通常的場景也能夠用到擴展方法的地方都仍是能夠輕鬆應對，因此咱們日常就該對深刻的學習認識他，才能在後面應用自如

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。