第一篇：初识ASP.NET控件开发_第三节：“生死有序”的控件生命周期

一、Page本质是一个Control

我们首先要澄清的第一个概念是页面类Page本质是一个控件类，它派生于TemplateControl类，而TemplateControl派生自Control类。既然饭我没有乱吃，自然话也不会乱讲。借田有良老师的翠花给大家上证据如下：

二、Control的“生死之序”

 

• 1.实例化（Instantiate）
  我们写控件一般不要接触此活动。
• 2.初始化（Initialize）
  【初始化自己，创建它的子控件（但该过程控件的状态没有加载）。触发该控件的OnInit()事件。】我们写控件一般不要接触此活动。
  【跟踪视图状态（Tracking View State）*  】这个比较重要，涉及到视图状态，一般情况下不必重载此方法。
• 3.加载视图状态（Load view state）*
  只会在回传过程中调用此方法，用法同上。
• 4.加载回发数据（Load postback data）*
  如果你的控件生成之后要和客户端交互，那么这个方法就很重要，只会在回传过程中调用此方法。
• 5.加载（Load）
  这个活动一般只是Page的OnLoad才会要去管它，我们写控件一般不要接触此方法。
• 6.更改通知（Raise changed events）*
  控件生成后，数据被客户端更改过，和加载回传数据是一路的。
• 7.处理回发事件（Raise postback event）*
  一般用于实现IPostBackEventHandler接口的控件的把客户端事件转化成服务器端事件。只用于回传过程。
• 8.预呈现（PerRender）**
  生成前期工作，这个是很重要的一个过程，通过重载OnPreRender方法实现自定义。
• 9.保存视图状态（Save view state）*
  如果所以信息都是用ViewState[xxx]这种方式来保存，不必重载，只有自定义视图状态管理时才重载此方法，当然，这里做了手脚，LoadViewState也就一定要和这里的Save方法配套。
• 10.呈现（Render）***
  这个是主角，控件成生什么东东基本就由这里管了。
• 11.卸载（Unload）
• 12.释放（Dispose）

三、控件树的“合成模式（Composite）”

从设计模式的角度讲，页面模型是一个“合成模式（Composite）”，它本身是一棵由多层控件组成的结构树，顶层是Page，以下有叶有树枝，叶是不再包涵子控件的控件，枝是又包涵子控件的控件，每一层控件的"初始化\加载视图状态\加载\预呈现\保存视图状态\卸载"等方法都会调用子控件的对应方法，父控件调用子控件的方法，子又调用孙的，如此递归。

1、初始化：

internal virtual void InitRecursive(Control namingContainer)
{
    this.ResolveAdapter();
    if (this._controls != null)
    {
        if (this.flags[128])
        {
            namingContainer = this;
        }
        string collectionReadOnly = this._controls.SetCollectionReadOnly("Parent_collections_readonly");
        int count = this._controls.Count;
        for (int i = 0; i < count; i++)
        {
            Control control = this._controls[i];
            control.UpdateNamingContainer(namingContainer);
            if (control._id == null && namingContainer != null && !control.flags[64])
            {
                control.GenerateAutomaticID();
            }
            control._page = this.Page;
            control.InitRecursive(namingContainer);
        }
        this._controls.SetCollectionReadOnly(collectionReadOnly);
    }
    if (this._controlState < ControlState.Initialized)
    {
        this._controlState = ControlState.ChildrenInitialized;
        if (this.Page != null && !this.DesignMode && this.Page.ContainsTheme && this.EnableTheming)
        {
            this.ApplySkin(this.Page);
        }
        if (this.AdapterInternal != null)
        {
            this.AdapterInternal.OnInit(EventArgs.Empty);
        }
        else
        {
            this.OnInit(EventArgs.Empty);
        }
        this._controlState = ControlState.Initialized;
    }
    this.TrackViewState();
}

2、加载视图状态:

internal void LoadViewStateRecursive(object savedState)
{
    if (savedState == null || this.flags[4])
    {
        return;
    }
    if (this.Page != null && this.Page.IsPostBack)
    {
        object obj = null;
        Pair pair = savedState as Pair;
        object first;
        ArrayList arrayList;
        if (pair != null)
        {
            first = pair.First;
            arrayList = (ArrayList)pair.Second;
        }
        else
        {
            Triplet triplet = (Triplet)savedState;
            first = triplet.First;
            obj = triplet.Second;
            arrayList = (ArrayList)triplet.Third;
        }
        try
        {
            if (obj != null && this.AdapterInternal != null)
            {
                this.AdapterInternal.LoadAdapterViewState(obj);
            }
            if (first != null)
            {
                this.LoadViewState(first);
            }
            if (arrayList != null)
            {
                if (this.LoadViewStateByID)
                {
                    this.LoadChildViewStateByID(arrayList);
                }
                else
                {
                    this.LoadChildViewStateByIndex(arrayList);
                }
            }
        }
        catch (InvalidCastException)
        {
            throw new HttpException(SR.GetString("Controls_Cant_Change_Between_Posts"));
        }
        catch (IndexOutOfRangeException)
        {
            throw new HttpException(SR.GetString("Controls_Cant_Change_Between_Posts"));
        }
    }
    this._controlState = ControlState.ViewStateLoaded;
}
internal void LoadChildViewStateByID(ArrayList childState)
{
    int count = childState.Count;
    for (int i = 0; i < count; i += 2)
    {
        string text = (string)childState[i];
        object obj = childState[i + 1];
        Control control = this.FindControl(text);
        if (control != null)
        {
            control.LoadViewStateRecursive(obj);
        }
        else
        {
            this.EnsureOccasionalFields();
            if (this._occasionalFields.ControlsViewState == null)
            {
                this._occasionalFields.ControlsViewState = new Hashtable();
            }
            this._occasionalFields.ControlsViewState[text] = obj;
        }
    }
}

