★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

 


 

第6章  庖丁解牛系列—页面状态机制(视图状态和控件状态)

 

 

本章内容

6.1 页面状态概述

6.2 视图状态机制

6.3 控件状态机制

6.4 视图状态和控件状态的关系

6.5 加密页面状态

6.6 清除页面状态

6.7 对动态添加控件的视图状态分析

6.8 自定义类型转换器实现高效率序列化

6.9 页面状态性能优化策略

6.10 视图状态和控件状态的总结

[点击下载本书word格式完整目录介绍]

6.1 页面状态概述

在ASP.NET技 术的服务器处理机制中，服务器每处理完客户端的一个请求就认为任务结束，当客户端再次请求时，服务器会将其作为一次新的请求处理，即使是相同的客户端也是 如此。也就是说服务器不会保存两次请求之间的一些前后相接的数据，这对开发人员经常实现一个前后衔接的操作来说就比较麻烦了，比如输入一些信息到一个文本 中，然后提交一个按钮，很多时候我们要在按钮提交的服务端事件中处理提交之前的数据和提交按钮时用户输入的最新数据，即想同时得到文本框的旧值和新值，但 是服务端不会保存前一个请求的任何信息，那怎么才能做到这一点呢？

两次页面请求之间的数据关联性，ASP.NET是通过视图机制实现的，简单地讲，视图区域信息（ViewState）存储于页面上的一个隐藏字段（名为__VIEWSTATE，只是视图状态中的值经过哈希计算和压缩，并且针对Unicode实现进行编码，其安全性要高于我们自己设置的隐藏域控件），每次需要视图机制保存的一些信息都存储在此字段中，每次提交时，它都会以“客户端到ó服务端”的形式来回传递一次，当处理完成后，最后会以处理后的新结果作为新的ViewState存储到页面中的隐藏字段，并与页面内容一起返回到客户端。

视图机制支持很多类型的数据存储，其中基本类型的有字符串、数字、布尔值、颜色、日期、字节，各种类型的数组等。视图机制已经对一些如ArrayList和哈希表集合等类型对象进行了优化；除了基本类型视图状态视图机制还支持自定义的类型，由于ViewState数据是作为序列化格式串存储的，因此默认情况下使用.NET Framework提供的二进制序列化功能来序列化对象，对于一些比较复杂的对象，一般都使用专门的类型转换器TypeConvert序列化，要比默认.NET提供的二进制序列化节省资源。关于TypeConvert类的实现在第4章已经讲了很多例子了，在后面会介绍类型转换器应用于视图状态的说明和示例。

为了提高性能，通常禁用页面或禁用服务端控件的状态视图，有些控件不需要维护其状态，如Label控件只是显示文本，而标签的文本，值不参与回发，可以设置其属性：EnableViewState=false；

如果整个页面控件都不需要维持状态视图，则可以设置整个页面的状态视图为false：<%@ Page EnableViewState="false"%>。

由于控件内部使用的视图状态，这样会导致视图状态失效，甚至会产生致命的问题-控件无法使用。说明一点，禁用视图是合法的，一个好的控件应该允许视图状态在适当情况下被开发人员禁用，并且仍然能够正确运行。

为了解决这个问题，ASP.NET 2.0开始支持控件状态机制。控件的状态数据现在能通过控件状态而不是视图状态被保持，控件状态是不能够被禁用的。如果控件中需要保存控件之间的逻辑，比如选项卡控件要记住每次回发时当前已经选中的索引SelectIndex时，就适合使用控件状态。当然ViewState属性完全可以满足此需求，如果视图状态被禁用的话，自定义控件就不能正确运行。控件状态的工作方式与视图状态完全一致，并且默认情况下在页面中它们都是存储在同一个隐藏域中。

总结一下，一般开发人员主要通过以下三种方式使用ASP.NET视图：

1．使用基类提供的ViewState对象

直接访问基类Control中的ViewState对象，类型为StateBag，以键/值对的形式存储数据

2．自定义类型视图状态。

重写控件的默认方法（SaveViewState，LoadViewState），实现自定义类型的视图状态。一般需要与属性对应类类型的视图状态配合使用，类类型视图状态可能通过实现IStateManager接口的几个成员（方法和属性）实现。

3．控件状态

它也提供了可重写的方法（SaveControlState，LoadControlState），实现控件中属性的控件状态。

视图状态数据在每次请求过程中都要在客户端和服务端来回传递，因此在开发过程中要确保数据量不要太大，否则会出现网络传输瓶颈。

从下节开始，详细讲解页面状态（视图状态和控件状态）的内部机制，以及它们在自定义控件中的应用。

6.2 视图状态机制

6.2.1 IStateManager接口

.NET框架为自定义视图状态管理提供了System.Web.UI.IStateManager接口，定义了任何类为支持服务器控件的视图状态管理而必须实现的属性和方法，服务器控件的视图状态由控件属性的累计值组成。该接口包括保存并加载服务器控件的视图状态值的方法，以及一个指示控件跟踪其视图状态的更改的方法。此接口的成员与Control类中的对应方法具有相同的语义。

若要自定义ASP.NET应用程序管理服务器控件视图状态的方式，必须创建一个实现此接口的类。代码如下：

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public interface IStateManager

  11. {

  13.     // Methods

  15.     object SaveViewState();

  17.     void LoadViewState(object state);

  19.     void TrackViewState();



  23.     // Properties

  25.     bool IsTrackingViewState { get; }

  27. }

该接口包括以下几个成员：

Ø SaveViewState：保存自从页回发到服务器后发生的所有服务器控件视图状态更改，最后返回最新更改后的视图状态对象。如果没有与控件关联的视图状态，则此方法返回空。保存了视图状态后，页面类会把所有控件的视图状态对象转换为可以通过网络传输的Base64格式字符串形式，最终该字符串对象作为存储在Hidden元素中的变量返回给客户端。使用自定义视图状态时，一般使用SaveViewState和LoadViewState组合完成状态管理。

Ø LoadViewState：把SaveViewState方法保存的上一个页面的视图信息还原到控件复杂属性中。

Ø TrackViewState：在服务器控件的生存期内，将在Init事件结束时自动调用该方法。在开发模板数据绑定控件时调用此方法。此方法提醒ASP.NET监视服务器控件视图状态的更改。如果控件没调用TrackViewState()方法，则本次对控件属性的修改将不会被添加到__VIEWSTATE隐藏域中，下次页面回发时，控件的属性只恢复为之前的旧值。从性能角度讲，为了减少在网络上的传输量，应该只保存“变化”的数据到视图状态中，即仅对需要保存到视图中的数据才调用此方法。其实TrackViewState只是控制一个布尔值作标记，往视图中增加数据时，会判断该值是否为true，如果为true才将其加入视图数据。下节讲解StateBag类时还会说明其内部原理。

Ø IsTrackingViewState：返回当前控件视图是否被ASP.NET框架监视（是否存储该属性到视图中，与TrackViewState方法控制的是同一个标记）。

或许读者会想到，之前在开发控件时使用过视图存储属性值，如ViewState["Text"]，而没有使用IStateManager接口控件为什么这样也能够正确保存值呢？在后面的6.2.3小节会说明其原因，事实上它也是使用了IStateManger接口，只是Control提供了更方便的管理而已。

6.2.2 控件生命周期中的装载和保存视图阶段

在第1章中讲过控件周期阶段，其中就包括视图状态的阶段，如图6-1所示。

从图6-1中可以看到LoadViewState和SaveViewState分别在控件生命周期的开始（初始化Init后）和最后（呈现Render之前）。这样我们可以在其间的一些周期阶段操作视图状态数据。而在控件的基类Control中已经提供了对这两个方法的支持。

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-1 控件生命周期中的视图装载和保存阶段

 

对于自定义的类型，仅实现IStateManager接口的方法是不够的（该方法仅使自定义类具有正反序列化的能力），还需要由主控件的控件生命周期方法来引发调用它们，才能够正确地装载和保存视图数据。这就要求主控件直接或间接继承Control类，并重载Control类中的LoadViewState和SaveViewState方法，这两个方法属于控件生命周期阶段方法，只要是属于控件生命周期的方法，则在控件生成阶段一定会被页框架调用。它们才是视图状态启动的导火线。

重载这两个方法如下所示：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public class ViewStatePeriod : WebControl

{

    protected override object SaveViewState()

    {

         //… …

    }

    protected override void LoadViewState(object savedState)

    {

        //… …

    }

}

 

u 另外，视图状态监视是在初始化Init阶段完成后启动的，之后就可以监控对视图的操作了。少数情况下，如果在视图状态打开之前想操作视图对象，则要手动启用跟踪：

 

if (this.IsTrackingViewState == false)

{

    this.TrackViewState();

    ... ...//操作视图

}

6.2.3 简单类型视图状态应用

视图状态默认支持很多类型的数据存储，其中基本类型的有字符串、数字、布尔值、颜色、日期、字节，以及各种类型的数组等。以下是一个最常见的典型用法：

public string Text

{

    get

    {

        String s = (String)ViewState["Text"];

        return ((s == null) ? String.Empty : s);

    }

 

    set

    {

        ViewState["Text"] = value;

    }

}

 

u 在上面代码中有个ViewState的对象，此对象没有多么深奥，只是基类Control中定义的一个属性。追溯到它的基类定义，代码如下：

private StateBag _viewState;

[WebSysDescription("Control_State"), Browsable(false), Designer Serializa

tionVisibility(DesignerSerializationVisibility.Hidden)]

protected virtual StateBag ViewState

{

   get

    {

        if (this._viewState == null)

        {

            this._viewState = new StateBag(this.ViewStateIgnoresCase);

            if (this.IsTrackingViewState)

            {

                this._viewState.TrackViewState();

            }

        }

        return this._viewState;

    }

}

 

u 这是一个标准的自定义类型属性。再仔细看一下，该属性的类型为StateBage类，这才是我们要找的关键类，它的代码结构如下：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public sealed class StateBag : IStateManager, IDictionary, ICollection, IEnumerable

  11. {

  13.     // Fields

  15.     private IDictionary bag;

  17.     private bool ignoreCase;

  19.     private bool marked;



  23.     // Methods

  25.     public StateBag()

  27.         : this(false)

  29.     {

  31.     }



  35.     public StateBag(bool ignoreCase)

  37.     {

  39.         this.marked = false;

  41.         this.ignoreCase = ignoreCase;

  43.         this.bag = this.CreateBag();

  45.     }



  49.     public StateItem Add(string key, object value)

  51.     {

  53.         if (string.IsNullOrEmpty(key))

  55.         {

  57.             throw ExceptionUtil.ParameterNullOrEmpty("key");

  59.         }

  61.         StateItem item = this.bag[key] as StateItem;

  63.         if (item == null)

  65.         {

  67.             if ((value != null) || this.marked)

  69.             {

  71.                 item = new StateItem(value);

  73.                 this.bag.Add(key, item);

  75.             }

  77.         }

  79.         else if ((value == null) && !this.marked)

  81.         {

  83.             this.bag.Remove(key);

  85.         }

  87.         else

  89.         {

  91.             item.Value = value;

  93.         }

  95.         if ((item != null) && this.marked)

  97.         {

  99.             item.IsDirty = true;

  101.         }

  103.         return item;

  105.     }



  109.     public void Clear()

  111.     {

  113.         this.bag.Clear();

  115.     }



  119.     private IDictionary CreateBag()

  121.     {

  123.         return new HybridDictionary(this.ignoreCase);

  125.     }



  129.     public IDictionaryEnumerator GetEnumerator()

  131.     {

  133.         return this.bag.GetEnumerator();

  135.     }



  139.     public bool IsItemDirty(string key)

  141.     {

  143.         StateItem item = this.bag[key] as StateItem;

  145.         return ((item != null) && item.IsDirty);

  147.     }



  151.     internal void LoadViewState(object state)

  153.     {

  155.         if (state != null)

  157.         {

  159.             ArrayList list = (ArrayList)state;

  161.             for (int i = 0; i < list.Count; i += 2)

  163.             {

  165.                 string key = ((IndexedString)list[i]).Value;

  167.                 object obj2 = list[i + 1];

  169.                 this.Add(key, obj2);

  171.             }

  173.         }

  175.     }



  179.     public void Remove(string key)

  181.     {

  183.         this.bag.Remove(key);

  185.     }



  189.     internal object SaveViewState()

  191.     {

  193.         ArrayList list = null;

  195.         if (this.bag.Count != 0)

  197.         {

  199.             IDictionaryEnumerator enumerator = this.bag.GetEnumerator();

  201.             while (enumerator.MoveNext())

  203.             {

  205.                 StateItem item = (StateItem)enumerator.Value;

  207.                 if (item.IsDirty)

  209.                 {

  211.                     if (list == null)

  213.                     {

  215.                         list = new ArrayList();

  217.                     }

  219.                     list.Add(new IndexedString((string)enumerator.Key));

  221.                     list.Add(item.Value);

  223.                 }

  225.             }

  227.         }

  229.         return list;

  231.     }



  235.     public void SetDirty(bool dirty)

  237.     {

  239.         if (this.bag.Count != 0)

  241.         {

  243.             foreach (StateItem item in this.bag.Values)

  245.             {

  247.                 item.IsDirty = dirty;

  249.             }

  251.         }

  253.     }



  257.     public void SetItemDirty(string key, bool dirty)

  259.     {

  261.         StateItem item = this.bag[key] as StateItem;

  263.         if (item != null)

  265.         {

  267.             item.IsDirty = dirty;

  269.         }

  271.     }



  275.     void ICollection.CopyTo(Array array, int index)

  277.     {

  279.         this.Values.CopyTo(array, index);

  281.     }



  285.     void IDictionary.Add(object key, object value)

  287.     {

  289.         this.Add((string)key, value);

  291.     }



  295.     bool IDictionary.Contains(object key)

  297.     {

  299.         return this.bag.Contains((string)key);

  301.     }



  305.     void IDictionary.Remove(object key)

  307.     {

  309.         this.Remove((string)key);

  311.     }



  315.     IEnumerator IEnumerable.GetEnumerator()

  317.     {

  319.         return this.GetEnumerator();

  321.     }



  325.     void IStateManager.LoadViewState(object state)

  327.     {

  329.         this.LoadViewState(state);

  331.     }



  335.     object IStateManager.SaveViewState()

  337.     {

  339.         return this.SaveViewState();

  341.     }



  345.     void IStateManager.TrackViewState()

  347.     {

  349.         this.TrackViewState();

  351.     }



  355.     internal void TrackViewState()

  357.     {

  359.         this.marked = true;

  361.     }



  365.     // Properties

  367.     public int Count

  369.     {

  371.         get

  373.         {

  375.             return this.bag.Count;

  377.         }

  379.     }



  383.     internal bool IsTrackingViewState

  385.     {

  387.         get

  389.         {

  391.             return this.marked;

  393.         }

  395.     }



  399.     public object this[string key]

  401.     {

  403.         get

  405.         {

  407.             if (string.IsNullOrEmpty(key))

  409.             {

  411.                 throw ExceptionUtil.ParameterNullOrEmpty("key");

  413.             }

  415.             StateItem item = this.bag[key] as StateItem;

  417.             if (item != null)

  419.             {

  421.                 return item.Value;

  423.             }

  425.             return null;

  427.         }

  429.         set

  431.         {

  433.             this.Add(key, value);

  435.         }

  437.     }



  441.     public ICollection Keys

  443.     {

  445.         get

  447.         {

  449.             return this.bag.Keys;

  451.         }

  453.     }



  457.     bool ICollection.IsSynchronized

  459.     {

  461.         get

  463.         {

  465.             return false;

  467.         }

  469.     }



  473.     object ICollection.SyncRoot

  475.     {

  477.         get

  479.         {

  481.             return this;

  483.         }

  485.     }



  489.     bool IDictionary.IsFixedSize

  491.     {

  493.         get

  495.         {

  497.             return false;

  499.         }

  501.     }



  505.     bool IDictionary.IsReadOnly

  507.     {

  509.         get

  511.         {

  513.             return false;

  515.         }

  517.     }



  521.     object IDictionary.this[object key]

  523.     {

  525.         get

  527.         {

  529.             return this[(string)key];

  531.         }

  533.         set

  535.         {

  537.             this[(string)key] = value;

  539.         }

  541.     }



  545.     bool IStateManager.IsTrackingViewState

  547.     {

  549.         get

  551.         {

  553.             return this.IsTrackingViewState;

  555.         }

  557.     }



  561.     public ICollection Values

  563.     {

  565.         get

  567.         {

  569.             return this.bag.Values;

  571.         }

  573.     }

  575. }


该类继承了四个接口：

IStateManager ，IDictionary ，ICollection ，IEnumerable 。IStateManager 即.NET Framework 为 自定义视图状态管理提供的接口，到这里您应该明白我们直接使用ViewState 对象时其实是隐式用到了IStateManager 接口，只不过Control 类不是继承IStateManager 实现的，而是采用关联对象方式把StateBag 类的一个实例作为自己的一个属性保持而已。这样从技术角度能够把 IStateManager 接口的几个方法与 Control 对控件生命周期支持的几个同名方法区别开来（它们命名是相同的）。另外，这几个方法在使用上也非常简便，直接通过属性的方式使用，否则使用时就要重写基类的方法实现，显得比较笨重且缺乏灵活性。

后面三个接口IDictionary，ICollection，IEnumerable主要为视图对象的存储集合以及对集合的快速检索提供支持。在这里可以看到我们使用的ViewState在服务端也存储在一个标准的IDictionary类型中，如下：

private IDictionary bag;

u IDictionary集合采用键（string类型）/值（object类型）的格式存储。除了bag对象，还有两个内部变量：

private bool ignoreCase;

private bool marked;

u ignoreCase指定在集合中存储的键是否忽略大小写。marked变量就标记是否启用了跟踪监控的变量，只有当该值为true时，才把值保存到视图集合对象中，否则如果集合中有该对象就移除它。在Add方法的核心代码片段中体现了这一点，代码如下：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public StateItem Add(string key, object value)

