如果控件始终按照声明的顺序绑定到数据源控件，则

Question

A) 下面的问题基于这样的假设：控件始终按照声明的顺序绑定到数据源控件？ 因此，在我们的示例中，SqlDataSource1 将先于 SqlDataSource2 连接到数据源，因此 lstCities 将在 GridView1 之前填充值，原因是 lstcities em> 是在 GridView1 之前声明的？！

B) 如果是这样，那么 ControlParameter 何时从 DropDownList 中检索值？ 我假设它在 SqlDataSource1_Selected() 事件处理程序之后和 SqlDataSource2_Selecting() 事件处理程序之前，但具体是什么时候呢？

在 .aspx 页面中：

    <asp:SqlDataSource ID="SqlDataSource1" ... >
    </asp:SqlDataSource>

    <asp:DropDownList ID="lstCities" DataSourceID="SqlDataSource1"
         DataTextField="City" runat="server"></asp:DropDownList>

    <asp:SqlDataSource ID="SqlDataSource2" ... >
        <SelectParameters>
            <asp:ControlParameter ControlID="lstCities" Name="City"
                 PropertyName="SelectedValue" />
        </SelectParameters>
    </asp:SqlDataSource>

    <asp:GridView DataSourceID="SqlDataSource2" runat="server" …>
    </asp:GridView>

thanx

编辑：

但是，如果是回发，那么这些参数将从页面的 OnLoadComplete 上的视图状态加载，同样按照它们声明的顺序。

Q1 - 让我们假设 ControlParameter 绑定到控件 C 的属性 C1。我想在回发时 ControlProperty 总是能够从 ViewState 获取 C.C1 的值，无论 C 是什么类型，即使 C 是什么类型ViewState 被禁用了吗？！

Q2 - 但请问为什么如果第一次创建页面，则不能从视图状态中检索 ControlParameter 的值？ 毕竟，当 lstCities 从数据源检索数据时，lstCities.SelectedValue 的值就设置好了？

谢谢伙伴

第二次编辑：

我很抱歉没有尽快回复，但我没有意识到你已经回复了。 当我这样做时，我花了 20 分钟试图让我的 3 个脑细胞正常工作，但我不确定我是否完全成功

A) 所以 ControlParameter 评估 C.C1 并因此检索 C.C1 的值C绑定后？！

Q1 - ControlParameter 仅读取其自身状态并仅确定其是否更改

A) 因此 ControlParameter 在绑定发生之前检查其 ViewState 是否更改（以便触发 OnParameterChanged 事件） --> 因此它会在 Page.OnLoadComplete 期间检查其 ViewState。 但是 ControlParameter 如何知道其 ViewState 已更改（它将在第一次回发时知道）？ 毕竟，从第一次创建页面开始，ControlParameter 的 ViewState 将始终被标记为脏，因此，从一个回发到另一个回发，ControlParameter 如何知道其值在回发之间是否已更改？

B) 我假设 ControlParameter 检查其 Viewstate 是否更改，以便它可以触发 OnParameterChanged 事件。 但为什么处理该事件如此重要？

第一次进行属性评估是在 Page.OnLoadComplete

属性评估您的意思是 ControlParameter 检查它自己的 ViewState 吗？ 因此，您的意思并不是说 ControlParameter 评估 C.C1 （我认为这发生在 C 被绑定之后）

我真的很感谢您的帮助

第三次编辑：

我真的很抱歉再次占用您的时间。我会尽力将其作为我的最后一次编辑。

Update() 在 OnLoadComplete 和数据绑定发生时都会被调用。 在 Update() 内部，还会执行以下语句：

this.ViewState["ParameterValue"] = actualValue;

因此，如果在数据绑定发生时调用 Update()，那么这意味着什么 当在 OnLoadComplete 中调用下一次回发 UpDate() 时，C.C1 和 ControlParameter 将已经具有相同的值，因此

             if ((actualValue == null && storedValue != null)
             || (actualValue != null && actualValue != storedValue))

将始终返回 false（在 OnLoadComplete 中调用 Update() 时），因此 OnParameterChanged 事件永远不会被触发？1如果是这样，我看不出需要在 OnLoadComplete 中调用 Update() ！

非常感谢

Answer 1

你的第一个假设是正确的。

对于你的第二个问题，这取决于它是否是回发和/或你是否明确绑定。 如果不是回发并且绑定自动发生，那么粗略地说，当 DataSourceView 在 OnSelecting 事件之前调用 DataBind 上的 Select 时，将检索 ControlParameter 的值。 gridview（以及与此相关的任何给定控件）的顺序如下：