3、加载:

internal virtual void LoadRecursive()
{
    if (this._controlState < ControlState.Loaded)
    {
        if (this.AdapterInternal != null)
        {
            this.AdapterInternal.OnLoad(EventArgs.Empty);
        }
        else
        {
            this.OnLoad(EventArgs.Empty);
        }
    }
    if (this._controls != null)
    {
        string collectionReadOnly = this._controls.SetCollectionReadOnly("Parent_collections_readonly");
        int count = this._controls.Count;
        for (int i = 0; i < count; i++)
        {
            this._controls[i].LoadRecursive();
        }
        this._controls.SetCollectionReadOnly(collectionReadOnly);
    }
    if (this._controlState < ControlState.Loaded)
    {
        this._controlState = ControlState.Loaded;
    }
}

4、预呈现:

internal virtual void PreRenderRecursiveInternal()
{
    if (!this.Visible)
    {
        this.flags.Set(16);
    }
    else
    {
        this.flags.Clear(16);
        this.EnsureChildControls();
        if (this.AdapterInternal != null)
        {
            this.AdapterInternal.OnPreRender(EventArgs.Empty);
        }
        else
        {
            this.OnPreRender(EventArgs.Empty);
        }
        if (this._controls != null)
        {
            string collectionReadOnly = this._controls.SetCollectionReadOnly("Parent_collections_readonly");
            int count = this._controls.Count;
            for (int i = 0; i < count; i++)
            {
                this._controls[i].PreRenderRecursiveInternal();
            }
            this._controls.SetCollectionReadOnly(collectionReadOnly);
        }
    }
    this._controlState = ControlState.PreRendered;
}

5、保存视图状态:

internal object SaveViewStateRecursive(ViewStateMode inheritedMode)
{
    if (this.flags[4])
    {
        return null;
    }
    bool flag;
    if (this.flags[8388608])
    {
        if (this.flags[16777216])
        {
            flag = true;
            inheritedMode = ViewStateMode.Enabled;
        }
        else
        {
            flag = false;
            inheritedMode = ViewStateMode.Disabled;
        }
    }
    else
    {
        flag = (inheritedMode == ViewStateMode.Enabled);
    }
    object obj = null;
    object obj2 = null;
    if (flag)
    {
        if (this.AdapterInternal != null)
        {
            obj = this.AdapterInternal.SaveAdapterViewState();
        }
        obj2 = this.SaveViewState();
    }
    ArrayList arrayList = null;
    if (this.HasControls())
    {
        ControlCollection controls = this._controls;
        int count = controls.Count;
        bool loadViewStateByID = this.LoadViewStateByID;
        for (int i = 0; i < count; i++)
        {
            Control control = controls[i];
            object obj3 = control.SaveViewStateRecursive(inheritedMode);
            if (obj3 != null)
            {
                if (arrayList == null)
                {
                    arrayList = new ArrayList(count);
                }
                if (loadViewStateByID)
                {
                    control.EnsureID();
                    arrayList.Add(control.ID);
                }
                else
                {
                    arrayList.Add(i);
                }
                arrayList.Add(obj3);
            }
        }
    }
    if (this.AdapterInternal != null)
    {
        if (obj2 != null || obj != null || arrayList != null)
        {
            return new Triplet(obj2, obj, arrayList);
        }
    }
    else
    {
        if (obj2 != null || arrayList != null)
        {
            return new Pair(obj2, arrayList);
        }
    }
    return null;
}

6、卸载:

internal virtual void UnloadRecursive(bool dispose)
{
    Page page = this.Page;
    if (page != null && page.RequiresControlState(this))
    {
        page.UnregisterRequiresControlState(this);
        this.RareFieldsEnsured.RequiredControlState = true;
    }
    if (this.flags[2097152])
    {
        this._id = null;
        this.flags.Clear(2097152);
    }
    if (this._controls != null)
    {
        string collectionReadOnly = this._controls.SetCollectionReadOnly("Parent_collections_readonly");
        int count = this._controls.Count;
        for (int i = 0; i < count; i++)
        {
            this._controls[i].UnloadRecursive(dispose);
        }
        this._controls.SetCollectionReadOnly(collectionReadOnly);
    }
    if (this.AdapterInternal != null)
    {
        this.AdapterInternal.OnUnload(EventArgs.Empty);
    }
    else
    {
        this.OnUnload(EventArgs.Empty);
    }
    if (dispose)
    {
        this.Dispose();
    }
    if (this.IsReloadable)
    {
        this._controlState = ControlState.Constructed;
    }
}

四、从InitRecursive、LoadRecursive、PreRenderRecursiveInternal、UnloadRecursive函数看事件的触发顺序