{

    //… …

    StateItem item = this.bag[key] as StateItem;

    if (item == null)

    {

        if ((value != null) || this.marked)

        {

            item = new StateItem(value);

            this.bag.Add(key, item);

        }

    }

    else if ((value == null) && !this.marked)

    {

        this.bag.Remove(key);

    }

    else

    {

        item.Value = value;

    }

    if ((item != null) && this.marked)

    {

        item.IsDirty = true;

    }

    return item;

}

u 这一段代码比较严谨，除了判断marked是否为true，还判断要增加的对象是否为null如果为null，也不会增加到视图集合列表对象中。另外，在视图集合中，对应的值类型为StateItem，它的代码如下所示：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public sealed class StateItem

{

    // Fields

    private bool isDirty;

    private object value;

 

    // Methods

    internal StateItem(object initialValue);

 

    // Properties

    public bool IsDirty { get; set; }

    public object Value { get; set; }

}

 

u 在这里除了定义了存储数据内容的object对象的value属性外，还有一个Dirty属性，该属性值标志当前集合中的一个对象是否是脏数据（即被改动过了），SaveViewState方法只对脏数据进行保存，以便提高性能。SaveViewState的代码片段如下：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. internal object SaveViewState()

  11.    {

  13.        ArrayList list = null;

  15.        if (this.bag.Count != 0)

  17.        {

  19.            IDictionaryEnumerator enumerator = this.bag.GetEnumerator();

  21.            while (enumerator.MoveNext())

  23.            {

  25.                StateItem item = (StateItem)enumerator.Value;

  27.                if (item.IsDirty)

  29.                {

  31.                    if (list == null)

  33.                    {

  35.                        list = new ArrayList();

  37.                    }

  39.                    list.Add(new IndexedString((string)enumerator.Key));

  41.                    list.Add(item.Value);

  43.                }

  45.            }

  47.        }

  49.        return list;

  51.    }


代码体中的语句

if （item.IsDirty ）就是对要保存的序列化对象进行过滤，最终返回的list 集合对象中的item 的Dirty 属性值都为true 。

StateBag类的关键点就介绍这些。StateBag是.NETFramework提供的一个比较实用的类，并且它实现了IStateManager，可以作为自定义类型视图、状态的一个典型例子，在实现自己的视图状态类时完全可以参考它。在实际开发时，很多情况下也并非一定要显示继承 IStateManager接口，系统类有些类型继承了IStateManager，比如Style，这样我们可以直接拿来使用，还有它的一些派生类TableItemStyle，TableStyle，PanelStyle 都可以直接在控件开发中使用。后面会介绍一个使用TableItemStyle作为基类实现自定义类型视图状态的示例。

6.2.4 实现自定义类型视图状态

前面对视图状态的概念和原理已经说得比较清楚了，这一节就以一个实例说明ViewState工作原理。建立一个Web自定义控件ViewStateControl，该控件继承于WebControl或Control，代码如下：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

[ToolboxData("<{0}:ViewStateControl runat=server></{0}:ViewStateControl>")]

    public class ViewStateControl : WebControl

    {

    }

 

u 由于WebControl是继承于Control基类的，因此该控件已经具备控件生命周期在视图阶段执行方法LoadViewState和SaveViewState的能力。在控件中增加三个不同类型的属性，如下所示：

 

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

 

private string _text;

[Bindable(true)]

[DefaultValue("")]

[Localizable(true)]

[Category("测试视图状态")]

[Description("没有使用视图状态存储")]

public string Text_NoViewState

{

    get

    {

        return _text;

    }

    set

    {

        this._text = value;

    }

}

 

[Bindable(true)]

[DefaultValue("")]

[Localizable(true)]

[Category("测试视图状态")]

[Description("使用ViewState属性来存储数据此属性")]

public string Text_ViewState

{

    get

    {

        String s = (String)ViewState["Text_ViewState"];

        return ((s == null) ? String.Empty : s);

    }

    set

    {

        ViewState["Text_ViewState"] = value;

 

    }

}

 

private FaceStyle _faceStyle;

[PersistenceMode(PersistenceMode.InnerProperty)]

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

[NotifyParentProperty(true)]

[Category("测试视图状态")]

[Description("自定义视图状态(实现IStateManager接口)存储此属性")]

public FaceStyle FaceStyle

{

    get

    {

        if (_faceStyle == null)

        {

            _faceStyle = new FaceStyle();

        }

        if (IsTrackingViewState)

        {

            ((IStateManager)_faceStyle).TrackViewState();

        }

        return _faceStyle;

    }

}

 

u 针对视图状态，这三个属性分别表示三种不同类型。第一个属性Text_NoViewState没有使用视图状态机制存储属性值；第二个属性Text_ViewState使用Control基类中的存储简单类型的ViewState对象存储属性值；第三个属性FaceStyle为自定义类型属性，属性类型为FaceStyle。由于FaceStyle为自定义类，要实现其类的视图状态管理，还需要继承前面讲解的IStateManager接口。FaceStyle的类结构如下：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public class FaceStyle : TableItemStyle, IStateManager

{

}

FaceStyle继承了IStateManager接口，并且还继承了TableItemStyle基类，前面讲过TableItemStyle继承了Style，并且Style又继承了IStateManager，也就是说TableItemStyle能够管理其内部的数据，这固然是好的，因为我们不清楚TableItemStyle的成员内容，也无法对基类中的成员进行管理。虽然TableItemStyle能够管理其内部视图数据，但它只能管理其内部数据（类成员）的视图（Style没有完全公开它继承的IStateManager的几个成员，所以需要自己实现IStateManager），而不能够管理FaceStyle类成员的视图，在这里笔者仍然在FaceStyle类中实现了IStateManager类，因为在FaceStyle类中一般还要加入自己的成员，这就需要FaceStyle类自己管理其成员视图状态。

针对FaceStyle这个比较特殊的自定类，我们只要验证下面两点就可以验证它是否真的能够支持和实现视图状态：

（1）TableItemStyle是否能够真的能够保存其内部和基类的数据？

（2）在FaceStyle类中加入新成员，并继承IStateManager实现其视图状态管理，只要实现FaceStyle中的成员能够完成视图状态的存取即可说明该成员能够支持视图状态。

对于第（1）点，可以直接针对TableItemStyle类内部的属性进行判断。对于第（2）点，专门为FaceStyle类增加一个属性，代码如下：

 

  1. private bool _blnOK;

  3. [Browsable(true)]

  5. [Description("自定义类测试变量")]

  7. public bool OK

  9. {

  11.     get

  13.     {

  15.         return _blnOK;

  17.     }

  19.     set

  21.     {

  23.         _blnOK = value;

  25.     }

  27. }

  29. public FaceStyle()

  31. {

  33.     _blnOK = false;

  35. }


该属性为布尔类型，在这里就不能使用

this.ViewState 对象存储值了，如果强制使用该对象也无法编译通过，因为只有在继承Control 类的派生类中才能够使用ViewState 对象。另外，在这里如果继承Control 类也没有必要，这仅是一个简单属性的类而已，像这样的样式类还有很多。

下面我们就自己实现FaceStyle类的视图状态管理。在FaceStyle类中增加如下代码：

bool IStateManager.IsTrackingViewState

{

    get

    {

        return base.IsTrackingViewState;

    }

}

 

#endregion

 

#region 方法

 

 

//从当前点开始, 此控件具有保存视图状态功能      

void IStateManager.TrackViewState()

{

    base.TrackViewState();

}

u 以上代码中包括一个属性和一个方法，这两个成员是对IStateManager接口中成员的实现。IsTrackingViewState属性指示当前FaceStyle属性是否启用视图监控，TrackViewState方法用于启用视图监控功能。这两个属性操作的监控标记布尔变量都是直接使用Style基类中的标记布尔变量，如下代码是marked标记在Style中的实现：

 

  1. private bool marked;

  3. protected internal virtual void TrackViewState()

  5. {

  7.     if (this.ownStateBag)

  9.     {

  11.         this.ViewState.TrackViewState();

  13.     }

  15.     this.marked = true;

  17. }



  21. protected bool IsTrackingViewState

  23. {

  25.     get

  27.     {

  29.         return this.marked;

  31.     }

  33. }


虽然

Style 类没有公开LoadViewState 方法，但对于TrackViewState 和IsTrackingViewStatep 这两个成员是可以使用的。另外，在FaceStype 中使用以上两个成员的好处是可以避免重新定义产生二义性，因为这两个成员性对基类还是FaceStyle 类本身来说实现的功能是一样的，也没必要再定义一个marked 变量。

IStateManager接口还有两个最重要成员LoadViewState和SaveViewState没有实现，下面是它们的代码：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>



  11. object IStateManager.SaveViewState()

  13. {

  15.     object[] state = new object[2];

  17.     state[0] = base.SaveViewState();            

  19.     

  21.     state[1] = (object)OK;

  23.     return state;

  25. }

  27. void IStateManager.LoadViewState(object state)

  29. {

  31.     if (state == null)

  33.     {

  35.         return;

  37.     }

  39.     object[] myState = (object[])state;

  41.     base.LoadViewState(myState[0]);

  43.     OK = (bool)myState[1];                

  45. }


以上两个方法是对视图数据操作的核心方法。

SaveViewState 方法主要将对FaceStyle 内部数据成员的视图状态所做的更改保存到对象，如果在主控件中则返回值直接交给页框架序列化处理，最终作为一个散列串存储在页面上的隐藏区域中；在非主控件的自定义类中则由主控件的SaveViewState 方法先调用返回值，再由主控件一块把这些自定义类的视图数据一块返回给页框架。在代码中，首先创建一个二维object 数组，数组的第一维存储基类TableItemState 序列化后的对象（base.SaveViewState 即为返回基类序列化对象方法），数组的第二维仅存储我们在FaceStyle 中专门增加的那个属性（名称为OK ）。最后返回整个数组对象。

LoadViewState恰好与SaveViewState执行相反的过程，主要完成把state二维数据组中的数据赋给控件当前对应的属性。当初始化Init阶段完成后，页框架会马上调用LoadViewState方法，LoadViewState方法带一个参数state，简单地说此参数是从客户端传回的，被页框架反序列化后的对象。

到现在为止，FaceStyle类的视图状态管理已经实现完成。代码比较短，下面是FaceStyle类的完整代码：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public class FaceStyle : TableItemStyle, IStateManager

{

    #region 类变量

 

    private bool _blnOK;

 

    #endregion

 

    #region 构造函数

 

    public FaceStyle()

    {

        _blnOK = false;

    }

 

    #endregion

 

    #region 属性

  

    [Browsable(true)]

    [Description("自定义类测试变量")]

    public bool OK

    {

        get

        {

            return _blnOK;

        }

        set

        {

            _blnOK = value;

        }

    }

 

   

    bool IStateManager.IsTrackingViewState

    {

        get

        {

            return base.IsTrackingViewState;

        }

    }

 

    #endregion

 

    #region 方法

 

 

    //从当前点开始, 此控件具有保存视图状态功能      

    void IStateManager.TrackViewState()

    {

        base.TrackViewState();

    }

 

  

    object IStateManager.SaveViewState()

    {

        object[] state = new object[2];

        state[0] = base.SaveViewState();           

       

        state[1] = (object)OK;

 

        //状态管理会存储此返回的值; 另外此方法返回值还有个用途: 创建复合控件时取得

        //各个子控件的视图状态

        return state;

    }

 

  

    void IStateManager.LoadViewState(object state)

    {

        if (state == null)

        {

            return;

        }

        object[] myState = (object[])state;

        base.LoadViewState(myState[0]);

 

        OK = (bool)myState[1];               

    }

    #endregion

}

 

u 之前说过，主控件中的LoadViewState和SaveViewState方法是启用自定义类视图管理的导火线。接下来就实现这两个方法，代码如下：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>



  11. protected override object SaveViewState()

  13. {

  15.     Pair p = new Pair();

  17.     p.First = base.SaveViewState();

  19.     p.Second = ((IStateManager)FaceStyle).SaveViewState();

  21.     for (int i = 0; i < 2; i++)

  23.     {

  25.         if (p.First != null || p.Second != null)

  27.         {

  29.             return p;

  31.         }

  33.     }

  35.     return null;

  37. }

  39. protected override void LoadViewState(object savedState)

  41. {

  43.     if (savedState == null)

  45.     {

  47.         base.LoadViewState(null);

  49.         return;

  51.     }

  53.     else

  55.     {

  57.         Pair p = (Pair)savedState;

  59.         if (p == null)

  61.         {

  63.             throw new ArgumentException("无效的View State 数据!");

  65.         }

  67.         base.LoadViewState(p.First);

  69.         if (p.Second != null)

  71.         {

  73.             ((IStateManager)FaceStyle).LoadViewState(p.Second);

  75.         }

  77.     }

  79. }


主控件中的这两个方法与

IStateManager 中的对应两个同名方法功能类似，但它们只是名称相同而已，这里主控件的两个方法是由页框架在控件生命周期阶段自动调用的。而IStateManager 跟页框架没有一点联系，必须与主控件里的这两个方法组合使用，它才有意义，否则就是一堆死代码，永远不会执行。

SaveViewState功能完成对主控件中指定属性的对象序列化。方法体中首先定义了一个Pair类型的对象p，此对象是系统专门为此提供的，能存储一对数据值，类似于对象二维数组（object[2]）。其类结构如下：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public sealed class Pair

{

    // Fields

    public object First;

    public object Second;

 

    // Methods

    public Pair();

    public Pair(object x, object y);

}

 

u p.First存储基类序列化后对象（base.SaveViewState返回值为Control类成员序列化后的对象），其后面有一句：

p.Second = ((IStateManager)FaceStyle).SaveViewState();

这句功能是取FaceStyle的序列化对象值。指定p.Second存储我们在主控件中自定义的属性FaceStyle序列化后的内容，FaceStyle.SaveViewState方法在FaceStyle内部定义，本节前面已经详细讲解了其实现过程。最后通过条件语句判断，如果Pair对象中First和Second值有一个不为null，就以p作为返回值，否则返回null。

后面的LoadViewState功能与SaveViewState执行逻辑正好相反，即把序列化对象值赋值给控件属性和复杂属性。

对于上面两个方法还要说明一点，LoadViewState方法在第1次请求时不执行，仅执行SaveViewState。通常下LoadViewState在控件周期中是在SaveViewState之前被页框架调用的，但LoadViewState在页面第一次加载时不执行是有特殊原因的，主要由于SaveViewState还未保存过，执行LoadViewState也是无意义的。另外，从功能角度理解，我们只有在第2次提交页面时，才有可能想知道提交之前页面中某个控件的数据是什么，因为第一次请求时想知道第0次请求的数据是无意义的。强烈建议在主控件的这两个方法中设置断点，跟踪调试一下，对理解页面视图机制有极大的帮助。

上面使用了一个Pair对象。在FaceStyle中我们使用的是数组object[2]。除了这两个对象，系统还提供了对象Triplet，它的类结构如下：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public sealed class Triplet

  11. {

  13.     // Fields

  15.     public object First;

  17.     public object Second;

  19.     public object Third;



  23.     // Methods

  25.     public Triplet();

  27.     public Triplet(object x, object y);

  29.     public Triplet(object x, object y, object z);

  31. }


Pair

英文意思是“两份”；Triplet 英文意思是“三份”。根据不同的应用场景可以选择Pair 或Triplet 类实现序列化功能。在下一章介绍为控件样式保存视图状态时会用到Triplet ，这里就不作示例了。