Page.ProcessRequest
Page.PreRenderRecursiveInternal
...
GridView.EnsureChildControls
GridView.CreateChildControls
GridView.DataBind
GridView.PerformSelect
DataSourceView.Select //comes from either SQLDataSource or LinqDataSource
DataSourceView.ExecuteSelect
//for Linq:
    LinqDataSourceView.GetParameterValues(WhereParameters)
//for SQL:
    SqlDataSourceView.InitializeParameters(SelectParameters)
Parameters.GetValues
Parameters.UpdateValues //this is where values get retrieved using reflection
DataSourceView.OnSelecting //follows almost immediately
...get data...
DataSourceView.OnSelected

因此，对于控件层次结构中的每个控件，框架递归调用 DataBind，然后触发参数检索、OnSelecting、数据检索和 OnSelected。

然而，如果它是回发，那么这些参数将从页面的 OnLoadComplete 上的视图状态加载，同样按照它们声明的顺序。

这是您要找的吗？

编辑

Q1 - 让我们假设 ControlParameter 绑定到控件 C 的属性 C1。我想在回发时 ControlProperty 始终能够从 ViewState 获取 C.C1 的值，无论 C 是什么类型，即使 C ViewState 被禁用了吗？！

事情并不完全是这样发生的...在回发时（以及针对该问题的初始请求），仅评估 ControlParemeter 的视图状态以查看它是否发生更改，以便触发 OnParameterChanged 事件。 ControlParameter 的实际值根据它指向的控件进行评估（通过反射）。 在你的情况下，它是“C.C1”。 现在，当它读取 C.C1 时，它的值很可能是从视图状态读取的。 但 ControlParameter 绝不会直接读取 C 的视图状态。

Q2 - 但我想问一下，为什么如果第一次创建页面，则不能从视图状态中检索 ControlParameter 的值？ 毕竟，当 lstCities 从数据源检索数据时，lstCities.SelectedValue 的值就设置好了？

就是这样，此时（页面第一次加载）lstCities 尚未检索任何数据。 属性评估第一次发生在 Page.OnLoadComplete 上，但在任何 DataBind 之前（当 Page.PreRenderRecursiveInternal 被触发时不久就会发生）。

以粗略的形式，尝试将其放入页面的生命周期中：

...request...
PerformPreInit
InitRecursive //SqlDataSource subscribes to Page.LoadComplete
OnInitComplete
if PostBack
    LoadAllState //the view state gets loaded
    ProcessPostData
OnPreLoad
LoadRecursive
if PostBack
    ProcessPostData
    RaiseChangedEvents
    RaisePostBackEvents //you handle your events
//notice that following sections assume that you did not do any data 
//binding inside your events
OnLoadComplete //This is where parameters (SelectParemeters/WhereParemeters)
    //get updated. At this point none of them are data bound yet.
    //And if it the first time, there are no values
    //as the ViewState is empty for them.
PreRenderRecursiveInternal //calls the DataBind (if you haven't already), 
    //then DataSourceView.Select; parameters evaluate their controls.
    //The control C would be bound at this point.
PerformPreRenderComplete
SaveAllState
OnSaveStateComplete
RenderControl

第二次编辑

所以 ControlParameter 会计算 C.C1，从而在 C 绑定后检索 C.C1 的值？！

ControlParameter 每当被请求时都会检索值，在这种情况下，这会（间接）发生在两个地方：OnLoadComplete 和 DataBind（由 PreRenderRecursiveInternal 触发）。 在 OnLoadComplete 上，C 未绑定。 在PreRenderRecursiveInternal上，在DataBind之后，C被绑定。 两次 ControlParameter 都被要求读取 C.C1。 也许以下内容会有所帮助...

简而言之，这里是感兴趣的类和方法。 将它们放在页面周期的角度，希望它会很清楚。

public class ControlParameter : Parameter
{
    public string ControlID { get; set; } //stored in ViewState
    public string PropertyName { get; set; } //stored in ViewState

    protected override object Evaluate(HttpContext context, Control owner)
    {
        Control sourceControl = DataBoundControlHelper.FindControl(owner, this.ControlID);
        //evaluate C.C1 using reflection
        return DataBinder.Eval(sourceControl, this.PropertyName);
    }