主控件的核心代码已经讲解完，下面看一下主控件ViewStateControl的完整代码：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. [ToolboxData("<{0}:ViewStateControl runat=server></{0}:ViewStateControl>")]

  11. public class ViewStateControl : WebControl

  13. {

  15.     private string _text;

  17.     [Bindable(true)]

  19.     [DefaultValue("")]

  21.     [Localizable(true)]

  23.     [Category("测试视图状态")]

  25.     [Description("没有使用视图状态存储")]

  27.     public string Text_NoViewState

  29.     {

  31.         get

  33.         {

  35.             return _text;

  37.         }



  41.         set

  43.         {

  45.             this._text = value;

  47.         }

  49.     }



  53.     [Bindable(true)]

  55.     [DefaultValue("")]

  57.     [Localizable(true)]

  59.     [Category("测试视图状态")]

  61.     [Description("使用ViewState属性来存储数据此属性")]

  63.     public string Text_ViewState

  65.     {

  67.         get

  69.         {

  71.             String s = (String)ViewState["Text_ViewState"];

  73.             return ((s == null) ? String.Empty : s);



  77.         }



  81.         set

  83.         {

  85.             ViewState["Text_ViewState"] = value;



  89.         }

  91.     }



  95.     private FaceStyle _faceStyle;

  97.     [PersistenceMode(PersistenceMode.InnerProperty)]

  99.     [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

  101.     [NotifyParentProperty(true)]

  103.     [Category("测试视图状态")]

  105.     [Description("自定义视图状态(实现IStateManager接口)存储此属性")]

  107.     public FaceStyle FaceStyle

  109.     {

  111.         get

  113.         {

  115.             if (_faceStyle == null)

  117.             {

  119.                 _faceStyle = new FaceStyle();

  121.             }



  125.             if (IsTrackingViewState)

  127.             {

  129.                 ((IStateManager)_faceStyle).TrackViewState();

  131.             }



  135.             return _faceStyle;

  137.         }

  139.     }



  143.     protected override void RenderContents(HtmlTextWriter output)

  145.     {

  147.         if (DesignMode)

  149.         {

  151.             output.Write("[自定义视图状态存储示例控件]");

  153.         }

  155.     }



  159.     protected override object SaveViewState()

  161.     {

  163.         Pair p = new Pair();

  165.         p.First = base.SaveViewState();

  167.         p.Second = ((IStateManager)FaceStyle).SaveViewState();

  169.         for (int i = 0; i < 2; i++)

  171.         {

  173.             if (p.First != null || p.Second != null)

  175.             {

  177.                 return p;

  179.             }

  181.         }

  183.         return null;

  185.     }



  189.     protected override void LoadViewState(object savedState)

  191.     {

  193.         if (savedState == null)

  195.         {

  197.             base.LoadViewState(null);

  199.             return;

  201.         }

  203.         else

  205.         {

  207.             Pair p = (Pair)savedState;

  209.             if (p == null)

  211.             {

  213.                 throw new ArgumentException("无效的View State 数据!");

  215.             }

  217.             base.LoadViewState(p.First);

  219.             if (p.Second != null)

  221.             {

  223.                 ((IStateManager)FaceStyle).LoadViewState(p.Second);

  225.             }

  227.         }

  229.     }

  231. }


最后，针对该控件是否能够正确实现视图状态的保存，笔者专门做了一个测试示例，对控件的每个属性进行测试。

在页面中放一个ViewStateControl控件，两个Button，一个Label。两个Button中的一个负责服务端设置控件的四个属性（稍后会具体讲解这四个属性）；另一个负责提交页面，并检测当前控件属性是否正确保存了视图数据，检测结果通过Label控件显示。Label负责显示状态信息，可以指示某个属性是否真的保存了视图状态数据。设置后的页面中代码如下：

<body>

    <form id="form1" runat="server">   

    <div>       

        <cc1:viewstatecontrol ID="ViewStateControl1" runat="server"

                                Text_NoViewState="" Text_ViewState="">

            <FaceStyle OK="false" BackColor="White" />            

        </cc1:viewstatecontrol>

        <br />

        <br />

        <asp:Button ID="btnSetProperty" runat="server"

                    OnClick="btnSetProperty_Click" Text="设置控件属性" />

        <asp:Button ID="btnRefresh" runat="server" Text="刷新页面"

                    OnClick="btnRefresh_Click" />&nbsp;<br />

        <br />

        <asp:Label ID="lbDisplay" runat="server" Height="309px"

                    Width="307px"></asp:Label></div>         

    </form>

</body>

如上代码主控件中的四个属性：Text_NoViewState，Text_ViewState，FaceStyle.OK，FaceStyle.BackColor各自代表不同的类型成员。在主控件中定义时，第一个属性Text_NoViewState没有使用视图状态机制存储属性值；第二个属性Text_ViewState使用Control基类中的存储简单类型的ViewState对象存储属性值；第三个属性FaceStyle.OK为FaceStyle类中的属性；第四个属性FaceStyle.BackColor为FaceStyle的基类中的属性。如果还不明白请回顾一下主控件的代码。视图状态机制就这么多内容，只要这四个属性能够符合视图状态规则，则就证明我们的控件做到了视图状态管理，也即我们已经掌握了页面视图状态机制。

页面中两个按钮的后台代码如下：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>



  11. string strPicXiaoLian = "<Img src='" + "Images""XL.jpg" + "' /> ";

  13. string strPicJuSang   = "<Img src='" + "Images""JS.jpg" + "' /> ";

  15. string strPicBG = "<Img src='" + "Images""BG.jpg" + "' /> ";

  17. private Color c = Color.FromName("#C0C0FE");

  19. protected void btnSetProperty_Click(object sender, EventArgs e)

  21. {

  23.     ///设置没有用视图状态存储的属性值

  25.     this.ViewStateControl1.Text_NoViewState = "我没有用任何视图状态存储!";



  29.     ///设置用ViewState存储的属性值

  31.     this.ViewStateControl1.Text_ViewState = "我是用ViewState容器存储的!";



  35.     //设置用自定义视图状态存储的属性值

  37.     this.ViewStateControl1.FaceStyle.OK = true;

  39.     this.ViewStateControl1.FaceStyle.BackColor = c;

  41. }

  43. protected void btnRefresh_Click(object sender, EventArgs e)

  45. {

  47.     /// <summary>

  49.     /// ViewState容器存储测试--测试存储ViewStateControl1.Text_NoViewState属性

  51.     /// </summary>

  53.     if (this.ViewStateControl1.Text_NoViewState == "我没有用任何视图状态存储!")

  55.     {

  57.         this.lbDisplay.Text = "this.ViewStateControl1.Text_NoViewState属性 已

  59.         经保存了视图状态 " + strPicXiaoLian + " <br><br>";

  61.     }

  63.     else

  65.     {

  67.         this.lbDisplay.Text = "this.ViewStateControl1.Text_NoViewState属性 没

  69.         有保存视图状态 " + strPicJuSang + " <br><br>";

  71.     }





  77.     /// <summary>

  79.     /// ViewState容器存储测试--测试存储ViewStateControl1.Text_ViewState属性

  81.     /// </summary>

  83.     if (this.ViewStateControl1.Text_ViewState == "我是用ViewState容器存储的!")

  85.     {

  87.         this.lbDisplay.Text += "this.ViewStateControl1.Text_ViewState属性 已经

  89.         保存了视图状态 " + strPicXiaoLian + " <br><br>";

  91.     }

  93.     else

  95.     {

  97.         this.lbDisplay.Text += "this.ViewStateControl1.Text_ViewState属性 没有

  99.         保存视图状态 " + strPicJuSang + " <br><br>";

  101.     }





  107.     /// <summary>

  109.     /// 自定义视图状态测试--测试存储类ViewStateControl1.FaceStyle的内部属性OK

  111.     /// </summary>

  113.     if (this.ViewStateControl1.FaceStyle.OK == true)

  115.     {

  117.         this.lbDisplay.Text += "this.ViewStateControl1.FaceStyle属性.OK 已经保

  119.         存了视图状态 " + strPicXiaoLian + " <br><br>";

  121.     }

  123.     else

  125.     {

  127.         this.lbDisplay.Text += "this.ViewStateControl1.FaceStyle属性.OK 没有保

  129.         存视图状态 " + strPicJuSang + " <br><br>";

  131.     }





  137.     /// <summary>

  139.     /// 自定义视图状态测试--测试存储类ViewStateControl1.FaceStyle的基类

  141.          TableItemStyle中的属性BackColor

  143.     /// </summary>

  145.     if (this.ViewStateControl1.FaceStyle.BackColor.Equals(c))

  147.     {

  149.         this.lbDisplay.Text += "this.ViewStateControl1.FaceStyle.BackColor 已

  151.         经保存了视图状态, 瞧，我的颜色就是保存的颜色 " + strPicXiaoLian + " " + strPicBG 

  153.         + "<br><br>";

  155.         //this.lbDisplay.BackColor = c;

  157.     }

  159.     else

  161.     {

  163.         this.lbDisplay.Text += "this.ViewStateControl1.FaceStyle.BackColor 没

  165.         有保存视图状态, 瞧，我的颜色还是白色 " + strPicJuSang + " <br><br>";

  167.     }

  169. }


测试代码看起来有些长，其实逻辑很简单，就是先为属性赋值，然后单击“提交”按钮，看一下页面重新呈现后这些属性值是否还存在。事件体外面定义了几个图片路径和一个颜色变量（测试

FaceStyle.BackColor 属性时使用）。

btnSetProperty_Click事件方法体主要针对我们要测试的四个属性，为每个属性设置一个值。btnRefresh_Click方法完成提交，并判断控件的每个值是否还等于在btnSetPropertyClick事件方法体中赋的值，如果相同就为当前属性显示 ，表示保存了值；否则显示 ，表示没有正确通过视图存储数据。

好了，现在是心情最轻松最愉快的时刻。开始测试。在浏览器中运行页面，先单击一下“刷新”按钮，页面显示如图6-2所示。

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-2 页面视图状态示例——初始状态

 

可以看到页面的上的控件还是初始值。顺便查看一下页面中隐藏域的值如下：

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwULLTE3 NjU0NjM4OTEPZBYCAgMPZBYCAgEPD2QUKwACZGhkZNKghO16NX9gdumXeBtdWJZV1bcC" />

内容比较少，仅包括页面自己的一些视图信息。先单击一下“设置控件属性”按钮，为控件的四个属性赋值，然后再单击“刷新页面”按钮，则会看到如图6-3所示的页面。

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-3 页面视图状态示例——存储了视图状态数据

 

可以看到后面的三个属性已经正确保存了视图状态。但第一个控件仍然没有保存视图状态数据，这是正常的，因为第一个控件我们本来就没有使用任何视图状态对象存储状态数据，如果它能够自动保存视图状态，那真是神了！看一下呈现到客户端源代码隐藏域：

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwULLTE3 NjU0NjM4OTEPZBYCAgMPZBYEAgEPDw8WAh4OVGV4dF9WaWV3U3RhdGUFIuaIkeaYr+eUqFZpZXdTdGF0ZeWuueWZqOWtmOWCqOeahCFkFCsAAhYEHglCYWNrQ29sb3IKAB4EXyFTQgIIZ2QCBw8PFgIeBFRleHQF9QN0aGlzLlZpZXdTdGF0ZUNvbnRyb2wxLlRleHRfTm9WaWV3U3RhdGXlsZ7mgKcg5rKh5pyJ5L+d5a2Y6KeG5Zu+54q25oCBIDxJbWcgc3JjPSdJbWFnZXNcSlMuanBnJyAvPiAgPGJyPjxicj50aGlzLlZpZXdTdGF0ZUNvbnRyb2wxLlRleHRfVmlld1N0YXRl5bGe5oCnIOW3sue7j+S/neWtmOS6huinhuWbvueKtuaAgSA8SW1nIHNyYz0nSW1hZ2VzXFhMLmpwZycgLz4gIDxicj48YnI+dGhpcy5WaWV3U3RhdGVDb250cm9sMS5GYWNlU3R5bGXlsZ7mgKcuT0sg5bey57uP5L+d5a2Y5LqG6KeG5Zu+54q25oCBIDxJbWcgc3JjPSdJbWFnZXNcWEwuanBnJyAvPiAgPGJyPjxicj50aGlzLlZpZXdTdGF0ZUNvbnRyb2wxLkZhY2VTdHlsZS5CYWNrQ29sb3Ig5bey57uP5L+d5a2Y5LqG6KeG5Zu+54q25oCBLCDnnqfvvIzmiJHnmoTpopzoibLlsLHmmK/kv53lrZjnmoTpopzoibIgPEltZyBzcmM9J0ltYWdlc1xYTC5qcGcnIC8+ICA8SW1nIHNyYz0nSW1hZ2VzXEJHLmpwZycgLz4gPGJyPjxicj5kZGTFH8U37EhQNJzHTltcDxNaH2mMfQ==" />

内容明显多了许多，再次证明我们控件的属性被存储到视图状态中了。到现在为止，对控件的四个属性类型测试已经成功！

接下来，再进行另一个测试，在Page_Load中加入下面语句：

 

  1. protected void Page_Load(object sender, EventArgs e)

  3. {

  5.     //禁用页面视图状态

  7.     Page.EnableViewState = false;

  9.     //或禁用控件视图状态

  11.     this.ViewStateControl1.EnableViewState = false;

  13. }

使用这两句中的任何一句即可，表示禁用页面视图或禁用控件视图，然后再按上面的顺序，依次单击“设置控件属性”和“刷新页面”按钮，就会看到如图

6-4 所示的页面结果。

可以看到，当页面或控件的视图被禁用后，任何属性值将不再被保存。这是控件开发人员无能为力的，因为开发人员为了提高性能可以随意禁止页面或控件状态。重要的一点是，一旦开发人员禁用页面或控件视图后，主控件中的LoadViewState和SaveViewState两个方法在控件生命周期不再被页框架自动调用，也就没有了页面状态启动的“导火线”，读者可以在控件中设置一下断点，跟踪调试一下。

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-4 页面视图状态示例——禁用了页面或控件的视图

 
但有些涉及控件逻辑的一些非业务数据，我们必须使用视图保存，那怎么办？ASP.NET 从2.0 版本开始已经支持控件状态ControlState ，开发人员可以禁用视图状态，但禁用不了控件状态，在本章6.1 节对其使用场景作了描述，如果不记得了请回顾一下前面章节。下一节就讲解一下控件状态机制，并介绍如何通过控件状态解决开发人员禁用视图状态而导致的问题。

 

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-5 控件状态

6.3 控件状态机制

自ASP.NET 2.0开始支持控件状态机制。控件的状态数据现在能通过控件状态而不是视图状态被保持，控件状态是不能够像视图状态那样被禁用的。由于控件状态的工作方式与视图状态完全一致，并且默认情况下在页面中它们都是存储在同一个隐藏域中，这里对它的工作原理就不多介绍了。

与LoadViewState和SaveViewState类似，控件状态也是提供了一对这样的方法，方法名称分别为LoadControlState和SaveControl State，并且也是在Control基类中提供。

图6-5中加灰底部分是控件状态在控件生命周期中的阶段。

如果启用控件状态功能，只需实现以下几个方法：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public class ControlStatePeriod : WebControl

{

    protected override void OnInit(EventArgs e)

    {

        base.OnInit(e);

        Page.RegisterRequiresControlState(this);

    }

    protected override object SaveControlState()

    {

        //… …

    }

    protected override void LoadControlState(object savedState)

    {

        //… …

    }

}

u 这里与视图状态有点不同的是，除了重载SaveControlState和LoadControlState两个方法外，在上面代码中还重写了OnInit方法，并增加如下语句：

Page.RegisterRequiresControlState(this);

该方法的功能是将控件注册为具有持久性控件状态的控件，参数是要注册的控件引用。由于在回发事件的过程中，控件状态的注册无法在请求之间进行传递，因此使用控件状态的自定义服务器控件必须对每个请求调用RegisterRequiresControlState方法。即本方法通知页框架在控件生命周期时调用控件状态的两个方法；反过来讲，如果没有通过上面方法注册当前控件，则控件的LoadControlState和SaveControlState方法不会执行。一般在Init事件中注册控件。

下面通过示例说明其用法。在上面的ViewStateControl中通过四个不同类型的属性充分验证了ViewState的可行性。这里我们还是使用这四个经典的属性，并使用控件状态机制完成一个新的控件ControlStateControl。直接看一下它的源代码：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. [ToolboxData("<{0}:ControlStateControl runat=server></{0}:ControlStateControl>")]

  11. public class ControlStateControl : WebControl

  13. {

  15.     private string _text;

  17.     [Bindable(true)]

  19.     [DefaultValue("")]

  21.     [Localizable(true)]

  23.     [Category("控件状态")]

  25.     [Description("没有使用视图状态存储")]

  27.     public string Text_NoViewState

  29.     {

  31.         get

  33.         {

  35.             return _text;

  37.         }



  41.         set

  43.         {

  45.             this._text = value;

  47.         }

  49.     }



  53.     [Bindable(true)]

  55.     [DefaultValue("")]

  57.     [Localizable(true)]

  59.     [Category("控件状态")]

  61.     [Description("使用ViewState属性来存储数据此属性")]

  63.     public string Text_ViewState

  65.     {

  67.         get

  69.         {

  71.             String s = (String)ViewState["Text_ViewState"];

  73.             return ((s == null) ? String.Empty : s);



  77.         }



  81.         set

  83.         {

  85.             ViewState["Text_ViewState"] = value;



  89.         }

  91.     }



  95.     private FaceStyle _faceStyle;

  97.     [PersistenceMode(PersistenceMode.InnerProperty)]

  99.     [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

  101.     [NotifyParentProperty(true)]

  103.     [Category("控件状态")]

  105.     [Description("自定义视图状态(实现IStateManager接口)存储此属性")]

  107.     public FaceStyle FaceStyle

  109.     {

  111.         get

  113.         {

  115.             if (_faceStyle == null)

  117.             {

  119.                 _faceStyle = new FaceStyle();

  121.             }



  125.             if (IsTrackingViewState)

  127.             {

  129.                 ((IStateManager)_faceStyle).TrackViewState();

  131.             }



  135.             return _faceStyle;

  137.         }

  139.     }



  143.     protected override void RenderContents(HtmlTextWriter output)

  145.     {

  147.         if (DesignMode)

  149.         {

  151.             output.Write("[自定义控件状态存储示例控件]");

  153.         }

  155.     }



  159.     /// <summary>

  161.     /// 由于在回发事件的过程中，控件状态的注册无法在请求之间进行传递，因此使用

  163.     /// 控件状态的自定义服务器控件必须对每个请求调用RegisterRequiresControlState

  165.     /// 方法

  167.     /// </summary>

  169.     /// <param name="e"></param>

  171.     protected override void OnInit(EventArgs e)

  173.     {

  175.         base.OnInit(e);

  177.         Page.RegisterRequiresControlState(this);

  179.     }



  183.     protected override object SaveControlState()

  185.     {

  187.         Pair p = new Pair();

  189.         p.First = base.SaveViewState();

  191.         p.Second = ((IStateManager)FaceStyle).SaveViewState();

  193.         for (int i = 0; i < 2; i++)

  195.         {

  197.             if (p.First != null || p.Second != null)

  199.             {

  201.                 return p;

  203.             }

  205.         }

  207.         return null;

  209.     }



  213.     protected override void LoadControlState(object savedState)

  215.     {

  217.         if (savedState == null)

  219.         {

  221.             base.LoadViewState(null);

  223.             return;

  225.         }

  227.         else

  229.         {

  231.             Pair p = (Pair)savedState;

  233.             if (p == null)

  235.             {

  237.                 throw new ArgumentException("无效的Control State 数据!");

  239.             }

  241.             base.LoadViewState(p.First);

  243.             if (p.Second != null)

  245.             {

  247.                 ((IStateManager)FaceStyle).LoadViewState(p.Second);

  249.             }

  251.         }

  253.     }

  255. }


还有

FaceStyle 类在ControlStateControl 主控件中也作为属性类型使用了，在这里的FaceStyle 类的代码没有作任何改变，限于篇幅就不重复贴出来了。

主控件中的逻辑与ViewStateControl中的绝大部分相同。不同的是ControlStateControl重载了OnInit方法并增加向页面中注册当前控件的控件状态的请求，还有LoadViewState和SaveViewState对应变为LoadControlState和SaveControlState。除了这几点，其他的代码逻辑完全相同，在ViewStateControl中已经讲解得非常详细了，如果还有不明白的请回顾一下前面章节。

这里的测试页面也与ViewStateControl的测试页面基本相同。唯一不同的是控件名称，这里限于篇幅也不重复贴出源代码，在本书的随书光盘中有完整的控件示例代码，包括测试页面代码。

本节的示例控件名称为ControlStateControl。在运行之前一定要在Page_Load中禁用视图状态，这样才能确定是控件状态在起作用。禁用视图状态的代码如下：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. protected void Page_Load(object sender, EventArgs e)

  11. {

  13.     //禁用页面控件状态测试

  15.     Page.EnableViewState = false;



  19.     //或禁用控件控件状态测试

  21.     this.ControlStateControl1.EnableViewState = false;

  23. }

您应该还记得，控件状态机制被引入的主要目的就是解决视图状态被禁用问题。基于这，我把页面视图状态和控件的视图状态全部禁用了。

运行页面，依次单击“设置控件属性”和“刷新页面”按钮，可以看到如图6-6所示的运行结果。

跟ViewStateControl成功测试结果完全一致，ControlStateControl控件也正确完成了它的功能。还可以进一步测试，把主控件中的以下语句注释掉：

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-6 成功保存了控件状态

 

  1. protected override void OnInit(EventArgs e)

  3. {

  5.     base.OnInit(e);

  7.     Page.RegisterRequiresControlState(this);

  9. }

再运行时，可以看到控件不能够保存控件状态了，原因是主控件中的

LoadConrolState 和SaveControlState 不再被页框架调用。可见Page.RegisterRequiresControlState （this ）方法的重要性。要想使用控件状态，一定不要忘记这句。

另外，要注意一点，使用控件状态时建议只存储少量控件逻辑必需的数据，一般设置少数几个重要属性即可。这里为了演示其功能把所有类型的属性全部使用控件状态实现，在实际开发中不建议这么做。

这一节内容就讲这么多。如果您看得比较细的话，可能会发现在控件ControlStateControl的代码中，有好多代码是视图状态概念中的，在控件状态主控件中几乎没有作任何修改就能使用，比如我们测试的第二个属性仍然使用了基类Control中的ViewState对象，并且还能够保存视图状态，但是页面视图已经被禁用了，这是怎么回事呢？这就涉及视图状态和控件状态的关系了。在下一节专门探讨这个问题。

6.4 视图状态和控件状态的关系

6.4.1 在禁用视图状态的情况下仍然使用ViewState对象

当开发人员禁用了页面或控件视图状态时。控件开发人员一般在无奈情况下会使用控件状态，要重写LoadControlState，SaveControlState，还有一个OnInit方法，这样固然完全可以实现控件重要数据的控件状态数据保存。但一般LoadControlState和SaveControlState方法都要开发人员自定义编程，比较麻烦，更适合对控件中复杂的自定义类型数据进行对象序列化操作，比如一些简单的类型如：string，int，bool，color，datetime，byte，arraylist等如果是控件重要属性的话，也都挤到LoadControlState 和 SaveControlState方法中，则会显得比较啰唆。

想一下，如果页面视图没有禁用时该多好，可以以this.ViewState["Text"]的格式直接使用Control中的ViewState对象，非常方便。既然ViewState对象不管禁用还是不禁用都在Control类中是存在的，那不用它岂不浪费。这一节主要内容就是如何实现在禁用视图状态下仍然可以使用ViewState对象。

该功能在主控件ControlStateControl中已经实现了。回顾一下主控件的代码片段：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public class ControlStateControl : WebControl

  11. {

  13.     //… …

  15.     [Description("使用ViewState属性来存储数据此属性")]

  17.     public string Text_ViewState

  19.     {

  21.         get

  23.         {

  25.             String s = (String)ViewState["Text_ViewState"];

  27.             return ((s == null) ? String.Empty : s);



  31.         }



  35.         set

  37.         {

  39.             ViewState["Text_ViewState"] = value;

  41.         }

  43.     }

  45.     //… …

  47.     protected override object SaveControlState()

  49.     {

  51.         Pair p = new Pair();

  53.         p.First = base.SaveViewState();

  55.         p.Second = ((IStateManager)FaceStyle).SaveViewState();

  57.         //… …

  59.         return p;

  61.     }



  65.     protected override void LoadControlState(object savedState)

  67.     {

  69.         if (savedState == null)

  71.         {

  73.             base.LoadViewState(null);

  75.             return;

  77.         }

  79.         else

  81.         {

  83.             //… …

  85.             base.LoadViewState(p.First);

  87.             //… …

  89.         }

  91.     }

  93.     //… …

  95. }


在

ControlStateControl 中，属性Text_ViewState 仍然存储在基类Control 的ViewState 对象中，且运行页面中同时禁用了页面和控件视图状态，但该属性仍然能够正确地应用视图状态。

在视图状态启用状态下，在LoadViewState方法中会默认调用基类的base.LoadViewState方法，其中就包含对基类中ViewState对象进行对象序列化的代码，如下：

 

  1. protected virtual void LoadViewState(object savedState)

  3. {

  5.     if (savedState != null)

  7.     {

  9.         this.ViewState.LoadViewState(savedState);

  11.         object obj2 = this.ViewState["Visible"];

  13.         if (obj2 != null)

  15.         {

  17.             if (!((bool)obj2))

  19.             {

  21.                 this.flags.Set(0x10);

  23.             }

  25.             else

  27.             {

  29.                 this.flags.Clear(0x10);

  31.             }

  33.             this.flags.Set(0x20);

  35.         }

  37.     }

  39. }


其中这句

this.ViewState.LoadViewState （savedState ）为关键语句，还记得ViewState 属性实际的类型为StateBag 类，它是系统定义的类型视图状态实现类（我们在6.2.3 小节探讨过）。

同样在，SaveViewState方法中也有序列化保存ViewState属性对象的代码，如下所示：

 

  1. protected virtual object SaveViewState()

  3. {

  5.     if (this.flags[0x20])

  7.     {

  9.         this.ViewState["Visible"] = !this.flags[0x10];

  11.     }

  13.     if (this._viewState != null)

  15.     {

  17.         return this._viewState.SaveViewState();

  19.     }

  21.     return null;

  23. }


关键语句为

this._viewState.SaveViewState() ，ViewState 是对外属性，其操作的变量就是StateBag 类型的_viewState 。

在视图状态被禁用的情况下，由于LoadViewState和SaveViewState不再被页框架调用（默认情况下是base.SaveViewState和base.LoadViewState方法不会再被调用），所以ViewState属性功能也就失效。

了解了ViewState对象的来龙去脉，现在就讲解一下在ControlStateControl控件中仍然可以使用ViewState的原因。在LoadControlState和SaveControlState方法中分别调用base.LoadViewState和base.SaveControlState，我们可以手动调用ViewState属性对象的对象正反序列化过程。归根到底，也就是说开发人员所谓的禁用视图实际上是禁止LoadViewState和SaveViewState两个方法的执行，但理论上我们只要启动控件状态，并把这两个方法的逻辑放到LoadControlState和SaveControlState中，仍然可以利用ViewState。

本节内容有些乖张，违反了ASP.NET设计页面状态的规则。既然ASP.NET框架把视图和控件状态已经分开了，建议在实际开发中分开处理，不要滥用。在LoadControlState方法中尽量只写控件状态相关逻辑，在LoadViewState中只写视图状态相关逻辑，毕竟ControlState是专门为存储控件必需的少量数据设计的。不过上面在ControlState中使用ViewState的确是非常方便的，在处理基本类型的属性时能够节省开发时间。

6.4.2 IStateManager接口仍然可以在控件状态中使用

对于IStateManager的功能微软官方文档是这么定义的：定义任何类为支持服务器控件的视图状态管理而必须实现的属性和方法，服务器控件的视图状态由控件属性的累计值组成。该接口包括保存并加载服务器控件的视图状态值的方法，以及一个指示控件跟踪其视图状态的任何更改的方法。其定义为：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public interface IStateManager

  11. {

  13.     // Methods

  15.     object SaveViewState();

  17.     void LoadViewState(object state);

  19.     void TrackViewState();



  23.     // Properties

  25.     bool IsTrackingViewState { get; }

  27. }


从它的成员来看，其中一些可重载方法，如

SaveViewState ，LoadViewState 等都是针对视图状态而非控件状态的。笔者个人认为，这里修改成SaveState 和LoadState 更好些，因为这个接口完全可以应用于控件状态，这也是本节要说明的内容。

看一下ControlStateControl控件的代码片段：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public class ControlStateControl : WebControl

  11. {

  13.     //… …

  15.     private FaceStyle _faceStyle;

  17.     [PersistenceMode(PersistenceMode.InnerProperty)]

  19.     [DesignerSerializationVisibility(DesignerSerializationVisibility. Content)]

  21.     [NotifyParentProperty(true)]

  23.     [Category("控件状态")]

  25.     [Description("自定义视图状态(实现IStateManager接口)存储此属性")]

  27.     public FaceStyle FaceStyle

  29.     {

  31.         get

  33.         {

  35.             if (_faceStyle == null)

  37.             {

  39.                 _faceStyle = new FaceStyle();

  41.             }



  45.             if (IsTrackingViewState)

  47.             {

  49.                 ((IStateManager)_faceStyle).TrackViewState();

  51.             }



  55.             return _faceStyle;

  57.         }

  59.     }

  61.     //… …

  63.     protected override object SaveControlState()

  65.     {

  67.         Pair p = new Pair();

  69.         p.First = base.SaveViewState();

  71.         p.Second = ((IStateManager)FaceStyle).SaveViewState();            

  73.         return p;

  75.     }

  77.     protected override void LoadControlState(object savedState)

  79.     {

  81.             //… …

  83.             Pair p = (Pair)savedState;

  85.             //… …

  87.             if (p.Second != null)

  89.             {

  91.                 ((IStateManager)FaceStyle).LoadViewState(p.Second);

  93.             } 

  95.     }

  97. }


以上代码中主控件属性

FaceStyle 的定义与ViewStateControl 定义完全一样；另外，在LoadControlState 和SaveControlState 中对FaceStyle 属性的对象序列化也是与ViewStateControl 中的完全一样。 FaceStyle 属性对应的类型为 FaceStyle ， ViewStateControl 也是使用的同一个 类。

这说明IStateManager完全可以用于控件状态。不同的是，这里是由LoadControlState和SaveControlState两个方法驱动，而不是由原来的LoadViewState和SaveViewState方法驱动。同时再一次证明IStateManger只是一个接口，实现它的类默认与页框架没有任何调用关系，必须由主控件中视图状态的两个方法或控件状态的两个方法调用。

6.4.3 视图状态和控件状态组合使用规则

在实际开发时，除了上面的IStateManger接口可以分别用于视图状态和控件状态外，视图状态的两个方法（LoadViewState和SaveViewState）和控件状态的两个方法（LoadControlState和SaveControlState）可以同时使用，即视图状态和控件状态一起使用。

这样做的好处是把数据量相对比较大的属性或用户数据属性作为ViewState存储，把仅与控件逻辑相关的属性，比如像选项卡控件的当前选中索引CurrentSelectIndex这样的属性，作为控件状态存储。

这时就要注意分清楚它们的使用职责了，像类似6.4.1节讲的用法就避免使用，以防出现意想不到的错误，除非我们非常了解基类中的一些方法到底做了些什么事情，但这比较难。

6.5 加密页面状态

本节介绍ASP.NET对视图信息的加密功能。Page.RegisterRequiresViewStateEncryption方法就是将控件注册为需要视图状态加密的控件。如果您要开发用于处理潜在的敏感信息的自定义控件，请调用RegisterRequiresViewStateEncryption方法向页注册控件，并确保该控件的视图状态信息已加密。

RegisterRequiresViewStateEncryption方法必须在页生命周期的PreRender阶段中或该阶段之前调用，下面在前面ViewStateControl控件中重写OnPreRender方法并加入视图加密功能，增加后的代码段如下：

protected override void OnPreRender(EventArgs e)

{

    this.Page.RegisterRequiresViewStateEncryption();

    base.OnPreRender(e);

}

u 编译控件并在浏览器中重新运行，可以看到发送到客户端的隐藏域视图控件中的值由：

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value= "/wEPDwULLTE3NjU0NjM4OTEPZBYCAgMPZBYEAgEPDw8WAh4OVGV4dF9WaWV3U3RhdGUFIuaIkeaYr+eUqFZpZXdTdGF0ZeWuueWZqOWtmOWCqOeahCFkFCsAAhYEHglCYWNrQ29sb3IKAB4EXyFTQgIIZ2QCBw8PFgIeBFRleHQF9QN0aGlzLlZpZXdTdGF0ZUNvbnRyb2wxLlRleHRfTm9WaWV3U3RhdGXlsZ7mgKcg5rKh5pyJ5L+d5a2Y6KeG5Zu+54q25oCBIDxJbWcgc3JjPSdJbWFnZXNcSlMuanBnJyAvPiAgPGJyPjxicj50aGlzLlZpZXdTdGF0ZUNvbnRyb2wxLlRleHRfVmlld1N0YXRl5bGe5oCnIOW3sue7j+S/neWtmOS6huinhuWbvueKtuaAgSA8SW1nIHNyYz0nSW1hZ2VzXFhMLmpwZycgLz4gIDxicj48YnI+dGhpcy5WaWV3U3RhdGVDb250cm9sMS5GYWNlU3R5bGXlsZ7mgKcuT0sg5bey57uP5L+d5a2Y5LqG6KeG5Zu+54q25oCBIDxJbWcgc3JjPSdJbWFnZXNcWEwuanBnJyAvPiAgPGJyPjxicj50aGlzLlZpZXdTdGF0ZUNvbnRyb2wxLkZhY2VTdHlsZS5CYWNrQ29sb3Ig5bey57uP5L+d5a2Y5LqG6KeG5Zu+54q25oCBLCDnnqfvvIzmiJHnmoTpopzoibLlsLHmmK/kv53lrZjnmoTpopzoibIgPEltZyBzcmM9J0ltYWdlc1xYTC5qcGcnIC8+ICA8SW1nIHNyYz0nSW1hZ2VzXEJHLmpwZycgLz4gPGJyPjxicj5kZGTFH8U37EhQNJzHTltcDxNaH2mMfQ==" />

u 变成了已经加密的散列码：

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value= "J62G77yDi1rdf8+ZXszW1d3eAPnuzO8h2MCNPEN2HR6daQNjLLamfq4EHwWRRJ16S6kHFp43gwVPkMB9RPQtMaI5Gc+lZ9orQjsZWpvaVDTBI4fF6wFRj7qY1r2hREghEQYM/e1a+JX9oiWk1kUs8vFJ3SNeXCkCdDb7fQtr6DlCKsbCGGWDrawgiIsI0O5pnYMPloa+z74clY6/DYZ23BIAZNNYDLML/e7mVIzSS+V4FBZsXxBBdRx1oWJ60wjrfkScl1g0Dpbn+LZ2NIu7nh2t5Xu8iTW1NmjSfUoH9ymBmQkCNek3jaex18n9wBOdLGsQ8ZxO/hAGVqbcqTQStiuRYezjvm8T9Q0U9cj9SI+FnS2PktVHXqh6qLsjH1Dlwm+qFyjHK2fvbH+WA2NZUq3HzObR4GzNFRlZn8ZliO/FDJEKyH+x9X7qneaJs9dTg6mo/qbvI+S0W1viQ/nj/OrC3PoiLwvwyd1WjBlND4B21rVjnoq/J+jPNQGE+AdQR2fW3kYAtGhKf6PSVmUm9fZ26JY2rkYw2vBahPWmxHqnf9V5yt/0D3LP9Mx7KYay4PAItTeEzIT4G5I0Hp65a8d/QQJbQTCs1Qz798Mei66mqF8QrOBxR2EUsS+uCekxQe+2xDhX2kkxntoqxgRJ4/n8cdKr2Z+K3F3IEmxObo+QvQ5wUtMWrsKIY8Jad562zCNBGjlyU72i+KuORHQCBoXRgt5vPeIBpdjb0Vk3tb6t7g2T5yFyB7PBTqEwV43Ws4/BPxYsdr9YCNOJd/TB6cDI5FUS/dGYTej2EZt2HOPCM758WeEwBQZuG+t1dFEZU6+vicImHDV8ifCwNv+Yhw==" />

</div>

还可以指定视图状态信息的加密模式，通过系统枚举ViewStateEncryptionMode来设置，该枚举可以控制是否加密视图状态信息，它有三个枚举项，如表6-1所示。

表6-1 ViewStateEncryptionMode的枚举项

枚举成员

说    明

Auto

如果控件通过调用RegisterRequiresViewStateEncryption方法请求加密，则加密视图状态信息；否则不加密。此值是Page.ViewStateEncryptionMode属性的默认值

Always

强制加密视图状态信息，而不管有没有调用

Never

即使控件请求加密，也不加密视图状态信息

u 以上枚举项除了在控件中设置外，还可以在配置文件配置应用程序级别，或者在Page页面中配置成页面级别。在控件或页面中应用时仅作如下设置：

this.Page.ViewStateEncryptionMode = ViewStateEncryptionMode.Auto;

this.Page.RegisterRequiresViewStateEncryption();

经过如上设置后，页框架会自动完成加密与解密功能。对该功能再补充两点：

（1）加密视图状态肯定会影响到应用程序的性能，所以使用时要谨慎。

（2）只要页面中有任何一个控件要求对视图状态进行加密，那么页面中所有的视图状态也都将被加密。目前ASP.NET还没有实现针页面中某个控件视图加密功能（在调用时不管是在控件中还是在页面中都是调用页面控件Page的方法RegisterRequiresViewStateEncryption，且该方法没有任何可重载方法）。

6.6 清除页面状态

在控件开发时，有时候需要清除子控件的页面状态，比如在创建子控件时，以下是一个在数据绑定时清除视图并创建子控件的应用场景：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public override void DataBind()

  11. {

  13.     base.OnDataBinding(EventArgs.Empty);

  15.     Controls.Clear();

  17.     ClearChildViewState(); //清理视图状态

  19.     TrackViewState();

  21.     CreateControlHierarchy(true);

  23.     ChildControlsCreated = true;

  25. }


本节介绍几个清理页面状态的方法，主要由

Control 基类提供。

1．HasChildViewState方法

获取一个值，该值指示当前服务器控件的子控件是否具有任何已保存的视图状态设置。如果有任何子控件具有已保存的视图状态信息，则返回true；否则返回false。

2．IsChildControlStateCleared方法

获取一个值，该值指示当前控件中包含的控件是否具有控件状态。如果该控件的子级不使用控件状态，则返回true；否则返回false。

3．ClearChildState方法

同时清除子控件的视图状态和控件状态。其方法体如下：

 

  1. protected void ClearChildState()

  3. {

  5.     this.ClearChildControlState();

  7.     this.ClearChildViewState();

  9. }

4．ClearChildControlState方法

 

 

清除控件状态。其代码如下：

protected void ClearChildControlState()

{

    if (this.ControlState >= ControlState.Initialized)

    {

        this.flags.Set(0x40000);

        if (this.Page != null)

        {

            this.Page.RegisterRequiresClearChildControlState(this);

        }

    }

}

 

u 控件状态是通过方法：

Page.RegisterRequiresControlState(this);

u 将控件注册为具有持久性控件状态的控件。同时也要调用方法：

this.Page.RegisterRequiresClearChildControlState(this);

清除控件状态，不同的是：此方法是内部方法。不供开发人员调用，只能通过ClearChild ControlState方法间接调用。

5．ClearChildViewState方法

此方法主要清除子控件的视图状态，其代码结构如下：

protected void ClearChildViewState()

{

    if (this._occasionalFields != null)

    {

        this._occasionalFields.ControlsViewState = null;

    }

}

方法体中设置控件视图状态的IDictionary对象ControlsViewState为null。

6.7 对动态添加控件的视图状态分析

这一节讲点与视图状态相关的有趣的东西。我们在开发ASP.NET页面时，有时候在Page_Load事件中动态创建控件，而当页面提交后，动态修改的数据就丢失了。举个例子，看看如下代码：

 

  1. protected void Page_Load(object sender, EventArgs e)

  3. {

  5.     ListBox lb = new ListBox();

  7.     if (!Page.IsPostBack)

  9.     {

  11.         lb.Items.Add("子项1");

  13.     }

  15.     this.form1.Controls.Add(lb);

  17. }

以上代码首先动态创建一个

ListBox 控件lb ，在页面第一次请求时（提交后不再执行此句）为它增加一个集合项“子项1 ”，最后把lb 添加到当前form 集合中。

这时如果单击页面中事先放置的“提交”按钮，则页面提交后不再看到“子项1”，也就是说在视图状态中没有存储该item项。

为了解决此问题，把代码修改成：

 

protected void Page_Load(object sender, EventArgs e)

{

    ListBox lb = new ListBox();

    (lb.Items as IStateManager).TrackViewState();

    if (!Page.IsPostBack)

    {

        lb.Items.Add("子项1");

    }

    this.form1.Controls.Add(lb);

}

 

u 以上代码在为ListBox控件lb增加集合子项时之前，先启用Items属性的视图跟踪监控。这样当页面再提交时，则集合项“子项1”仍然能够呈现。扩展一下，多增加几个Item并设置几个为选中状态，再次提交页面，增加的几个item仍然能够被视图状态成功保存，且能够记住当前是否选中状态。这是为什么呢？原来ListBox控件的属性Items的继承基类ListControl中有个ListItemCollection类型的items对象，像“子项1”这些item就是被增加到items对象中进行管理的。关键的一点是，ListItemCollection集合对象实现了IStateManager接口，看一下它的类定义：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public sealed class ListItemCollection : IList, ICollection, IEnumerable, IStateManager

{

    // Fields

    private ArrayList listItems;

    private bool marked;

    private bool saveAll;

 

    // Methods

    public ListItemCollection();

    public void Add(string item);

    public void Add(ListItem item);

    public void AddRange(ListItem[] items);

    public void Clear();

    public bool Contains(ListItem item);

    public void CopyTo(Array array, int index);

    public ListItem FindByText(string text);

    internal int FindByTextInternal(string text, bool includeDisabled);

    public ListItem FindByValue(string value);

    internal int FindByValueInternal(string value, bool includeDisabled);

    public IEnumerator GetEnumerator();

    public int IndexOf(ListItem item);

    public void Insert(int index, string item);

    public void Insert(int index, ListItem item);

    internal void LoadViewState(object state);

    public void Remove(string item);

    public void Remove(ListItem item);

    public void RemoveAt(int index);

    internal object SaveViewState();

    int IList.Add(object item);

    bool IList.Contains(object item);

    int IList.IndexOf(object item);

    void IList.Insert(int index, object item);

    void IList.Remove(object item);

    void IStateManager.LoadViewState(object state);

    object IStateManager.SaveViewState();

    void IStateManager.TrackViewState();

    internal void TrackViewState();

 

    // Properties

    public int Capacity { get; set; }

    public int Count { get; }

    public bool IsReadOnly { get; }

    public bool IsSynchronized { get; }

    public ListItem this[int index] { get; }

    public object SyncRoot { get; }

    bool IList.IsFixedSize { get; }

    object IList.this[int index] { get; set; }

    bool IStateManager.IsTrackingViewState { get; }

}

 

u ListItemCollection类实现了IStateManager接口下的几个视图状态相关方法，因为它自身具有视图状态管理能力。基于此，在增加到ListBox对象子项之前，调用这句：

(lb.Items as IStateManager).TrackViewState();

把它的视图跟踪监控功能打开，即从此刻起视图状态将记录它所有的修改，当然包括它增加的“子项1”项。这就是页面提交“子项1”仍然能够显示在页面上的原因。

只有实现了IStateManger接口的集合才能够调用TrackViewState方法打开视图监控。如果没有实现此接口的对象，还有一种方法可以实现视图状态功能，把最初的代码修改成如下格式：

 

protected void Page_Load(object sender, EventArgs e)

{

    ListBox lb = new ListBox();

    this.form1.Controls.Add(lb);

    if (!Page.IsPostBack)

    {

        lb.Items.Add("子项1");

    }

}

 

u 在上面的代码中对之前不能够保存视图状态的代码，仅调换了一下代码顺序。把this.form1.Controls.Add（lb）这句放到了lb.Item.Add（“子项1”）之前。运行页面并单击“提交”按钮，就会发现item“子项1”也能够保存视图状态。仅作了代码调整即使lb实现了视图状态保存，这是什么原因呢？这里的关键语句：

this.form1.Controls.Add(lb);

中的关键方法Add起了重要作用。Controls集合的Add方法最终调用的是Control控件基类中的方法AddedControl。直接看一下AddedControl的代码实现：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. protected internal virtual void AddedControl(Control control, int index)

  11. {

  13.     if (control.OwnerControl != null)

  15.     {

  17.         throw new InvalidOperationException(SR.GetString("Substitution_ 

  19.         NotAllowed"));

  21.     }

  23.     if (control._parent != null)

  25.     {

  27.         control._parent.Controls.Remove(control);

  29.     }

  31.     control._parent = this;

  33.     control._page = this.Page;

  35.     control.flags.Clear(0x20000);

  37.     Control namingContainer = this.flags[0x80] ? this : this._namingContainer;

  39.     if (namingContainer != null)

  41.     {

  43.         control.UpdateNamingContainer(namingContainer);

  45.         if ((control._id == null) && !control.flags[0x40])

  47.         {

  49.             control.GenerateAutomaticID();

  51.         }

  53.         else if ((control._id != null) || ((control._occasionalFields != null) 

  55.         && (control._occasionalFields.Controls != null)))

  57.         {

  59.             namingContainer.DirtyNameTable();

  61.         }

  63.     }

  65.     if (this._controlState >= ControlState.ChildrenInitialized)

  67.     {

  69.         control.InitRecursive(namingContainer);

  71.         if (((control._controlState >= ControlState.Initialized) && (control. 

  73.         RareFields != null)) && control.RareFields.RequiredControlState)

  75.         {

  77.             this.Page.RegisterRequiresControlState(control);

  79.         }

  81.         if (this._controlState >= ControlState.ViewStateLoaded)

  83.         {

  85.             object savedState = null;

  87.             if ((this._occasionalFields != null) && (this._occasionalFields. 

  89.             ControlsViewState != null))

  91.             {

  93.                 savedState = this._occasionalFields.ControlsViewState[index];

  95.                 if (this.LoadViewStateByID)

  97.                 {

  99.                     control.EnsureID();

  101.                     savedState =this._occasionalFields.ControlsViewState [control. ID];

  103.                     this._occasionalFields.ControlsViewState.Remove (control.ID);

  105.                 }

  107.                 else

  109.                 {

  111.                     savedState = this._occasionalFields.ControlsViewState[index];

  113.                     this._occasionalFields.ControlsViewState.Remove(index);

  115.                 }

  117.             }

  119.             control.LoadViewStateRecursive(savedState);

  121.             if (this._controlState >= ControlState.Loaded)

  123.             {

  125.                 control.LoadRecursive();

  127.                 if (this._controlState >= ControlState.PreRendered)

  129.                 {

  131.                     control.PreRenderRecursiveInternal();

  133.                 }

  135.             }

  137.         }

  139.     }

  141. }


这是

.NET 类库代码，不必全部看懂。但要知道此方法能够启用视图状态和向页面请求注册控件状态（假如需要的话）。

视图状态跟踪被启用后，接下来执行对item“子项1”的增加当然也能够被页框架视图管理器保存。

6.8 自定义类型转换器实现高效率序列化

由于ViewState数据是作为序列化格式串存储的，在视图装载和保存阶段，需要进行正反序列化。这对于复杂对象是比较耗资源的，还好系统已经对一些如ArrayList和哈希表集合等类型对象进行了优化；但对于我们自定义的类对象，在默认情况下使用.NetFramework提供的二进制序列化功能来序列化对象，比较耗资源，解决的办法是为自定义类提供专门的类型转换器（TypeConverter），实现字符串到对象的相互转换，这种方法比默认.Net提供的二进制序列化要节省资源。

类型转换器在第4章的4.6.2节已经讲解过了，这里不再多说，如果还不明白请回顾一下前面章节。之前定义的类型转换器主要用于设计器中的设计与代码视图切换。这里我们把类型转换器应用于视图状态。下面就来看一个例子，示例控件名称为ViewStateTypeConverter，示例中仍然使用在第4章我们自定义的三维坐标类SolidCoordinate和该类的自定义类型转换器SolidCoordinateConverter。这两个类代码比较简单，先回顾一下这两个类的代码。SolidCoordinate代码如下：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

[TypeConverter(typeof(SolidCoordinateConverter))]

public class SolidCoordinate

{

    private int x;

    private int y;

    private int z;

 

    public SolidCoordinate()

    {       

    }

 

    public SolidCoordinate(int x, int y, int z)

    {

        this.x = x;

        this.y = y;

        this.z = z;

    }

 

    [NotifyParentProperty(true)]

    public int X

    {

        get

        {

            return this.x;

        }

        set

        {

            this.x = value;

        }

    }

 

    [NotifyParentProperty(true)]

    public int Y

    {

        get

        {

            return this.y;

        }

        set

        {

            this.y = value;

        }

    }

 

    [NotifyParentProperty(true)]

    public int Z

    {

        get

        {

            return this.z;

        }

        set

        {

            this.z = value;

        }

    }

}

 

u SolidCoordinateConverter类的代码如下：

 

  1. /// <summary>

  3. ///  SolidCoordinate类的自定义类型转换器

  5. /// </summary>

  7. public class SolidCoordinateConverter : TypeConverter

  9. {

  11.     

  13.     /// <summary>

  15.     /// 判断是否能从字符串转换为SolidCoordinate类

  17.     /// </summary>

  19.     /// <param name="context"></param>

  21.     /// <param name="sourceType"></param>

  23.     /// <returns></returns>

  25.     public override bool CanConvertFrom(ITypeDescriptorContext context, Type 

  27.     sourceType)

  29.     {

  31.         return ((sourceType == typeof(string)) || base.CanConvertFrom(context, 

  33.         sourceType));

  35.     }



  39.     /// <summary>

  41.     /// 判断是否能从SolidCoordinate类转换为string或InstanceDescriptor类型

  43.     /// </summary>

  45.     /// <param name="context"></param>

  47.     /// <param name="destinationType"></param>

  49.     /// <returns></returns>

  51.     public override bool CanConvertTo(ITypeDescriptorContext context, Type 

  53.     destinationType)

  55.     {

  57.         return ((destinationType == typeof(InstanceDescriptor)) || base. 

  59.         CanConvertTo(context, destinationType));

  61.     }

  63.   

  65.     



  69.     /// <summary>

  71.     /// 从字符串转换为SolidCoordinate类型

  73.     /// </summary>

  75.     /// <param name="context"></param>

  77.     /// <param name="culture"></param>

  79.     /// <param name="value"></param>

  81.     /// <returns></returns>

  83.     public override object ConvertFrom(ITypeDescriptorContext context, 

  85.     CultureInfo culture, object value)

  87.     {

  89.         string str = value as string;

  91.         if (str == null)

  93.         {

  95.             return base.ConvertFrom(context, culture, value);

  97.         }

  99.         string str2 = str.Trim();

  101.         if (str2.Length == 0)

  103.         {

  105.             return null;

  107.         }

  109.         if (culture == null)

  111.         {

  113.             culture = CultureInfo.CurrentCulture;

  115.         }

  117.         char ch = culture.TextInfo.ListSeparator[0];

  119.         string[] strArray = str2.Split(new char[] { ch });

  121.         int[] numArray = new int[strArray.Length];

  123.         TypeConverter converter = TypeDescriptor.GetConverter(typeof(int));

  125.         for (int i = 0; i < numArray.Length; i++)

  127.         {

  129.             numArray[i] = (int)converter.ConvertFromString(context, culture, 

  131.             strArray[i]);

  133.         }

  135.         if (numArray.Length != 3)

  137.         {

  139.             throw new Exception("格式不正确!");

  141.         }

  143.         return new SolidCoordinate(numArray[0], numArray[1], numArray[2]);

  145.     }



  149.     /// <summary>

  151.     /// 从SolidCoordinate类转换为string或InstanceDescriptor类型

  153.     /// </summary>

  155.     /// <param name="context"></param>

  157.     /// <param name="culture"></param>

  159.     /// <param name="value"></param>

  161.     /// <param name="destinationType"></param>

  163.     /// <returns></returns>

  165.     public override object ConvertTo(ITypeDescriptorContext context, 

  167.     CultureInfo culture, object value, Type destinationType)

  169.     {

  171.         if (destinationType == null)

  173.         {

  175.             throw new Exception("目标类型不能为空!");

  177.         }

  179.         if (value is SolidCoordinate)

  181.         {

  183.             if (destinationType == typeof(string))

  185.             {

  187.                 SolidCoordinate solidCoordinate = (SolidCoordinate)value;

  189.                 if (culture == null)

  191.                 {

  193.                     culture = CultureInfo.CurrentCulture;

  195.                 }

  197.                 string separator = culture.TextInfo.ListSeparator + " ";

  199.                 TypeConverter converter=TypeDescriptor.GetConverter(typeof(int));

  201.                 string[] strArray = new string[3];

  203.                 int num = 0;

  205.                 strArray[num++] = converter.ConvertToString(context, culture, s

  207.                 olidCoordinate.X);

  209.                 strArray[num++] = converter.ConvertToString(context, culture, 

  211.                 solidCoordinate.Y);

  213.                 strArray[num++] = converter.ConvertToString(context, culture, 

  215.                 solidCoordinate.Z);

  217.                 return string.Join(separator, strArray);

  219.             }

  221.             if (destinationType == typeof(InstanceDescriptor))

  223.             {

  225.                 SolidCoordinate solidCoordinate2 = (SolidCoordinate)value;

  227.                 ConstructorInfo constructor =typeof(SolidCoordinate). 

  229.                 GetConstructor(new Type[]{typeof(int),typeof(int),typeof(int)});

  231.                 if (constructor != null)

  233.                 {

  235.                     return new InstanceDescriptor(constructor, new object[] 

  237. { solidCoordinate2.X, solidCoordinate2.Y, solidCoordinate2.Z });

  239.                 }

  241.             }

  243.         }

  245.         return base.ConvertTo(context, culture, value, destinationType);

  247.     }



  251.     /// <summary>

  253.     /// 根据上下文和指定的属性字典创建实例

  255.     /// </summary>

  257.     /// <param name="context"></param>

  259.     /// <param name="propertyValues"></param>

  261.     /// <returns></returns>

  263.     public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)

  265.     {

  267.         if (propertyValues == null)

  269.         {

  271.             throw new Exception("属性值不能为空!");

  273.         }

  275.         object obj2 = propertyValues["X"];

  277.         object obj3 = propertyValues["Y"];

  279.         object obj4 = propertyValues["Z"];

  281.         if (((obj2 == null) || (obj3 == null) || (obj4 == null)) || (!(obj2 is 

  283.         int) || !(obj3 is int) || !(obj4 is int)))

  285.         {

  287.             throw new Exception("格式不正确!");

  289.         }

  291.         return new SolidCoordinate((int)obj2, (int)obj3, (int)obj4);

  293.     }

  295.   



  299.     /// <summary>

  301.     /// 如果更改此对象的属性需要调用CreateInstance 来创建新值，则返回true；否则为false

  303.     /// </summary>

  305.     /// <param name="context"></param>

  307.     /// <returns></returns>

  309.     public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)

  311.     {

  313.         return true;

  315.     }        

  317.     



  321.     /// <summary>

  323.     /// 使用指定的上下文和attributes集合作为参数，返回由参数value指定的集合数组

  325.     /// </summary>

  327.     /// <param name="context"></param>

  329.     /// <param name="value"></param>

  331.     /// <param name="attributes"></param>

  333.     /// <returns></returns>

  335.     public override PropertyDescriptorCollection GetProperties (ITypeDescriptorContext context, object value, Attribute[] attributes)

  337.     {

  339.         return TypeDescriptor.GetProperties(typeof(SolidCoordinate), attributes).Sort(new string[] { "X", "Y", "Z" });

  341.     }     



  345.     /// <summary>

  347.     /// 使用指定的上下文返回该对象是否支持单属性录入[如果指定, 属性窗口也会提

  349.     /// 供扩展输入模式]

  351.     /// </summary>

  353.     /// <param name="context"></param>

  355.     /// <returns></returns>

  357.     public override bool GetPropertiesSupported(ITypeDescriptorContext context)

  359.     {

  361.         return true;

  363.     }

  365. }


这两个类在第

4 章已经讲解过，这里就不再介绍了。如果还不明白，请回顾一下4.6.2.1 小节。

接下来讲解我们最关注的主控件。在主控件中增加一个SolidCoordinate类型的属性，代码如下所示：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

[DefaultProperty("SolidCoordinate")]

[ToolboxData("<{0}:ViewStateTypeConverter runat=server></{0}:ViewStateTypeConverter>")]

public class ViewStateTypeConverter : WebControl

{

    SolidCoordinate solidCoordinate;

    [Category("转换器")]

    [Description("SolidCoordinate类型属性(具有三个值的扩展类型)")]

    public SolidCoordinate SolidCoordinate

    {

        get

        {

            if (solidCoordinate == null)

            {

                solidCoordinate = new SolidCoordinate();

            }

            return solidCoordinate;

        }

        set

        {

            solidCoordinate = value;

        }

    }

    //… …

}

u 主控件类代码中就包括一个复杂属性。先不在主控件中增加视图相关的代码，而在页面中测试一下它现在是否能够保存视图状态。编译控件，在页面中放置一个ViewStateType Converter控件，增加一个“提交”按钮，最终页面的前台代码如下：

<body>

    <form id="form1" runat="server">

    <div>

        <cc1:viewstatetypeconverter id="ViewStateTypeConverter1" runat= "server"></cc1:viewstatetypeconverter>

        <br />

        <asp:Button ID="Button1" runat="server" Text="提交页面" OnClick= "Button1_Click" />   

    </div>

    </form>

</body>

u 然后在Page_Load中增加页面首次请求时的属性赋值代码，如下所示：

 

  1. protected void Page_Load(object sender, EventArgs e)

  3. {

  5.     if (!Page.IsPostBack)        

  7.     {

  9.         ViewStateTypeConverter1.SolidCoordinate = new KingControls.Solid Coordinate(1, 2, 3);

  11.     }

  13. }

  15. protected void Button1_Click(object sender, EventArgs e)

  17. {

  19.     this.Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "OutputResult", "alert('(X:" + ViewStateTypeConverter1.SolidCoordinate. X.ToString() + ",Y:" + ViewStateTypeConverter1.SolidCoordinate.Y.ToString() + ",Z:" + ViewStateTypeConverter1.SolidCoordinate.Z.ToString() + ")');", true);        

  21. }


在上面的代码中还增加了“提交”按钮的事件，主要是通过客户端

alert 方法输出当前控件的属性值。通过输出结果确认视图状态是否成功保存，如果输出值不等于我们设置的（1,2,3 ），则说明该属性没有保存到视图状态中。

在浏览器中运行页面。由于这是页面第一次请求，会执行Page_Load中的控件赋值语句，给控件的属性SolidCoordinate赋值（1,2,3），然后单击“提交”按钮，输出结果如图6-7所示。

通过示例证明，现在主控件还不能对属性SolidCoordinate进行视图状态保存，还得我们自己去实现这个功能。OK，继续在主控件中增加视图状态相关的两个方法LoadViewState和SaveViewState，这两个方法最终的代码如下：

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-7 SolidCoordinate属性值没有保存到ViewState中

 

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public class ViewStateTypeConverter : WebControl

{

    //… …

    protected override object SaveViewState()

    {

        Pair p = new Pair();

        p.First = base.SaveViewState();

        SolidCoordinateConverter convert = new SolidCoordinateConverter();

        p.Second = convert.ConvertTo(null, null, this.SolidCoordinate,typeof (string));

        for (int i = 0; i < 2; i++)

        {

            if (p.First != null || p.Second != null)

            {

                return p;

            }

        }

        return null;

    }

 

    protected override void LoadViewState(object savedState)

    {

        if (savedState == null)

        {

            base.LoadViewState(null);

            return;

        }

        else

        {

            Pair p = (Pair)savedState;

            if (p == null)

            {

                throw new ArgumentException("无效的View State 数据!");

            }

            base.LoadViewState(p.First);

            if (p.Second != null)

            {

                SolidCoordinateConverter convert = new SolidCoordinate Converter();

                this.SolidCoordinate = convert.ConvertFrom(null, null, p.

                Second) as SolidCoordinate;

            }

        }

    }

    //… …

}

u 先讲解一下SaveViewState方法中的代码逻辑。首先定义一个Pair对象p，成员p.First负责存储基类中序列化后的对象（其中就包括ViewState属性对象）；至于成员p.Second，笔者用它来存储SolidCoordinate属性，主要通过这两句完成序列化功能：

SolidCoordinateConverter convert = new SolidCoordinateConverter();

p.Second=convert.ConvertTo(null,null,this.SolidCoordinate,typeof(string));

第一条语句定义SolidCoordinate类的转换器对象，第二条语句使用转换器对象的ConvertTo方法把SolidCoordinate类型的属性转换为字符串，存储到p.Second属性中。最后返回p作为整个控件的对象序列化结果。

而LoadViewState逻辑正好相反，主要功能是把视图信息对象再赋值给控件属性（包括基类的属性）。不同的是这次调用的是ConvertFrom方法。

增加这两个方法后，主控件已经使SolidCoordinate属性具有了视图状态保存能力。再在浏览器中运行页面验证一下，单击“提交”按钮后输出的结果如图6-8所示。

 

 

★★★【庖丁解牛：纵向切入Asp.net 3.5控件和组件开发技术系列—(6)页面状态机制(视图状态和控件状态)】★★★

图6-8 SolidCoordinate属性值成功保存到ViewState中

 

另外，如果在自定义类内部关联了类型转换器，则还可以把这句：

SolidCoordinateConverter convert = new SolidCoordinateConverter();

u 修改成如下写法：

TypeConverter convert = TypeDescriptor.GetConverter(this.SolidCoordinate);

这两句功能相同，不同的是后者使用TypeDescriptor的GetConverter静态方法返回指定类的关联转换器。

这一节内容就讲这么多。本节以SolidCoordinate类为典型例子，说明了类型转换器在视图状态中的用法。使用这种方式，为自己的控件属性的增加视图状态时，就比较容易了。噢，忘了一点，还要记住我们是为了提高序列化速度而采用的这种方法。

6.9  页面状态性能优化策略

6.9.1 存储位置优化——把视图状态信息保存在服务端而非客户端

视 图状态信息默认情况下是存储在客户端的，不占用服务端资源（这里是指持续地占用服务器资源一定时间，视图状态只是在页面呈现时，服务端正反向解析视图状态 内容占用一会服务器内存，当页面呈现完成后则会把视图存储到页面上的隐藏控件域中）。当页面结构比较复杂时，会导致视图信息字节数比较大，则会产生带宽瓶 颈。为了解决这个问题我们可以选择把视图信息存储到服务器端，或数据库中，或文件等存储介质。这一节我们就以把视图状态存储到服务端Session中为例，说明其实现方法。

新建一个页面SessionPageStatePersister.aspx，页面中的内容仍然使用前面的控件状态控件的测试页面内容，设置好页面内容后，在后台代码中重写基类Page的PageStatePersister属性，如下所示：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public partial class Page_SessionPageStatePersister : System.Web.UI.Page

{

    protected override PageStatePersister PageStatePersister

    {

        get

        {

            return new SessionPageStatePersister(this);

        }

    }

}

 

u 为了更容易理解，下面是Page对该属性的系统默认实现源代码：

 

  1. protected virtual PageStatePersister PageStatePersister

  3. {

  5.     get

  7.     {

  9.         if (this._persister == null)

  11.         {

  13.             PageAdapter pageAdapter = this.PageAdapter;

  15.             if (pageAdapter != null)

  17.             {

  19.                 this._persister = pageAdapter.GetStatePersister();

  21.             }

  23.             if (this._persister == null)

  25.             {

  27.                 this._persister = new HiddenFieldPageStatePersister(this);

  29.             }

  31.         }

  33.         return this._persister;

  35.     }

  37. }


ASP.NET

的默认持久性机制是使用HiddenFieldPageStatePersister 类将视图状态存储在客户端，即系统默认实现是在属性PageStatePersister 中返回HiddenFieldPageStatePersister 类实例，表示存储在客户端的隐藏域中。上面我们重写该属性，返回 SessionPageStatePersister 类 实例，SessionPageStatePersister 类表示在Web 服务器Session 会话中存储ASP.NET 页视图状态。

OK，运行一下页面，并查看一下它的隐藏域视图信息，会发现__VIEWSTATE由原来的：

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value= "/wEPDwUJNzIxMjkzNTM2D2QWAgIDD2QWBAIBDw8WAh4OVGV4dF9WaWV3U3RhdGUFIuaIkeaYr+eUqFZpZXdTdGF0ZeWuueWZqOWtmOWCqOeahCFkZAIHDw8WAh4EVGV4dAWQBHRoaXMuQ29udHJvbFN0YXRlQ29udHJvbDEuVGV4dF9Ob1ZpZXdTdGF0ZeWxnuaApyDmsqHmnInkv53lrZjmjqfku7bnirbmgIEgPEltZyBzcmM9Jy4uXEltYWdlc1xKUy5qcGcnIC8+ICA8YnI+PGJyPnRoaXMuQ29udHJvbFN0YXRlQ29udHJvbDEuVGV4dF9WaWV3U3RhdGXlsZ7mgKcg5bey57uP5L+d5a2Y5LqG5o6n5Lu254q25oCBIDxJbWcgc3JjPScuLlxJbWFnZXNcWEwuanBnJyAvPiAgPGJyPjxicj50aGlzLkNvbnRyb2xTdGF0ZUNvbnRyb2wxLkZhY2VTdHlsZeWxnuaApy5PSyDlt7Lnu4/kv53lrZjkuobmjqfku7bnirbmgIEgPEltZyBzcmM9Jy4uXEltYWdlc1xYTC5qcGcnIC8+ICA8YnI+PGJyPnRoaXMuQ29udHJvbFN0YXRlQ29udHJvbDEuRmFjZVN0eWxlLkJhY2tDb2xvciDlt7Lnu4/kv53lrZjkuobmjqfku7bnirbmgIEsIOeep++8jOaIkeeahOminOiJsuWwseaYr+S/neWtmOeahOminOiJsiA8SW1nIHNyYz0nLi5cSW1hZ2VzXFhMLmpwZycgLz4gIDxJbWcgc3JjPScuLlxJbWFnZXNcQkcuanBnJyAvPiA8YnI+PGJyPmRkGAEFFENvbnRyb2xTdGF0ZUNvbnRyb2wxDw8PFgIfAAUi5oiR5piv55SoVmlld1N0YXRl5a655Zmo5a2Y5YKo55qEIWQUKwACFgQeCUJhY2tDb2xvcgoAHgRfIVNCAghnZHweEc0h/1gIsxczc2fHdmLTQy1x" />

u 变为现在的：

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value= "/wEPaA8FDzhjYTlhMjI1ZDY2NTQ3MxgBBRRDb250cm9sU3RhdGVDb250cm9sMQ8PDxYCHg5UZXh0X1ZpZXdTdGF0ZQUi5oiR5piv55SoVmlld1N0YXRl5a655Zmo5a2Y5YKo55qEIWQUKwACFgQeCUJhY2tDb2xvcgoAHgRfIVNCAghnZNiSxDj0eWw88GLxQrKC0IucFKmW" />

另外，这里的HiddenFieldPageStatePersister和SessionPageStatePersister都是继承基类 System.Web.UI.PageStatePersister，该基类允许自定义持久化机制，如果既不想存储到客户端隐藏域中，也不想存储到Session中，可以定义该类的派生类，实现自定义持久化机制。在6.8.2小节有一个派生System.Web.UI.PageStatePersister 类的例子。

除了使用重写基类Page的PageStatePersister属性实现指定持久化类对象外，还可以通过实现System.Web.UI.Adapters.PageAdapter类的页配器实现同样功能。PageAdapter类是一个抽象类，可以修改网页以适应特定的浏览器，并提供所有页面适配器可直接或间接继承的基类。下面是一个自定义页适配器的例子：

 

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public class SessionPageAdapter : System.Web.UI.Adapters.PageAdapter

{

    public override PageStatePersister GetStatePersister()

    {

        return new SessionPageStatePersister(this.Page);

    }

}

 

 

u 然后在站点下面添加App_Browsers目录，并添加一个文件名称为SessionPageAdapter.browser的文件，内容如下：

<browsers>

   //… …

    <browser refID="Default">

      <controlAdapters>

        <adapter controlType="System.Web.UI.Page" adapterType="KingControls. SessionPageAdapter" />

      </controlAdapters>

    </browser> 

</browsers>

运行一下页面，也会发现得到与之前相同的效果。这两种方法都能够在服务器Session中存储视图信息。不同的一点是后面这种方式影响到了整个站点下面的所有页面。

Session一般用于存储特定于单独会话的短期信息，比存储到客户端隐藏域中方式要安全得多。但这种方式要占用服务器内存，因此在客户端比较多的情况下不要在Session中存储大量的信息。

6.9.2 体积优化——压缩视图状态数据

这一节讲解另一种优化技术，在序列化对象信息前先压缩数据。其实现机制也是重写基类Page的PageStatePersister属性，下面就介绍一下它的实现。

首先定义一个实现System.Web.UI.PageStatePersister基类的类CompressPageStatePersister，代码如下所示：

 

  1. /// <summary>

  3. /// 获得本书更多内容,请看:

  5. /// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

  7. /// </summary>

  9. public class CompressPageStatePersister : PageStatePersister

  11. {

  13.     private string PageStateKey = "____VIEWSTATE";

  15.     public CompressPageStatePersister(Page page) : base(page)

  17.     {

  19.     }

  21.     public override void Load()

  23.     {

  25.         string postbackState = Page.Request.Form[PageStateKey];

  27.         if (!string.IsNullOrEmpty(postbackState))

  29.         {

  31.             //页面状态包括视图状态和控件状态两部分

  33.             Pair statePair = (Pair)CompressHelp.Decompress(postbackState);

  35.             if (!Page.EnableViewState)

  37.             {

  39.                 this.ViewState = null;

  41.             }

  43.             else

  45.             {

  47.                 this.ViewState = statePair.First;

  49.             }

  51.             this.ControlState = statePair.Second;

  53.         }

  55.     }



  59.     public override void Save()

  61.     {

  63.         if (!Page.EnableViewState)

  65.         {

  67.             this.ViewState = null;

  69.         }

  71.         if (this.ViewState != null || this.ControlState != null)

  73.         {

  75.         string stateString;

  77.             Pair statePair = new Pair(ViewState, ControlState);

  79.             stateString = CompressHelp.Compress(statePair);

  81.             Page.ClientScript.RegisterHiddenField(PageStateKey, stateString);

  83.         }

  85.     }

  87. }


在以上代码中重写了

PageStatePersister 类的的Load 和Save 两个方法。PageStateKey 变量为页面状态保存在页面中的字段名。

在Load方法中，首先通过语句：

string postbackState = Page.Request.Form[PageStateKey];

取得保存到客户端压缩了的状态信息，然后调用压缩类CompressHelp中的Decompress方法解压缩返回，然后赋值给基类中的this.ViewState和this.ControlState，这两个对象分别标志视图状态和控件状态。

Save的过程正好相反，将当前对象的数据压缩，并通过Page.RegisterHiddenField方法把值注册到客户端隐藏控件。

压缩类CompressHelp主要提供了两个静态方法，代码如下：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

public class CompressHelp

{

    //序列化工具，LosFormatter是页面默认的序列器

    private static LosFormatter _formatter = new LosFormatter();

    /// <summary>

    /// 解压并反序列化状态内容

    /// </summary>

    /// <param name="stateString">从客户端取回的页面状态字符串</param>

    /// <returns>还原后的页面状态Pair对象</returns>

    public static object Decompress(string stateString)

    {

        byte[] buffer = Convert.FromBase64String(stateString);

        MemoryStream ms = new MemoryStream(buffer);

        GZipStream zipStream = new GZipStream(ms, CompressionMode.Decompress);

        MemoryStream msReader = new MemoryStream();

        buffer = new byte[0x1000];

        while (true)

        {

            int read = zipStream.Read(buffer, 0, buffer.Length);

            if (read <= 0)

            {

                break;

            }

            msReader.Write(buffer, 0, read);

        }

        zipStream.Close();

        ms.Close();

        msReader.Position = 0;

        buffer = msReader.ToArray();

        stateString = Convert.ToBase64String(buffer);

        return _formatter.Deserialize(stateString);

    }

    /// <summary>

    /// 序列化并压缩状态内容

    /// </summary>

    /// <param name="state">页面状态</param>

    /// <returns>结果字符串</returns>

    public static string Compress(object state)

    {

        StringWriter writer = new StringWriter();

        _formatter.Serialize(writer, state);

        string stateString = writer.ToString();

        writer.Close();

        byte[] buffer = Convert.FromBase64String(stateString);

        MemoryStream ms = new MemoryStream();

        GZipStream zipStream=new GZipStream(ms,CompressionMode.Compress,true);

        zipStream.Write(buffer, 0, buffer.Length);

        zipStream.Close();

        buffer = new byte[ms.Length];

        ms.Position = 0;

        ms.Read(buffer, 0, buffer.Length);

        ms.Close();

        stateString = Convert.ToBase64String(buffer);

        return stateString;

    }

}

u 最后，把定义的KingControls.CompressPageStatePersister应用到页面上（页面名称为CompressPageState.aspx，内容仍然使用前面的控件状态控件的测试页面内容）。代码如下：

/// <summary>

/// 获得本书更多内容,请看:

/// http://blog.csdn.net/ChengKing/archive/2008/08/18/2792440.aspx

/// </summary>

protected override PageStatePersister PageStatePersister

{

    get

    {

        return new CompressPageStatePersister(this);

    }

}   

 

u OK，在浏览器中运行页面，可以看到，页面中的__VIEWSTATE值由原来的：

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value= "/wEPDwUJNzIxMjkzNTM2D2QWAgIDD2QWBAIBDw8WAh4OVGV4dF9WaWV3U3RhdGUFIuaIkeaYr+eUqFZpZXdTdGF0ZeWuueWZqOWtmOWCqOeahCFkZAIHDw8WAh4EVGV4dAWQBHRoaXMuQ29udHJvbFN0YXRlQ29udHJvbDEuVGV4dF9Ob1ZpZXdTdGF0ZeWxnuaApyDmsqHmnInkv53lrZjmjqfku7bnirbmgIEgPEltZyBzcmM9Jy4uXEltYWdlc1xKUy5qcGcnIC8+ICA8YnI+PGJyPnRoaXMuQ29udHJvbFN0YXRlQ29udHJvbDEuVGV4dF9WaWV3U3RhdGXlsZ7mgKcg5bey57uP5L+d5a2Y5LqG5o6n5Lu254q25oCBIDxJbWcgc3JjPScuLlxJbWFnZXNcWEwuanBnJyAvPiAgPGJyPjxicj50aGlzLkNvbnRyb2xTdGF0ZUNvbnRyb2wxLkZhY2VTdHlsZeWxnuaApy5PSyDlt7Lnu4/kv53lrZjkuobmjqfku7bnirbmgIEgPEltZyBzcmM9Jy4uXEltYWdlc1xYTC5qcGcnIC8+ICA8YnI+PGJyPnRoaXMuQ29udHJvbFN0YXRlQ29udHJvbDEuRmFjZVN0eWxlLkJhY2tDb2xvciDlt7Lnu4/kv53lrZjkuobmjqfku7bnirbmgIEsIOeep++8jOaIkeeahOminOiJsuWwseaYr+S/neWtmOeahOminOiJsiA8SW1nIHNyYz0nLi5cSW1hZ2VzXFhMLmpwZycgLz4gIDxJbWcgc3JjPScuLlxJbWFnZXNcQkcuanBnJyAvPiA8YnI+PGJyPmRkGAEFFENvbnRyb2xTdGF0ZUNvbnRyb2wxDw8PFgIfAAUi5oiR5piv55SoVmlld1N0YXRl5a655Zmo5a2Y5YKo55qEIWQUKwACFgQeCUJhY2tDb2xvcgoAHgRfIVNCAghnZMhDeYVwXQ029fkRLFj7HE0Hw8SV" />

u 变为了现在的：

<input type="hidden" name="____VIEWSTATE" id="____VIEWSTATE" value= "H4sIAAAAAAAEAO29B2AcSZYlJi9tynt/SvVK1+B0oQiAYBMk2JBAEOzBiM3mkuwdaUcjKasqgcplVmVdZhZAzO2dvPfee++999577733ujudTif33/8/XGZkAWz2zkrayZ4hgKrIHz9+fB8/Iv7vX/M3/U1/3R97sLe79/De/Xuf/qaz3+bX+rV+bfr31/m16Ivf5tf6Bb/Jm/xd+/v/ZJFfvW6zNv91P/ov/qg/+b/4s/7G//JP+6vsZ//53/B3/+d/9l/1n//1f9Z//of8Vf/ln/OH/a6z2a/16/O7vw7e/XX/pF+nnRfN+KRatnVV8hv6++6Ygb+oHKi/+S/4L/6gvzL9L/6Wv/i/+PP+6P/sH/zzCeh/8Sf8lf/Z3/t3/Jd/zN/xX/xBf3D6+GxxkTb19LOPx+Pf92yRXeTN7/ud1+OfXl18nN49StPHk/oI/7+hx25///nf+bf8l3/vnyj9/Wd/zx9xY5e/9/P36fJZNs1ft9el9jb+8vf6YXU4fpJN355UZVVv6nGU/pd/wV/5P/59fxzNLE3ff/2X/Hn/1R/9t/znf9PfTLMsze2HN6MW+f7J5/Z7g/ls9tv9mr/ubxVD/TcF3/wuv8atuOy3+uTX+LV+m1/nF/yYHWPya/yCX+f3/11fP/m1foOL2f8DRHjCstcCAAA=" />

可以看到明显小了许多。当页面越复杂时压缩比会越大。笔者在自己的项目中测试过，一个50KB的页面，经过压缩后变为40KB，相当于压缩了10KB。另外，它会占用服务器CPU和内存，但相比网络带宽这点代价算不了什么。

6.9.3 分块存储视图状态数据

如果隐藏域中的数据量过大，某些代理和防火墙将阻止对包含这些数据的页的访问。由于最大数量会随所采用的防火墙和代理的不同而不同，较大的隐藏域可能会出现偶发性问题。如果您需要存储大量的数据项，可以打开视图状态分块，这样会自动将数据分割到多个隐藏域。

ASP.NET框架提供了MaxPageStateFieldLength属性，用来获取或设置页状态字段的最大长度。其属性值表示页面状态字段的最大长度，以字节为单位。

微软官方网站以及很多文章介绍说，通过设置Page.MaxPageStateFieldLength属性可以指定块的最大字节数，且MSDN明确说明此属性是公有的，笔者在VS 2005和VS 2008下测试结果是Page下面根本没有这个属性，所以采用在配置文件Web.Config中实现，如下：

<system.web>

    <pages maxPageStateFieldLength="100" />   

<system.web>

当MaxPageStateFieldLength属性设置为正数时，发送到客户端浏览器的视图状态将分为多个隐藏字段，并且每个字段的值都小于在MaxPageStateFieldLength属性中指定的大小；而如果MaxPageStateFieldLength属性设置为负数（默认值）则表示不应将视图状态字段分成多个块区。另外，如果将MaxPageStateFieldLength设置非常小，会导致性能降低。

6.10 视图状态和控件状态的总结

前面讲了页面状态的各个方面，从概念到代码演示再到性能。本节做个总结，重新理一下页面状态内容，说明视图状态和控件状态的优缺点和使用场景。

1．视图状态

视图状态是ASP.NET页框架用于保存服务器与客户端往返过程之间的页面和控件值的方法。当呈现页的HTML形式时，需要在回发过程中保留的页的当前状态和值将被序列化为Base64编码的字符串，并输出到视图状态的隐藏字段中，即页面中HTML源代码中的__VIEWSTATE隐藏字段，可以存储：字符串、整数、布尔值、Array对象、ArrayList对象、哈希表等数据类型。

视图状态有如下优点：

（1）节省服务端资源。由于视图状态是存放到隐藏字段（在HTML代码结构中）传送到客户端的，因此不占用服务端资源。

（2）使用方便。默认已经开启视图状态。有些场合，如果控件没有注册服务端事件或者控件没有动态属情况可以将视图状态关闭，节省网络流量，提高页面呈现速度。

（3）视图状态通过散列码校检机制和使用3DES等加密机制来保证数据安全。

（4）自定义存储位置。在Load和Save方法中可以自定义其存储位置。

视图状态有如下缺点：

（1）由于其存储到页面HTML代码结构中，因此传输数据量大时，会严重影响性能。可以用视图状态分块机制，将数据分块存储，设置MaxPageStateFieldLength属性。

（2）如果视图状态被禁用，则无法保存页面状态。

（3）虽然已经通过加密，但由于其是呈现到客户端隐藏字段区域，因此容易被篡改。

2．控件状态

有时，为了让控件正常工作，需要按顺序存储控件状态数据。例如，如果编写了一个自定义控件，其中使用了不同的选项卡来显示不同的信息，如TabTrip，FormView等控件，为了让自定义控件按预期的方式工作，该控件需要知道在往返行程之间选择了哪个选项卡。可以使用ViewState属性来达到这一目的，然而，开发人员可以在页级别关闭视图状态，从而使控件无法正常工作。

为了解决此问题，ASP.NET 2.0增加了一项新的存储功能：控件状态。ControlState属性允许您保持特定于某个控件的属性信息，且不能像ViewState属性那样被关闭。简单地说，当禁用视图状态时，ControlState能够完成ViewState不能够完成的任务。

控件状态有如下优点：

（1）节省服务端资源。跟视图状态一样，控件状态存储在隐藏字段中，也不占用服务器资源。

（2）比视图状态更可靠。控件状态功能推出的一个重大原因就是，当视图状态被禁用时，它依然可以有效。

（3）自定义存储位置。在Load和Save方法中可以自定义其存储位置。

控件状态有如下缺点：

（1）由于其存储到页面HTML代码结构中，因此传输数据量大时，会严重影响性能。

（2）视图状态可以用System.Web.UI.StateBag类型的ViewState来存储，也可以自定义编程。控件状态只能自定义编程。

6.11 本章总结

客户端提交的两次连续的页面请求，其数据可能存在差异。ASP.NET是采用视图机制解决两次页面请求之间的关联性问题的。本章在讲解页面状态存储原理后，对视图状态机制作了详细的介绍，包括基本ViewState工 作原理、自定义视图状态的应用、控件状态机制及应用方案、视图状态和控件的关系、对页面状态进行加密以及页面状态的清理机制、动态增加控件使用视图时的注 意事项、对页面状态的保存和装载应用高效率的类型转换器，并且讨论了页面状态的性能优化策略，对视图状态和控件状态的优缺点做了比较，分析了它们的及适用 场景。在开发过程中，如果能够理解页面状态工作原理，则开发起来就会非常容易。

 

获得本书更多内容,请看:

    http://www.cnblogs.com/ChengKing/archive/2009/01/02/1366915.html

 

 

 

 

 

如果您需要发问,  非常欢迎您在下面留言,  Thanks/King.

 

 

.

.

.

 

你可能感兴趣的:(asp.net)

  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • 通过C# 裁剪PDF页面 Eiceblue C#.NETPDFc#pdf开发语言visualstudio
    在处理PDF文档时，有时需要精确地裁剪页面以适应特定需求，比如去除广告、背景信息或者仅仅是为了简化文档内容。本文将指导如何使用免费.NET控件通过C#实现裁剪PDF页面。免费库FreeSpire.PDFfor.NET支持在.NET(C#,VB.NET,ASP.NET,.NETCore)程序中实现创建、操作、转换和打印PDF文档等操作。可以从以下链接下载产品包后手动添加引用，或者直接通过NuGet安
  • asp.net core的入门教学 21软件外包1班-庞兴南 asp.net后端
    什么是ASP.NETCoreasp.netcore是一个基于HTML和ASP的动态Web开发框架，主要用于web应用程序的开发。它是一个轻量级框架，使用HTML、ASP、CSS、JavaScript等技术。它易于使用和部署，可以快速构建web应用程序。asp.netcore提供了丰富的功能，包括模板引擎、文件解析、数据处理和用户管理等。本文将介绍asp.netcore的主要功能和特点，并提供使用方
  • 6.1 ASP.NET Core Web 入门 步、步、为营 .NetCoreasp.netmvc
    6.1ASP.NETCoreWeb入门ASP.NETCore中，严格来讲只有一个Asp.netCoreMVC一个框架，Asp.netCoreMVC既支持基于视图的MVC开发，也支持WebAPI和RazorPages开发。ASP.NETCoreMVC项目在VS2022中，一定选择ASP.NETCoreWeb应用（模型-视图-控制器）项目模板项目中wwwroot文件夹包含图片、JS、CSS等静态文件，
  • asp.net core 8.0 使用 Autofac ioc 容器 具体实例 彭小彭~ .netcoreasp.net
    要在ASP.NETCore8.0项目中具体实现使用Autofac作为IOC容器，我们将遵循一个明确的示例，从创建新项目到配置Autofac，并演示如何注册和解析服务。步骤1:创建ASP.NETCore8.0项目首先，使用VisualStudio或命令行工具创建一个新的ASP.NETCoreWeb应用程序。如果使用命令行，可以运行以下命令：dotnetnewwebapp-nAutofacDemocd
  • 探索ASP.NET Core 8.0的奇妙世界 郎凌队Lois
    探索ASP.NETCore8.0的奇妙世界practical-aspnetcore该项目提供了关于ASP.NETCore实际应用开发的一系列教程和示例，涵盖了从基础知识到高级主题，是一个实用的学习资源库。适合于想要掌握ASP.NETCore技术栈的开发者进行学习和参考。项目地址:https://gitcode.com/gh_mirrors/pr/practical-aspnetcore随着微软的A
  • 探索未来Web开发的精简之道：ASP.NET Core 8.0 Minimal API 示例项目 尚舰舸Elsie
    探索未来Web开发的精简之道：ASP.NETCore8.0MinimalAPI示例项目随着微服务和云原生架构的兴起，轻量级API成为了开发社区的新宠。ASP.NETCore8.0MinimalAPIExample正是这样一个项目，它集成了最新技术栈，简化了API开发过程，让开发者能够以最少的代码实现强大的功能。本文将带你深入了解这一开源杰作，揭示其技术魅力，并探索其应用场景。项目介绍ASP.NET
  • ASP.NET Core 入门教学二十八 linux打包部署 充值内卷 asp.netlinux后端
    在Linux上打包和部署ASP.NETCore应用程序涉及几个步骤。以下是一个详细的指南，帮助你在Linux系统上完成这一过程。1.准备工作确保你的Linux系统已经安装了以下软件：.NETSDK（用于构建应用程序）.NETRuntime（用于运行应用程序）Apache或Nginx（作为反向代理服务器）你可以使用以下命令安装.NETSDK和Runtime：sudoaptupdatesudoapti
  • 前后端分离，Asp.net core webapi 如何配置跨域 代码掌控者 C#asp.netcore.netcore经验分享c#
    前言可以说，前后端分离已经成为当今信息系统项目开发的主流软件架构模式，微服务的出现，让前后端分离发展更是迅速，大量优秀的前端框架如vue.js、react的出现，也让前后端分离趋势加快。所谓的前后端分离软件架构模式，就是指将前端和后端的开发完全分离，后端负责提供API接口和数据处理，而前端通过各种现代的JavaScript技术如AJAX或者Fetch等，来调用后端提供的API接口获取数据，从而构建
  • 探索现代Web API开发的典范：Asp.Net Core Web API N-Tier项目 苏舰孝Noel
    探索现代WebAPI开发的典范：Asp.NetCoreWebAPIN-Tier项目aspnetcore.ntier.NETCoreN-TierarchitectureWebApisampleproject.项目地址:https://gitcode.com/gh_mirrors/as/aspnetcore.ntier在寻求高效、可扩展且遵循最佳实践的API开发框架时，Asp.NetCoreWebAP
  • 推荐：ASP.NET Core Web API 模板 —— 强大的启动项目！ 戴洵珠Gerald
    推荐：ASP.NETCoreWebAPI模板——强大的启动项目！aspnetcore-webapi-templateThisprojectisanWebAPIOpen-SourceBoilerplateTemplatethatincludesASP.NETCore5,WebAPIstandards,cleann-tierarchitecture,GraphQLservice,Redis,Mssql
  • ASP.NET Core N-Tier架构Web API示例项目教程 毛宝锋
    ASP.NETCoreN-Tier架构WebAPI示例项目教程aspnetcore.ntier.NETCoreN-TierarchitectureWebApisampleproject.项目地址:https://gitcode.com/gh_mirrors/as/aspnetcore.ntier本教程旨在指导您了解并使用从https://github.com/aghayeffemin/aspnet
  • Whisper 模型在实时语音转录中有哪些具体的应用场景？ 借雨醉东风 热点追踪whisper人工智能
    关注我，持续分享逻辑思维&管理思维&面试题；可提供大厂面试辅导、及定制化求职/在职/管理/架构辅导；推荐专栏《10天学会使用asp.net编程AI大模型》，目前已完成所有内容。一顿烧烤不到的费用，让人能紧跟时代的浪潮。从普通网站，到公众号、小程序，再到AI大模型网站。干货满满。学成后可接项目赚外快，绝对划算。不仅学会如何编程，还将学会如何将AI技术应用到实际问题中，为您的职业生涯增添一笔宝贵的财富
  • asp.net core 自定义过滤器 注入的几种方式和实现 彭小彭~ .netcore.netcore
    在ASP.NETCore中，过滤器（Filters）是一种在MVC应用程序中运行代码的方法，可以在操作（Actions）执行之前或之后运行。过滤器可以应用于控制器（Controllers）或特定的操作方法。过滤器可以用来实现跨切面的逻辑，比如异常处理、授权、缓存、日志等。有几种类型的过滤器：授权过滤器（Authorizationfilters）资源过滤器（Resourcefilters）操作过滤器
  • 【.NET全栈】ASP.NET开发Web应用——ADO.NET数据访问技术 JosieBook #.NET全栈.netasp.net前端
    文章目录前言一、ADO.NET基础1、ADO.NET架构2、ADO.NET数据提供者二、连接数据库1、SqlConnection数据库连接类2、使用SqlConnectionStringBuilder连接字符串3、关闭和释放连接4、在web.config配置文件中保存连接字符串5、连接池技术三、与数据库交互1、使用SqlCommand操作数据库2、为SqlCommand传递参数3、使用SqlCom
  • ASP.NET中Response.Redirect的用法（详细） 微微的猪食小窝 asp.net服务器java
    一、Response.Redirect是重定向到新的url。例如：if(!IsPostBack){if(Session["UserId"]==null||Session["UserId"].ToString()==""){Response.Redirect(Oper.GetSysUrl()+"/Default.aspx");//转到主页}******//其他实现代码}二、若想传递参数，只要在url
  • 【.NET全栈】ASP.NET开发Web应用——LINQ技术 JosieBook #.NET全栈.netasp.netlinq
    文章目录一、LINQ基础1、LINQ简介2、延迟执行3、LINQ表达式简介1、基本查询语法2、投影新对象3、过滤和排序4、分组和聚合5、联合查询二、LINQtoDataSet操作内存表1、LINQtoDataSet简介2、类型化DataSet三、LINQtoSQL操作数据库1、数据实体类2、DataContext类介绍3、在ASP.NET中应用LINQtoSQL4、自动生成数据实体类5、生成存储过
  • ASP.NET Core 开源项目详解与入门指南 沈菱嫱Marie
    ASP.NETCore开源项目详解与入门指南aspnetcoredotnet/aspnetcore:是一个ASP.NETCore应用程序开发框架的官方GitHub仓库，它包含了ASP.NETCore的核心源代码和技术文档。适合用于ASP.NETCore应用程序开发，特别是对于那些需要深入了解ASP.NETCore框架实现和技术的场景。特点是ASP.NETCore官方仓库、核心源代码、技术文档。项目
  • ASP.NET Core 入门教学二十一 分布式追踪技术 充值内卷 asp.net分布式
    分布式追踪技术在微服务架构中非常重要，它可以帮助开发者理解和监控应用程序在分布式环境中的行为。ASP.NETCore提供了对分布式追踪的原生支持，主要通过OpenTelemetry和ApplicationInsights实现。1.OpenTelemetryOpenTelemetry是一个开源的观测框架，用于生成、收集和导出遥测数据（如追踪、指标和日志）。ASP.NETCore可以通过集成OpenT
  • Asp.Net 汉字转(拼音) 素年槿夏 C#
    1.ChinesConvertSpelling：汉字转拼音类(全拼)1usingSystem;2usingSystem.Data;3usingSystem.Configuration;4usingSystem.Text;56///7///SummarydescriptionforConvertHzToPz_Gb23128///9namespaceCommon10{11publicclassChin
  • ASP.NET Core消息队列RabbitMQ基础入门实战演练 阿笨NET 跟着阿笨一起玩NETASP.NETCoreASP.NETCore消息队列ASP.NETCoreRabbitMQ.NETCore视频教程ASP.NETCore视频课程
    一、课程介绍人生苦短，我用.NETCore！消息队列RabbitMQ大家相比都不陌生，本次分享课程阿笨将给大家分享一下在一般项目中99%都会用到的消息队列MQ的一个实战业务运用场景。本次分享课程不是零基础教学，课程内容的侧重点是讲解的RabbitMQ的最实用、最简单的实战运用场景：Publish/Subscrib(发布/订阅)模式，发送端发送消息，单个接收端接收处理消息。学完本次"是猴子都看的懂的
  • ASP.NET Core 入门教学十五 异步编程 充值内卷 asp.net后端
    在ASP.NETCore中，异步编程是一种非常重要的技术，它可以提高应用程序的性能和响应能力。本教程将介绍如何在ASP.NETCore中使用异步编程。1.异步编程基础异步编程允许程序在等待某些操作（如I/O操作）完成时继续执行其他任务，而不是阻塞整个线程。这可以显著提高应用程序的性能，特别是在处理大量并发请求时。2.使用async和await在C#中，async和await关键字用于实现异步编程。
  • ASP.NET Core 入门教学十六 防止常见的Web攻击 充值内卷 asp.net前端后端
    在ASP.NETCore中，防止常见的Web攻击是非常重要的，以确保应用程序的安全性。以下是一些常见的Web攻击类型及其防范措施：1.跨站脚本攻击（XSS）跨站脚本攻击（XSS）是一种通过在网页中注入恶意脚本来攻击用户的浏览器的技术。为了防止XSS攻击，可以采取以下措施：输入验证：对用户输入进行严格的验证和清理。输出编码：在将用户输入的数据插入到HTML页面中时，进行适当的编码。ASP.NETCo
  • ASP.NET Core 入门教学八 集成RocketMQ消息队列 充值内卷 asp.netrocketmq后端
    在ASP.NETCore中集成RocketMQ消息队列，你需要遵循以下步骤：1.安装RocketMQ客户端库首先，你需要在你的ASP.NETCore项目中安装RocketMQ的.NET客户端库。你可以使用NuGet包管理器来完成这个任务。在VisualStudio中，右键点击你的项目，选择“管理NuGet程序包”，然后搜索并安装Apache.RocketMQ.Client包。2.配置RocketM
  • 分享一个基于微信小程序的智慧校园服务平台（源码、调试、LW、开题、PPT） 计算机源码社 微信小程序微信小程序毕业设计项目计算机毕设源码计算机毕设毕设选题课程设计源码毕业设计答辩
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|基
  • ASP.NET 整页缓存技术 lploveme asp.net浏览器browser引擎vb.nethtml
    在网上找了好久的整页缓存技术今天终于可以解决我的问题我要求是这样的有AB两个客服机同时访问一个页面信息得到的应该都是缓存以后的信息而不是A得到的是缓存而B不是缓存信息今天找到了好的方式特意贴出来让我常常看整页输出缓存这是一篇很不错的文章来源是http://softbbs.pconline.com.cn/9740011.html要提升ASP.NET应用程序的性能，最简单、最有效的方式就是使用内建的缓
  • ASP.NET Core 微服务初探[1]：服务发现之Consul weixin_34015336 运维ui数据结构与算法
    在传统单体架构中，由于应用动态性不强，不会频繁的更新和发布，也不会进行自动伸缩，我们通常将所有的服务地址都直接写在项目的配置文件中，发生变化时，手动改一下配置文件，也不会觉得有什么问题。但是在微服务模式下，服务会更细的拆分解耦，微服务会被频繁的更新和发布，根据负载情况进行动态伸缩，以及受资源调度影响而从一台服务器迁移到另一台服务器等等。总而言之，在微服务架构中，微服务实例的网络位置变化是一种常态，
  • 我眼中的ASP.NET Core之微服务 dotNET跨平台
    前言前几天在博客园看到有园友在分享关于微软的一个微服务架构的示例程序，想必大家都已经知道了，那就是eShopOnContainers。我们先不看项目的后缀名称OnXXX，因为除了OnContainers还有OnAzure，OnWeb，OnKubernetes以及OnServiceFabric。我们就还是来先说说eShop这个项目吧，eShop是ASP.NETCore发布之后微软新开源出来的一个示例
  • asp.net core 微服务架构搭建 战族狼魂 微服务架构asp.net微服务
    在ASP.NETCore中实现微服务架构涉及多个步骤，包括服务划分、API网关、服务发现、通信方式、容器化等。以下是一个基本的微服务架构搭建指南。目录1.服务划分2.创建独立的ASP.NETCore服务3.设置API网关4.服务发现5.通信方式6.容器化7.总结1.服务划分首先，需要将你的应用程序划分成多个独立的服务，每个服务专注于单一职责。每个服务都应该是独立的，能够独立开发、部署和扩展。2.创
  • 2024年计算机毕业设计2000个热门选题推荐之NodeJS篇——全行业Java项目定制asp.net代做Python安卓NodeJS等 itszkt计算机项目源代码 项目选题课程设计java开发语言
    ✌精彩专栏推荐订阅以防找不到✌项目界面文字不会改？项目代码不懂？怕老师问？项目没有软件？不会运行？✌选题—项目修改教程—答疑—远程，为客户提供帮助和支持，努力解决问题和推动项目进展✌✌✌选题推荐——以防找不到我们，点击上方订阅专栏✌✌2024年计算机JavaPython安卓APP微信小程序asp.net项目PHP2000+热门选题推荐计算机毕业设计如何选题？计算机毕业设计开题报告如何书写论文的书写
  • 戴尔笔记本win8系统改装win7系统 sophia天雪 win7戴尔改装系统win8
    戴尔win8 系统改装win7 系统详述 第一步：使用U盘制作虚拟光驱：         1）下载安装UltraISO：注册码可以在网上搜索。         2）启动UltraISO，点击“文件”—》“打开”按钮，打开已经准备好的ISO镜像文
  • BeanUtils.copyProperties使用笔记 bylijinnan java
    BeanUtils.copyProperties VS PropertyUtils.copyProperties 两者最大的区别是： BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。 既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProp
  • MyEclipse中文乱码问题 0624chenhong MyEclipse
    一、设置新建常见文件的默认编码格式，也就是文件保存的格式。 在不对MyEclipse进行设置的时候，默认保存文件的编码，一般跟简体中文操作系统（如windows2000，windowsXP）的编码一致，即GBK。 在简体中文系统下，ANSI 编码代表 GBK编码;在日文操作系统下，ANSI 编码代表 JIS 编码。 Window-->Preferences-->General -
  • 发送邮件 不懂事的小屁孩 send email
    import org.apache.commons.mail.EmailAttachment; import org.apache.commons.mail.EmailException; import org.apache.commons.mail.HtmlEmail; import org.apache.commons.mail.MultiPartEmail;
  • 动画合集 换个号韩国红果果 htmlcss
    动画 指一种样式变为另一种样式 keyframes应当始终定义0 100 过程 1 transition  制作鼠标滑过图片时的放大效果 css .wrap{ width: 340px;height: 340px; position: absolute; top: 30%; left: 20%; overflow: hidden; bor
  • 网络最常见的攻击方式竟然是SQL注入 蓝儿唯美 sql注入
    NTT研究表明，尽管SQL注入（SQLi）型攻击记录详尽且为人熟知，但目前网络应用程序仍然是SQLi攻击的重灾区。 信息安全和风险管理公司NTTCom Security发布的《2015全球智能威胁风险报告》表明，目前黑客攻击网络应用程序方式中最流行的，要数SQLi攻击。报告对去年发生的60亿攻击 行为进行分析，指出SQLi攻击是最常见的网络应用程序攻击方式。全球网络应用程序攻击中，SQLi攻击占
  • java笔记2 a-john java
    类的封装： 1，java中，对象就是一个封装体。封装是把对象的属性和服务结合成一个独立的的单位。并尽可能隐藏对象的内部细节（尤其是私有数据） 2，目的：使对象以外的部分不能随意存取对象的内部数据（如属性），从而使软件错误能够局部化，减少差错和排错的难度。 3，简单来说，“隐藏属性、方法或实现细节的过程”称为——封装。 4，封装的特性：       4.1设置
  • [Andengine]Error：can't creat bitmap form path “gfx/xxx.xxx” aijuans 学习Android遇到的错误
            最开始遇到这个错误是很早以前了，以前也没注意，只当是一个不理解的bug，因为所有的texture，textureregion都没有问题，但是就是提示错误。 昨天和美工要图片，本来是要背景透明的png格式，可是她却给了我一个jpg的。说明了之后她说没法改，因为没有png这个保存选项。 我就看了一下，和她要了psd的文件，还好我有一点
  • 自己写的一个繁体到简体的转换程序 asialee java转换繁体filter简体
              今天调研一个任务，基于java的filter实现繁体到简体的转换，于是写了一个demo，给各位博友奉上，欢迎批评指正。          实现的思路是重载request的调取参数的几个方法，然后做下转换。          
  • android意图和意图监听器技术 百合不是茶 android显示意图隐式意图意图监听器
    Intent是在activity之间传递数据;Intent的传递分为显示传递和隐式传递   显式意图：调用Intent.setComponent() 或 Intent.setClassName() 或 Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。   隐式意图;不指明调用的名称,根据设
  • spring3中新增的@value注解 bijian1013 javaspring@Value
            在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下： 1.首先在applicationContext.xml中加入：  <beans xmlns="http://www.springframework.
  • Jboss启用CXF日志 sunjing logjbossCXF
    1. 在standalone.xml配置文件中添加system-properties：     <system-properties>        <property name="org.apache.cxf.logging.enabled" value=&
  • 【Hadoop三】Centos7_x86_64部署Hadoop集群之编译Hadoop源代码 bit1129 centos
      编译必需的软件 Firebugs3.0.0 Maven3.2.3 Ant JDK1.7.0_67 protobuf-2.5.0 Hadoop 2.5.2源码包       Firebugs3.0.0   http://sourceforge.jp/projects/sfnet_findbug
  • struts2验证框架的使用和扩展 白糖_ 框架xmlbeanstruts正则表达式
    struts2能够对前台提交的表单数据进行输入有效性校验，通常有两种方式： 1、在Action类中通过validatexx方法验证，这种方式很简单，在此不再赘述； 2、通过编写xx-validation.xml文件执行表单验证，当用户提交表单请求后，struts会优先执行xml文件，如果校验不通过是不会让请求访问指定action的。 本文介绍一下struts2通过xml文件进行校验的方法并说
  • 记录-感悟 braveCS 感悟
    再翻翻以前写的感悟，有时会发现自己很幼稚，也会让自己找回初心。   2015-1-11 1. 能在工作之余学习感兴趣的东西已经很幸福了； 2. 要改变自己，不能这样一直在原来区域，要突破安全区舒适区，才能提高自己，往好的方面发展； 3. 多反省多思考；要会用工具，而不是变成工具的奴隶； 4. 一天内集中一个定长时间段看最新资讯和偏流式博
  • 编程之美-数组中最长递增子序列 bylijinnan 编程之美
    import java.util.Arrays; import java.util.Random; public class LongestAccendingSubSequence { /** * 编程之美 数组中最长递增子序列 * 书上的解法容易理解 * 另一方法书上没有提到的是，可以将数组排序（由小到大）得到新的数组， * 然后求排序后的数组与原数
  • 读书笔记5 chengxuyuancsdn 重复提交struts2的token验证
    1、重复提交 2、struts2的token验证 3、用response返回xml时的注意 1、重复提交 (1)应用场景 (1-1)点击提交按钮两次。 (1-2)使用浏览器后退按钮重复之前的操作，导致重复提交表单。 (1-3)刷新页面 (1-4)使用浏览器历史记录重复提交表单。 (1-5)浏览器重复的 HTTP 请求。 (2)解决方法 (2-1)禁掉提交按钮 (2-2)
  • [时空与探索]全球联合进行第二次费城实验的可能性 comsci
         二次世界大战前后,由爱因斯坦参加的一次在海军舰艇上进行的物理学实验 -费城实验   至今给我们大家留下很多迷团.....      关于费城实验的详细过程,大家可以在网络上搜索一下,我这里就不详细描述了      在这里,我的意思是,现在
  • easy connect 之 ORA-12154: TNS: 无法解析指定的连接标识符 daizj oracleORA-12154
    用easy connect连接出现“tns无法解析指定的连接标示符”的错误，如下： C:\Users\Administrator>sqlplus username/[email protected]:1521/orcl SQL*Plus: Release 10.2.0.1.0 – Production on 星期一 5月 21 18:16:20 2012 Copyright (c) 198
  • 简单排序:归并排序 dieslrae 归并排序
    public void mergeSort(int[] array){ int temp = array.length/2; if(temp == 0){ return; } int[] a = new int[temp]; int
  • C语言中字符串的\0和空格 dcj3sjt126com c
       \0 为字符串结束符，比如说：                       abcd (空格)cdefg； 存入数组时，空格作为一个字符占有一个字节的空间，我们
  • 解决Composer国内速度慢的办法 dcj3sjt126com Composer
    用法： 有两种方式启用本镜像服务： 1 将以下配置信息添加到 Composer 的配置文件 config.json 中（系统全局配置）。见“例1” 2 将以下配置信息添加到你的项目的 composer.json 文件中（针对单个项目配置）。见“例2” 为了避免安装包的时候都要执行两次查询，切记要添加禁用 packagist 的设置，如下 1 2 3 4 5
  • 高效可伸缩的结果缓存 shuizhaosi888 高效可伸缩的结果缓存
    /** * 要执行的算法，返回结果v */ public interface Computable<A, V> { public V comput(final A arg); }   /** * 用于缓存数据 */ public class Memoizer<A, V> implements Computable<A,
  • 三点定位的算法 haoningabc c算法
    三点定位， 已知a,b,c三个顶点的x,y坐标 和三个点都z坐标的距离，la，lb,lc 求z点的坐标 原理就是围绕a,b,c 三个点画圆，三个圆焦点的部分就是所求 但是，由于三个点的距离可能不准，不一定会有结果， 所以是三个圆环的焦点，环的宽度开始为0，没有取到则加1 运行 gcc -lm test.c test.c代码如下 #include "stdi
  • epoll使用详解 jimmee clinux服务端编程epoll
    epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
  • Hibernate对Enum的映射的基本使用方法 linzx0212 enumHibernate
      枚举   /** * 性别枚举 */ public enum Gender { MALE(0), FEMALE(1), OTHER(2); private Gender(int i) { this.i = i; } private int i; public int getI
  • 第10章 高级事件（下） onestopweb 事件
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • 孙子兵法 roadrunners 孙子兵法
    始计第一 孙子曰： 兵者，国之大事，死生之地，存亡之道，不可不察也。 故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将，五 曰法。道者，令民于上同意，可与之死，可与之生，而不危也；天者，阴阳、寒暑 、时制也；地者，远近、险易、广狭、死生也；将者，智、信、仁、勇、严也；法 者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知之者不胜。故校 之以计，而索其情，曰
  • MySQL双向复制 tomcat_oracle mysql
    本文包括: 主机配置 从机配置 建立主-从复制 建立双向复制   背景 按照以下简单的步骤: 参考一下： 在机器A配置主机(192.168.1.30) 在机器B配置从机(192.168.1.29) 我们可以使用下面的步骤来实现这一点   步骤1：机器A设置主机 在主机中打开配置文件 ,
  • zoj 3822 Domination(dp) 阿尔萨斯 Mina
    题目链接：zoj 3822 Domination 题目大意：给定一个N∗M的棋盘，每次任选一个位置放置一枚棋子，直到每行每列上都至少有一枚棋子，问放置棋子个数的期望。 解题思路：大白书上概率那一张有一道类似的题目，但是因为时间比较久了，还是稍微想了一下。dp[i][j][k]表示i行j列上均有至少一枚棋子，并且消耗k步的概率（k≤i∗j）,因为放置在i+1~n上等价与放在i+1行上，同理
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他