    internal void UpdateValue(HttpContext context, Control owner)
    {
        //PostBack or not, read stored value (on initial load it is empty)
        object storedValue = this.ViewState["ParameterValue"];
        //Get the actual value for this parameter from C.C1
        object actualValue = this.Evaluate(context, owner);
        //Store received value
        this.ViewState["ParameterValue"] = actualValue;
        //Fire a change event if necessary
        if ((actualValue == null && storedValue != null)
         || (actualValue != null && actualValue != storedValue))
            this.OnParameterChanged();
    }
}

public class SqlDataSource : DataSourceControl
{
    //fired by OnLoadComplete
    private void LoadCompleteEventHandler(object sender, EventArgs e)
    {
        //UpdateValues simply calls the UpdateValue for each parameter
        this.SelectParameters.UpdateValues(this.Context, this);
        this.FilterParameters.UpdateValues(this.Context, this);
    }
}

public class SqlDataSourceView : DataSourceView, IStateManager
{
    private SqlDataSource _owner;

    //this method gets called by DataBind (including on PreRenderRecursiveInternal)
    protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
    {
        DbConnection connection = this._owner.CreateConnection(this._owner.ConnectionString);
        DbCommand command = this._owner.CreateCommand(this.SelectCommand, connection);
        //This is where ControlParameter will read C.C1 values again.
        //Except this time, C.C1 will be already populated by its own DataBind
        this.InitializeParameters(command, this.SelectParameters, null);

        command.CommandType = GetCommandType(this.SelectCommandType);
        SqlDataSourceSelectingEventArgs e = new SqlDataSourceSelectingEventArgs(command, arguments);

        this.OnSelecting(e);

        if (e.Cancel)
            return null;

        //...get data from DB

        this.OnSelected(new SqlDataSourceStatusEventArgs(command, affectedRows, null));

        //return data (IEnumerable or DataView)
    }

    private void InitializeParameters(DbCommand command, ParameterCollection parameters, IDictionary exclusionList)
    {
        //build exlusions list
        //...
        //Retrieve parameter values (i.e. from C.C1 for the ControlParameter)
        IOrderedDictionary values = parameters.GetValues(this._context, this._owner);

        //build command's Parameters collection using commandParameters and retrieved values
        //...
    }
}

A) 因此 ControlParameter 检查其 ViewState 是否更改...

参考上面的UpdateValue方法看看它是如何使用ViewState的。

<块引用>

B) 我假设 ControlParameter 检查其 Viewstate 是否发生更改，以便它可以触发 OnParameterChanged 事件。 但为什么处理该事件如此重要？

我不知道这很重要。 我想，就像任何其他事件一样，它允许您跟踪参数属性的变化并根据您的需要采取行动。 它在很多地方被解雇，但我看不到有人订阅它。 所以...

通过属性评估，您的意思是 ControlParameter 检查它自己的 ViewState？ 因此，您的意思并不是说 ControlParameter 评估 C.C1 （我认为这发生在 C 被绑定之后）

这意味着 ControlParameter.UpdateValue 被调用，它检查 ViewState 的原因，然后调用 ControlParameter.Evalue，然后找到一个控件并使用反射 (Eval) 检索数据。 往上看。

第三次编辑

我认为“更新”是指“更新值”。

因此，如果在数据绑定发生时调用 Update()，那么这意味着当在 OnLoadComplete 中调用下一次回发 UpDate() 时，C.C1 和 ControlParameter 将已经具有相同的值...

没有必要。 您忘记了视图状态是在 LoadAllState 上加载的，并且在它和 OnLoadComplete 之间还有六个步骤（请参阅上面的页面生命周期）。 其中每一个都可能修改源控件的 (C.C1) 值。

假设您有 C.C1 =“x” 并进行了回发。 现在，所有控件的视图状态均已加载 (LoadAllState)。 如果 C.C1 将其值存储在视图状态中，它将加载“x”。 在 Page_Load (LoadRecursive) 上，您决定设置 C.C1 = "y"。 这里，C.C1 可能决定是否将“y”存储在其视图状态中——这无关紧要。 然后其他事件随之而来。 接下来是 OnLoadComplete。 由于 SqlDataSource 订阅了此事件，它将评估所有关联的参数 (LoadCompleteEventHandler)，并且由于您确实更改了 C.C1 但 ControlParameter 的视图状态没有更改，因此

if ((actualValue == null && storedValue != null)
 || (actualValue != null && actualValue != storedValue))
    this.OnParameterChanged();

将返回 true，并且将触发 OnParameterChanged。 顺便说一句，至少还有其他十个地方可以触发此事件。 它在数据绑定和属性检索过程中没有发挥很大的作用（如果有的话）。