ASP.NET AJAX Programmer’s Reference with ASP.NET 2.0 or ASP.NET 3.5 phần 7 pps

Adding a Container Control to a Composite Control The BaseMasterDetailControl server control implements a method named AddContainer , shown in Listing 19-13 , that encapsulates the cod

This is where the IStateManager interface comes into play The type of MasterContainerStyle and

DetailContainerStyle complex properties — that is, the TableItemStyle — implements this interface

When the SaveViewState method of a control is called, the method calls the SaveViewState methods

of its complex properties The SaveViewState method of a complex property does exactly what the SaveViewState method of a control does — it saves its state into an appropriate object and returns the object

It then collects the objects returned from the SaveViewState methods of its complex properties and saves them into the same object to which it saves its own state Finally, it returns the object that contains the states of both the control and its complex properties

When the LoadViewState method of a control is called, it retrieves the objects that contain the states of its complex properties It then calls the LoadViewState method of each complex property and passes the object that contains the saved state into it The LoadViewState method of a complex property does exactly what the LoadViewState of a control does

As you can see from the implementation of the MasterContainerStyle and DetailContainerStyle properties shown in Listing 19-13 , when these two style properties are created and

BaseMasterDetailControl server control is tracking its view state, the control calls the

TrackViewState method of these two properties to inform them that they must start tracking their view states

TrackViewState

BaseMasterDetailControl overrides TrackViewState to call the TrackViewState methods of its style properties, as shown in Listing 19-13 Note that TrackViewState calls the TrackViewState method of a style property if and only if the style isn’t null — that is, if the page developer has specified the style

SaveViewState

BaseMasterDetailControl overrides SaveViewState to call the SaveViewState methods of its style properties, as shown in Listing 19-13 The SaveViewState method of each style property stores its view state in an appropriate object and returns the object to the SaveViewState method of

BaseMasterDetailControl , which in turn puts all these objects, and the object that contains the view state of its base class, in an array and returns the array to its caller

Notice that SaveViewState checks whether all the objects that the array contains are null If they are, it returns null If at least one of the objects isn’t null , it returns the whole array

LoadViewState

BaseMasterDetailControl overrides LoadViewState to call the LoadViewState methods of its

style properties, as shown in Listing 19-13 As you can see, the LoadViewState method of

BaseMasterDetailControl retrieves the array of objects that contains the saved view state of its base

class and style properties The method then calls the LoadViewState methods of its base class and

properties in the order in which the SaveViewState method of BaseMasterDetailControl called

their SaveViewState methods The LoadViewState method of each style property loads its view state

with the saved view state

Adding a Container Control to a Composite Control

The BaseMasterDetailControl server control implements a method named AddContainer , shown in

Listing 19-13 , that encapsulates the code that adds a container control to the Controls collection of the

BaseMasterDetailControl control Note that this method is marked as protected virtual to enable

others to override it — in order, for example, to raise an event before or after the container is added to

the Controls collection

Rendering a Container Control

The BaseMasterDetailControl server control exposes a method named RenderContainer , shown in

Listing 19-13 , which encapsulates the code that renders a container This method is marked as protected

virtual to enable others to override it

Overriding CreateChildControls: One-Stop Shopping for

All Your Child Controls

The Control class exposes a method named CreateChildControls that you must override to create

the child controls that you need in order to assemble your custom control One important thing to keep

in mind about child controls is that they’re created on demand Don’t assume that they’re created at a

particular stage of your custom control’s life cycle They can be created at any time In other words, the

CreateChildControls method can be called at any stage of your custom control’s life cycle to create

the child controls

This has important consequences One of these is that you must create the child controls of your custom

control in one and only one place — the CreateChildControls method Your custom control mustn’t

create any of its child controls in any other place If you create your child controls in any other place,

they cannot be created on demand because the on-demand child-control creation feature of the

ASP.NET Framework is accomplished via calling the CreateChildControls method Think of

CreateChildControls as your one-stop shopping place for all your child controls You mustn’t shop

anywhere else!

Next, I’ll walk you through the implementation of the CreateChildControls method shown in

Listing 19-13 This method first calls the Clear method of the Controls collection to clear the collection

This ensures that multiple copies of child controls aren’t added to the Controls collection when the

CreateChildControls method is called multiple times:

Controls.Clear();

If you examine the implementation of the BaseMasterDetailControl server control, you’ll notice that this method is never called multiple times You may be wondering, then, why you should bother with clearing the collection You’re right as far as the implementation of the BaseMasterDetailControl server control goes, because you’re the author of this control and you can make sure your implementation

of it doesn’t call the CreateChildControls method multiple times However, you have no control over others when they’re deriving from your control to author their own custom controls There’s nothing that would stop them from calling the CreateChildControls method multiple times This example shows that when you’re writing a custom control you must take the subclasses of your custom control into account

Then it takes the following actions for each cell shown in Figure 19-7 to create the child control that goes into the cell:

❑ It calls the CreateContainer method to create the container control that represents the cell For example, the following call to the CreateContainer method creates the container control that represents the cell number 2 in Figure 19-7 :

detailContainer = CreateContainer(ContainerType.Detail);

❑ It calls the CreateContainerChildControls method and passes the container control into it

As I mentioned earlier, the CreateContainerChildControls method creates the child trols, initializes them, and adds them to the container control For example, the following call to the CreateContainerChildControls method creates the detail server control and adds it

con-to the detailContainer server control:

CreateContainerChildControls(detailContainer);

❑ It calls the AddContainer method to add the container control to the BaseMasterDetailControl server control For example, the following code adds the container control that represents the cell number 2 in Figure 19-7 to the BaseMasterDetailControl control:

To address this problem, the Control class exposes a method named EnsureChildControls and a Boolean property named ChildControlsCreated The EnsureChildControls method checks whether the ChildControlsCreated property is set to false If it is, the method first calls the

CreateChildControls method and then sets the ChildControlsCreated property to true The

EnsureChildControls method uses this property to avoid multiple invocations of the

CreateChildControls method

That is why your custom control’s implementation of the CreateChildControls method must set the

ChildControlsCreated property to true to signal the EnsureChildControls method that child

con-trols have been created and the CreateChildControls mustn’t be called again

Overriding the TagKey Property

Your custom control must use the TagKey property to specify the HTML element that will contain the

entire contents of your custom control — that is, the containing element of your custom control Since

BaseMasterDetailControl displays its contents in a table, the control overrides the TagKey property

to specify the table HTML element as its containing element (see Listing 19-13 )

Overriding the CreateControlStyle Method

Your custom control must override the CreateControlStyle method to specify the appropriate Style

subclass The properties of this Style subclass are rendered as CSS style attributes on the containing

HTML element Since BaseMasterDetailControl uses a table HTML element as its containing

ele-ment, it overrides the CreateControlStyle method to use a TableStyle instance (see Listing 19-13 )

The TableStyle class exposes properties such as GridLines , CellSpacing , CellPadding ,

HorizontalAlign , and BackImageUrl that are rendered as CSS table style attributes

Exposing Style Properties

When you override the CreateControlStyle method, you must also define new style properties for

your custom control that expose the corresponding properties of the Style subclass This provides page

developers with a convenient mechanism to set the CSS style properties of the containing HTML

element

BaseMasterDetailControl exposes five properties named GridLines , CellSpacing , CellPadding ,

HorizonalAlign , and BackImageUrl that correspond to the properties of the TableStyle class with

the same names as shown in Listing 19-13

Overriding the RenderContents Method

The CreateChildControls method is where you create and initialize the child controls that you need

in order to assemble your custom control The RenderContents method is where you do the assembly

— that is, where you assemble your custom control from the child controls First you need to understand

how the default implementation (the WebControl class’s implementation) of the RenderContents

method assembles your custom control from the child controls

The WebControl class’s implementation of RenderContents calls the Render method of its base class,

the Control class:

protected internal virtual void RenderContents(HtmlTextWriter writer)

{

base.Render(writer);

}

Render calls the RenderChildren method of the Control class:

protected internal virtual void Render(HtmlTextWriter writer){

In conclusion, the default implementation of the RenderContents method assembles the child controls

in the order in which the CreateChildControls method adds them to the Controls collection This default assembly of the BaseMasterDetailControl custom control will simply lay down the child con-trols on the page one after another in a linear fashion, which is not the layout you want As Listing 19-13 shows, the BaseMasterDetailControl server control overrides the RenderContents method to com-pose or assemble the child controls in a tabular fashion

As Figure 19-7 shows, the BaseMasterDetailControl server control renders its contents in

a table that consists of two rows The RenderContents method in Listing 19-13 first calls the

ApplyContainerStyles method to apply container styles Then, for each table row, it calls the

RenderBeginTag method of the HtmlTextWriter object passed in as its argument to render the opening tag of the tr HTML element that represents the row:

Finally, it calls the RenderEndTag method of the HtmlTextWriter object to render the closing tag of the

tr HTML element that represents the row:

writer.RenderEndTag();

Exposing the Properties of Child Controls

Your composite control must expose the properties of its child controls as if they were its own properties

in order to enable page developers to treat these properties as attributes on the tag that represents your custom control on an ASP.NET page BaseMasterDetailControl exposes the following properties of its child master and detail controls as its own properties, as shown in Listing 19-13

Since the child controls of your custom composite control are created on demand, there are no

guarantees that the child controls are created when the getters and setters of these properties access

them That’s why the getters and setters of these properties call EnsureChildControls before they

access the respective child controls In general, your custom control must call EnsureChildControls

before it accesses any of its child controls

Exposing the properties of child controls as the top-level properties of your composite control provides

page developers with the following benefits:

❑ They can set the property values of child controls as attributes on the tag that represents your

composite control on an ASP.NET page

❑ If your custom composite control doesn’t expose the properties of its child controls as its

top-level properties, page developers will have no choice but to use the error-prone approach of

indexing the Controls collection of the composite control to access the desired child control

and set its properties

❑ They can treat your custom control as a single entity In other words, your composite control

enables page developers to set the properties of its child controls as if they were setting its own

properties

What Your Custom Control Inherits from CompositeControl

The ASP.NET CompositeControl provides the basic features that every composite control must

support:

❑ Overriding the Controls collection

❑ Implementing INamingInterface

❑ Overriding the DataBind method

❑ Implementing the ICompositeControlDesignerAccessor interface This interface exposes a

single method named RecreateChildControls that enables designer developers to recreate

the child controls of a composite control on the designer surface This is useful if you want to

develop a custom designer for your composite control A designer is a component that enables

page developers to work with your custom composite control in a designer such as Visual

Studio (This chapter doesn’t cover designers.)

❑ Overriding the Render method to call EnsureChildControls when the control is in design

mode before the actual rendering begins This ensures that child controls are created before they

are rendered

Overriding the Controls Collection

As I discussed earlier, the child controls that you need in order to assemble your custom control aren’t

created at any particular phase of your control’s life cycle They’re created on demand Therefore, there

are no guarantees that the child controls are created when the Controls collection is accessed That’s

why CompositeControl overrides the Collection property to call the EnsureChildControls method to ensure that the child controls are created before the collection is accessed:

public override ControlCollection Controls{

get { EnsureChildControls();

return base.Controls;

}}

I NamingContainer Interface

As Listing 19-13 shows, the BaseMasterDetailControl server control assigns unique values to the ID properties of all of its child controls For example, it assigns the string value MasterServerControl to the ID property of the master child control This string value is unique in that no other child control

of the BaseMasterDetailControl control has the same ID property

Now let’s examine what happens when page developers use two instances of the

BaseMasterDetailControl control on the same ASP.NET Web page Call the first instance

MasterDetailControl_1 and the second instance MasterDetailControl_2 Even though the

ID properties of the child controls of each instance are unique within the scope of the instance, they aren’t unique within the page scope, because the ID property of a given child control of one instance

is the same as the ID property of the corresponding child control of the other instance For example, the ID property of the master child control of the MasterDetailControl_1 instance is the same as the

ID property of the master child control of the MasterDetailControl_2 instance

So can the ID property value of a child control of a composite control be used to locate the control? It depends Any code within the scope of the composite control can use the ID property value of a child control to locate it, because the ID property values are unique within the scope of the composite control However, if the code isn’t within the scope of the composite control, it can’t use the ID property to locate the child control on the page if the page contains more than one instance of the composite control Two very good examples of this circumstance are as follows:

❑ The client-side code uses the id attribute of a given HTML element to locate it on the page This scenario is very common, because DHTML is so popular

❑ The page needs to uniquely identify and locate a server control on the page to delegate postback and postback data events to it

So what property of the child control should the code from outside the scope of the composite control use to locate the child control on the page? The Control class exposes two important properties named

ClientID and UniqueID The page is responsible for assigning values to these two properties that are unique on the page The ClientID and UniqueID properties of a control are rendered as the id and

name HTML attributes on the HTML element that contains the control As you know, client code uses the

id attribute to locate the containing HTML element on the page while the page uses the name attribute to

locate the control on the page

The page doesn’t automatically assign unique values to the ClientID and UniqueID properties

of the child controls of a composite control The composite control must implement the

INamingContainer interface to request the page to assign unique values to these two properties

The INamingContainer interface is a marker interface and doesn’t expose any methods,

properties, or events

You may wonder how the page assigns unique values to the ClientID and UniqueID properties of

the child controls of a composite control A child control, like any other control, inherits the

NamingContainer property from the Control class This property refers to the first ascendant control

of the child control that implements the INamingContainer interface If your custom composite control

implements this interface, it becomes the NamingContainer of its child controls The page concatenates

the ClientID of the NamingContainer of a child control to its ID with an underscore character as the

separator to create a unique string value for the ClientID of the child control The page does the same

thing to create a unique string value for the UniqueID of the child control with one difference — the

separator character is a dollar sign character rather than an underscore character

BaseMasterDetailControl2

One of the best choices for a detail server control is the ASP.NET DetailsView server control, and

one of the best choices for a master server control is the subclasses of BaseDataBoundControl , which

include GridView , BulletedList , ListBox , CheckBoxList , RadioButtonList , and so on I’ll

implement another abstract base class named BaseMasterDetailControl2 that derives from

BaseMasterDetailControl and extends its functionality to use a DetailsView server control as

detail server control and a BaseDataBoundControl server control as master server control, as shown

namespace CustomComponents{

public abstract class BaseMasterDetailControl2 : BaseMasterDetailControl {

protected override Control CreateMaster() {

BaseDataBoundControl master = this.CreateBaseDataBoundControlMaster();

master.DataBound += new EventHandler(Master_DataBound);

return master;

}

protected abstract void Master_DataBound(object sender, EventArgs e);

protected abstract BaseDataBoundControl CreateBaseDataBoundControlMaster();

protected override Control CreateDetail() {

DetailsView detail = new DetailsView();

} set { ((BaseDataBoundControl)Master).DataSourceID = value;

} }

(continued)

As you can see from Listing 19-16 , the CreateMaster method first invokes another method named

CreateBaseDataBoundControlMaster to create and return a BaseDataBoundControl server control

as the master server control:

BaseDataBoundControl master = this.CreateBaseDataBoundControlMaster();

Next, it registers a method named Master_DataBound as event handler for the DataBound event of the

master server control:

master.DataBound += new EventHandler(Master_DataBound);

As you’ll see later, the master server control is normally bound to an ASP.NET data source control such

as SqlDataSource A BaseDataBoundControl server control raises the DataBound event every time it

is bound or rebound to the underlying data source control This normally happens when the DataBind

method of the control is invoked Since rebinding the master server control causes the control to

download fresh data from the underlying data store and to reload, you need to ensure that the selected

record is set back to the original record if the fresh data contains the original record That is why the

BaseMasterDetailControl2 registers the Master_DataBound method as an event handler for

the DataBound event of the master server control

As Listing 19-16 shows, the CreateBaseDataBoundControlMaster method is an abstract method and

must be implemented by the subclasses of BaseMasterDetailControl2 This allows each subclass to

use a different subclass of BaseDataBoundControl as a master server control:

protected abstract BaseDataBoundControl CreateBaseDataBoundControlMaster();

As you can see from Listing 19-16 , the Master_DataBound is an abstract method and must be

imple-mented by the subclasses of BaseMasterDetailControl2 This allows each subclass to perform tasks

specific to the specific type of the BaseDataBoundControl server control being used:

protected abstract void Master_DataBound(object sender, EventArgs e);

CreateDetail

As you can see from Listing 19-16 , the BaseMasterDetailControl2 control implements the

CreateDetail method of its base class to instantiate and initialize a DetailsView server control

as the detail server control

RegisterDetailEventHandlers

The main responsibility of the RegisterDetailEventHandlers method is to register event handlers for those events of the detail server control that require the master server control to update As you can see from Listing 19-16 , in the case of the DetailsView server control, the following events are of interest:

❑ ItemDeleted : The DetailsView server control raises this event when the end user deletes the selected data record The BaseMasterDetailControl2 registers a method named UpdateMaster

as an event handler for this event to update the master server control accordingly:

If you don’t call the Update method on the UpdatePanel server control after rebinding the master server control, the master server control will retrieve the data from the underlying data store but will not refresh itself with the retrieved data You’ll see the logic behind this process in the following chapters

Properties

As you can see from Listing 19-16 , the BaseMasterDetailControl2 control, like any other composite

server control, exposes the properties of its child controls as its own top-level properties, as follows:

❑ MasterDataSourceID : This string property exposes the DataSourceID property of the master

server control, which is a BaseDataBoundControl control, as a top-level property

❑ DetailDataSourceID : This string property exposes the DataSourceID property of the detail

server control, which is a DetailsView control, as a top-level property

Summar y

This chapter used numerous examples to provide you with an introduction to the ASP.NET AJAX partial

page rendering I then developed two base custom partial-page-enabled server controls named

BaseMasterDetailControl and BaseMasterDetailControl2 , which we will use in the next chapter

to build partial-page-enabled server controls

Using UpdatePanel in User

Controls and Custom

Controls

The previous chapter developed two partial-rendering-enabled custom controls named

BaseMasterDetailControl and BaseMasterDetailControl2 , which I will use in this chapter

to develop partial-rendering-enabled custom server controls I’ll then use examples to show you how to use ASP.NET AJAX partial page rendering in your own Web applications

MasterDetailControl

MasterDetailControl is a server control that inherits from BaseMasterDetailControl2 and extends its functionality to use the ASP.NET GridView as a master server control, as shown in Listing 20-1

Listing 20-1: The MasterDetailControl Server Control

{ EnsureChildControls();

((GridView)Master).DataKeyNames = value;

((DetailsView)Detail).DataKeyNames = value;

} }

protected override void Master_DataBound(object sender, EventArgs e) {

for (int i = 0; i < ((GridView)Master).Rows.Count; i++) {

if (((GridView)Master).DataKeys[i].Value == this.SelectedValue) {

((GridView)Master).SelectedIndex = i;

break;

} }

((GridView)Master).SelectedIndex = -1;

Master_SelectedIndexChanged(null, null);

} }

protected virtual void Master_SelectedIndexChanged(object sender, EventArgs e) {

if (((GridView)Master).SelectedIndex == -1) this.Detail.Visible = false;

else this.Detail.Visible = true;

this.SelectedValue = ((GridView)Master).SelectedValue;

UpdateDetail(sender, e);

} }}

I’ll discuss the methods and properties of the MasterDetailControl server control in the following sections

CreateBaseDataBoundControlMaster

As Listing 20-1 shows, the MasterDetailControl server control overrides the

CreateBaseDataBoundControlMaster method of its base class to create and return a GridView server control as the master server control As you can see, this method instantiates a GridView server control and sets its AllowPaging , AllowSorting , AutoGenerateColumns , and AutoGenerateSelectButton properties

RegisterMasterEventHandlers

The main responsibility of the RegisterMasterEventHandlers method is to register event handlers

for those events of the master server control that require the detail server control to update The

GridView server control exposes the following three important events that meet that description, as

shown in Listing 20-1 :

❑ SelectedIndexChanged : The GridView server control raises this event when the end user

selects a new record from the records that the control is displaying Since the detail server control

displays the details of the selected record, every time a new record is selected — that is, every

time the SelectedIndexChanged event is raised — the detail server control must be updated

with the details of the newly selected record Because of this, the MasterDetailControl

registers a method named Master_SelectedIndexChanged as an event handler for the

SelectedIndexChanged event of the GridView server control:

((GridView)Master).SelectedIndexChanged +=

new EventHandler(Master_SelectedIndexChanged);

❑ PageIndexChanged : The GridView server control raises this event when the end user clicks an

element in the pager user interface to display a new page of records Since the new page of

records may not include the selected record, you need to hide the detail server control until the

end user makes a new selection That is why the MasterDetailControl registers a method

named Master_ResetSelectedValue as an event handler for the PageIndexChanged event of

the GridView server control:

((GridView)Master).PageIndexChanged +=

new EventHandler(Master_ResetSelectedValue);

❑ Sorted : The GridView server control raises this event when the end user clicks the header

text of a column to sort the displayed records Again, the newly sorted records may not

include the selected record, so you need to hide the detail server control That is why the

MasterDetailControl registers the Master_ResetSelectedValue method as an event

handler for the Sorted event of the GridView server control:

((GridView)Master).Sorted += new EventHandler(Master_ResetSelectedValue);

Master_SelectedIndexChanged

As you can see from Listing 20-1 , this method hides the detail server control if the SelectedIndex

property of the master server control is set to -1 — that is, if no record is selected There is no point in

rendering the detail server control if there is no selected record to display:

The MasterDetailControl inherits the SelectedValue property from the BaseMasterDetailControl

As Listing 20-1 shows, this property stores its value in the view state for future reference It is necessary to store the selected record in the view state because the following requests may end up rebinding the

GridView server control and consequently resetting the SelectedValue property of the control In such situations, you can retrieve the selected value from the view state and assign it to the SelectedValue property of the GridView server control after rebinding the control if the control still contains the selected record

As Listing 20-1 shows, the Master_SelectedIndexChanged method finally calls the UpdateDetail method to update the detail server control This is necessary because a new record has been selected

MasterDetailControl inherits the UpdateDetail method from its base class — that is, from the

BaseMasterDetailControl As you can see from Listing 20-1 , this method first calls the DataBind method on the detail server control to rebind the control and consequently to retrieve fresh data from the underlying data store:

for (int i = 0; i < ((GridView)Master).Rows.Count; i++) {

if (((GridView)Master).DataKeys[i].Value == this.SelectedValue) {

((GridView)Master).SelectedIndex = i;

break;

} }

The GridView server control uses an instance of a server control named GridViewRow to display each

of its data records The Rows collection property of the GridView server control contains all the

GridViewRow server controls that display the data records of the server control

The GridView server control exposes a collection property named DataKeys , which contains one

DataKey object for each displayed data record in which the names and values of the primary key datafields of the record are stored In other words, each DataKey object in the DataKeys collection

Next, the method invokes the Master_SelectedIndexChanged method discussed earlier:

Master_SelectedIndexChanged(null, null);

Properties

As you can see from Listing 20-1 , the MasterDetailControl , like any other composite server control,

exposes the properties of its child controls as its own top-level properties, as follows:

❑ PageSize : This string property exposes the PageSize property of the GridView server control

as top-level property Recall that the PageSize property of a GridView server control specifies

the total number of records to display

❑ DataKeyNames : This array property exposes the DataKeyNames property of the GridView

server control as top-level property Recall that the DataKeyNames property of a

GridView server control contains the list of primary key datafield names

Note that the DataKeyNames property is annotated with the TypeConverter(typeof(StringArray

Converter)) metadata attribute to instruct the page parser that it must use the

StringArrayConverter to convert the declarative value of the DataKeyNames to the array This

declarative value is the value that the page developer declaratively assigns to the DataKeyNames

attribute on the tag that represents the MasterDetailControl server control on an aspx or ascx file

This declarative value is a string of comma-separated list of substrings in which each substring contains

the name of a primary key datafield name As the name suggests, the StringArrayConverter

converts this string into an array, which the page parser then automatically assigns to the

DataKeyNames property of the MasterDetailControl server control

Note that the getters and setters of these properties of the MasterDetailControl invoke the

EnsureChildControls method before they attempt to access the associated child server controls,

as I mentioned earlier

Using MasterDetailControl in a Web Page

Add the following files to the App_Code directory of the application that contains the page that uses the

MasterDetailControl control:

❑ BaseMasterDetailControl.cs : Listing 19-12 presents the content of this file

❑ ContainerType.cs : Listing 19-13 presents the content of this file

❑ MasterDetailContainer.cs : Listing 19-14 presents the content of this file

❑ BaseMasterDetailControl2.cs : Listing 19-15 presents the content of this file

❑ MasterDetailControl.cs : Listing 20-1 presents the content of this file

Listing 20-2 presents a page that uses the MasterDeatilControl Note that this page uses a theme,

a database with two tables named Products and Categories, and a connections string named

MyConnectionString I’ll discuss this theme, database, and connection string shortly If you run this

page, you’ll get the result shown in Figure 20-1

Listing 20-2: A Page that Uses the MasterDetailControl

<%@ Page Language=”C#” Theme=”Theme1” %>

<%@ Register Namespace=”CustomComponents” TagPrefix=”custom” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

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

<asp:ScriptManager ID=”ScriptManager1” runat=”server” />

<custom:MasterDetailControl ID=”MasterDetailControl1” runat=”server”

DataKeyNames=”ProductID” DetailDataSourceID=”DetailDataSource”

MasterDataSourceID=”MasterDataSource” PageSize=”3”

MasterSkinID=”GridView1” DetailSkinID=”DetailsView1” CellSpacing=”20”

HorizontalAlign=”Center” GridLines=”both” BorderStyle=”Ridge”

BorderWidth=”20” BorderColor=”Yellow” BackImageUrl=”images.jpg”>

<MasterContainerStyle HorizontalAlign=”center” BorderStyle=”Ridge”

SelectCommand=”Select ProductID, ProductName, UnitPrice From Products” />

<asp:SqlDataSource ID=”DetailDataSource” runat=”server”

ConnectionString=”<%$ ConnectionStrings:MyConnectionString %>”

SelectCommand=”Select * From Products where ProductID=@ProductID”

UpdateCommand=”Update Products Set ProductName=@ProductName, CategoryID=@CategoryID, UnitPrice=@UnitPrice, DistributorName=@DistributorName where ProductID=@ProductID”

DeleteCommand=”Delete From Products where ProductID=@ProductID”

InsertCommand=”Insert Into Products (ProductName, CategoryID, UnitPrice, DistributorName)

Values (@ProductName, @CategoryID, @UnitPrice, @DistributorName)”>

As you can see, the MasterDetailControl displays only the master portion of the control Now if you

select a record from the GridView control, you’ll get the result shown in Figure 20-2 : the DetailsView

server control displays the detail of the selected record

Note that the DetailsView server control displays the standard Edit and Delete buttons to enable end

users to edit and delete the current record from the underlying data store The DetailsView server

control also contains the New button to enable the end user to add a new record to the data store

Thanks to the ASP.NET AJAX partial page rendering infrastructure, all the user interactions with the

GridView and DetailsView server controls are handled asynchronously in the background without

interrupting the user or reloading the entire page

Note that the page shown in Listing 20-2 takes advantage of ASP.NET 2.0 themes A theme is

implemented as a subfolder under the App_Themes folder The subfolder must have the same name as

the theme A theme subfolder consists of one or more skin files and their respective image and Cascading

Style Sheet files Since ASP.NET 2.0 merges all the skin files of a theme into a single skin file, page

devel-opers can use as many skin files as necessary to organize the theme folder Themes are assigned to the

containing page, not to the the individual controls

Figure 20-1

The @Page directive in ASP.NET 2.0 exposes a new attribute named Theme , which is set to the name of the desired theme Since all themes are subfolders of the App_Themes folder, the ASP.NET framework knows where to find the assigned theme A skin file includes one or more control skins A control skin defines the appearance properties of a class of server controls The definition of a control skin is very similar to the declaration of an instance of the control on an ASP.NET page This doesn’t mean that all properties of a server control can be set in its skin In general, only the appearance properties can be included and set in a control skin If the SkinID property of a control skin isn’t set, the control skin is treated as the default skin A default skin is automatically applied to the control instances whose SkinID properties aren’t set If the SkinID property of a control skin is set, it will be applied only to the control instances whose SkinID property is set to the same value

Figure 20-2

The page shown in Listing 20-2 uses a theme named Theme1 that contains a skin file with the following

content:

<asp:GridView SkinID=”GridView1” runat=”server” BackColor=”LightGoldenrodYellow”

BorderColor=”Tan” BorderWidth=”1px” CellPadding=”2” ForeColor=”Black”

GridLines=”None”>

<FooterStyle BackColor=”Tan” />

<SelectedRowStyle BackColor=”DarkSlateBlue” ForeColor=”GhostWhite” />

<PagerStyle BackColor=”PaleGoldenrod” ForeColor=”DarkSlateBlue”

HorizontalAlign=”Center” />

<HeaderStyle BackColor=”Tan” Font-Bold=”True” />

<AlternatingRowStyle BackColor=”PaleGoldenrod” />

</asp:GridView>

<asp:DetailsView SkinID=”DetailsView1” runat=”server” Width=”100%”

BackColor=”LightGoldenrodYellow” BorderColor=”Tan” BorderWidth=”1px”

CellPadding=”2” ForeColor=”Black” GridLines=”None” HorizontalAlign=”Center”>

<FooterStyle BackColor=”Tan” />

<EditRowStyle BackColor=”DarkSlateBlue” ForeColor=”GhostWhite” />

<PagerStyle BackColor=”PaleGoldenrod” ForeColor=”DarkSlateBlue”

HorizontalAlign=”Center” />

<HeaderStyle BackColor=”Tan” Font-Bold=”True” />

<AlternatingRowStyle BackColor=”PaleGoldenrod” />

</asp:DetailsView>

Also note that the page shown in Listing 20-2 connects to a database named ProductsDB that consists of

two database tables named Products and Categories The following table describes the Products

database table:

The following table describes the Categories database table:

Column Name Data Type

Note that the data source controls in Listing 20-2 make use of a connection string named

MyConnectionString You need to add the following fragment to the web.config file of your application:

<configuration>

<connectionStrings>

<add connectionString=”server=YOUR_SERVER_NAME;initial catalog=ProductsDB;integrated security=SSPI” name=”MyConnectionString”/>

</connectionStrings>

</configuration>

MasterDetailControl2

In this section, you’ll implement a new server control named MasterDetailControl2 that derives from

BaseMasterDetailControl2 and extends its functionality to use a DropDownList server control as the master server control, as shown in Listing 20-3

Listing 20-3: The MasterDetailControl2 Server Control

public class MasterDetailControl2 : BaseMasterDetailControl2 {

protected override BaseDataBoundControl CreateBaseDataBoundControlMaster() {

DropDownList master = new DropDownList();

set { ((DetailsView)Detail).DataKeyNames = value;

} } }}

Master_SelectedIndexChanged

When the ListControl control raises the SelectedIndexChanged event, the

Master_SelectedIndexChanged method shown in Listing 20-3 is automatically invoked This method first checks whether any item has been selected from the ListControl control If not, it hides the detail server control, as I mentioned earlier:

if (((ListControl)Master).SelectedIndex == -1) this.Detail.Visible = false;

else this.Detail.Visible = true;

Next, it assigns the value of the SelectedValue property of the ListControl control to the

SelectedValue property of the MasterDetailControl2 control:

object whose value is given by the SelectedValue property of the MasterDetailControl2 Recall that

this property contains the value associated with the selected item:

ListItem selectedItem =

((ListControl)Master).Items.FindByValue((string)SelectedValue);

Next, it accesses the index of the selected item:

int selectedIndex = ((ListControl)Master).Items.IndexOf(selectedItem);

Then it assigns this index to the SelectedIndex property of the ListControl master:

MasterDetailControl2 , like any other composite control, exposes the properties of its child controls as

its own top-level properties, as shown in Listing 20-3 Note that the DataKeyNames property is

anno-tated with the [TypeConverter(typeof(StringArrayConverter))] metadata attribute to instruct

the page parser that it must use the StringArrayConverter to convert the declarative value of this

property to its imperative value The declarative value is the string containing a list of comma-separated

substrings that the page developer assigns to the DataKeyNames attribute on the tag that represents the

MasterDetailControl2 control on the aspx page The imperative value is the value that the

DataKeyNames property expects — that is, an array of strings The StringArrayConverter knows how

to convert the string containing a list of comma-separated substrings to a NET array that contains these

substrings

Using MasterDetailControl2

Listing 20-4 presents a page that uses the MasterDetailControl2 Figure 20-3 shows what you’ll see

on your browser when you access this page Note that this page uses a theme named Theme1 that

con-tains a skin file with the following content:

<asp:DetailsView SkinID=”DetailsView1” runat=”server” Width=”100%”

BackColor=”LightGoldenrodYellow” BorderColor=”Tan” BorderWidth=”1px”

CellPadding=”2” ForeColor=”Black” GridLines=”None” HorizontalAlign=”Center”>

<FooterStyle BackColor=”Tan” />

<EditRowStyle BackColor=”DarkSlateBlue” ForeColor=”GhostWhite” />

<HeaderStyle BackColor=”Tan” Font-Bold=”True” />

<AlternatingRowStyle BackColor=”PaleGoldenrod” />

</asp:DetailsView>

<asp:DropDownList SkinID=”DropDownList1” runat=”server”

BackColor=”LightGoldenrodYellow” BorderColor=”Tan” BorderWidth=”1px”

CellPadding=”2” ForeColor=”Black” GridLines=”None” Width=”100%”/>

This page assumes that the following files are added to the App_Code directory of the application that contains the page:

❑ BaseMasterDetailControl.cs : Listing 19-12 presents the content of this file

❑ ContainerType.cs : Listing 19-13 presents the content of this file

❑ MasterDetailContainer.cs : Listing 19-14 presents the content of this file

❑ BaseMasterDetailControl2.cs : Listing 19-15 presents the content of this file

❑ MasterDetailControl.cs : Listing 20-1 presents the content of this file

❑ MasterDetailControl2.cs : Listing 20-3 presents the content of this file

Also note that this page uses the same database ( ProductsDB ) and connection string discussed in the previous section

Again, thanks to the ASP.NET AJAX partial page infrastructure, every time the end user selects a new item from the DropDownList master control, or deletes, inserts, or updates a record in the DetailsView detail control, the following things happen:

❑ The current page is posted back to the server asynchronously in the background, without interrupting the user interaction with the current page

❑ When the server response finally arrives, only the MasterDetailControl2 is updated, without causing the entire page to reload

Listing 20-4: A Page that Uses MasterDetailControl2

<%@ Page Language=”C#” Theme=”Theme1” %>

<%@ Register Namespace=”CustomComponents” TagPrefix=”custom” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

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

<asp:ScriptManager ID=”ScriptManager1” runat=”server” />

(continued)

Listing 20-4 (continued)

<custom:MasterDetailControl2 ID=”MasterDetailControl21” runat=”server”

DataKeyNames=”ProductID” DetailDataSourceID=”DetailDataSource”

MasterDataSourceID=”MasterDataSource” MasterSkinID=”DropDownList1”

DetailSkinID=”DetailsView1” CellSpacing=”20” HorizontalAlign=”Center”

GridLines=”both” BorderStyle=”Ridge” BorderWidth=”20” BorderColor=”Yellow”

SelectCommand=”Select ProductID, ProductName From Products” />

<asp:SqlDataSource ID=”DetailDataSource” runat=”server”

ConnectionString=”<%$ ConnectionStrings:MyConnectionString %>”

SelectCommand=”Select * From Products where ProductID=@ProductID”

UpdateCommand=”Update Products Set ProductName=@ProductName,

CategoryID=@CategoryID,

UnitPrice=@UnitPrice,

DistributorName=@DistributorName

where ProductID=@ProductID”

DeleteCommand=”Delete From Products where ProductID=@ProductID”

InsertCommand=”Insert Into Products (ProductName, CategoryID, UnitPrice,

MasterDetailControl3

In this section, you’ll implement a new server control named MasterDetailControl3 that derives from

MasterDetailControl2 and extends its functionality to use a ListBox server control rather than the

DropDownList server control as master server control, as shown in Listing 20-5 As you can see,

MasterDetailControl3 simply overrides the CreateBaseDataBoundControlMaster method that

it inherits from MasterDetailControl2 and replaces the DropDownList server control with a

ListBox server control

Listing 20-5: The MasterDetailControl3 Control

Listing 20-6 contains a page that uses MasterDetailControl3 Note that this page uses a theme named

Theme1 , which contains a skin file with the following content:

<asp:DetailsView SkinID=”DetailsView1” runat=”server” Width=”100%”

BackColor=”LightGoldenrodYellow” BorderColor=”Tan” BorderWidth=”1px”

CellPadding=”2” ForeColor=”Black” GridLines=”None” HorizontalAlign=”Center”>

<FooterStyle BackColor=”Tan” />

<EditRowStyle BackColor=”DarkSlateBlue” ForeColor=”GhostWhite” />

<HeaderStyle BackColor=”Tan” Font-Bold=”True” />

<AlternatingRowStyle BackColor=”PaleGoldenrod” />

</asp:DetailsView>

<asp:ListBox SkinID=”ListBox1” runat=”server” BackColor=”LightGoldenrodYellow”

BorderColor=”Tan” BorderWidth=”1px” ForeColor=”Black” Width=”200”/>

Note also that this page assumes that the following files are added to the App_Code directory of the

application that contains this page:

❑ BaseMasterDetailControl.cs : Listing 19-12 presents the content of this file

❑ ContainerType.cs : Listing 19-13 presents the content of this file

❑ MasterDetailContainer.cs : Listing 19-14 presents the content of this file

❑ BaseMasterDetailControl2.cs : Listing 19-15 presents the content of this file

❑ MasterDetailControl.cs : Listing 20-1 presents the content of this file

❑ MasterDetailControl2.cs : Listing 20-3 presents the content of this file

❑ MasterDetailControl3.cs : Listing 20-5 presents the content of this file

Also note that this page uses the same database ( ProductsDB ) and connection string as the pages in the previous sections

Figure 20-4 shows what you’ll get when you access this page As you can see, the master server control is now a ListBox server control Again, thanks to the ASP.NET AJAX partial page infrastructure, every time the end user selects a new item from the ListBox master control or deletes, inserts, or updates a record in the DetailsView detail control, the following things happen:

❑ The current page is posted back to the server asynchronously in the background, without rupting the user interaction with the current page

inter-❑ When the server response finally arrives, only the MasterDetailControl3 is updated, without causing the entire page to reload

Listing 20-6: A Page that Uses the MasterDetailControl3 Control

<%@ Page Language=”C#” Theme=”Theme1” %>

<%@ Register Namespace=”CustomComponents” TagPrefix=”custom” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

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

<asp:ScriptManager ID=”ScriptManager1” runat=”server” />

<custom:MasterDetailControl3 ID=”MasterDetailControl21” runat=”server”

DataKeyNames=”ProductID” DetailDataSourceID=”DetailDataSource”

MasterDataSourceID=”MasterDataSource” MasterSkinID=”ListBox1”

DetailSkinID=”DetailsView1” CellSpacing=”20” HorizontalAlign=”Center”

GridLines=”both” BorderStyle=”Ridge” BorderWidth=”20” BorderColor=”Yellow”

Listing 20-6 (continued)

<asp:SqlDataSource runat=”server” ID=”MasterDataSource”

ConnectionString=”<%$ ConnectionStrings:MyConnectionString %>”

SelectCommand=”Select ProductID, ProductName From Products” />

<asp:SqlDataSource ID=”DetailDataSource” runat=”server”

ConnectionString=”<%$ ConnectionStrings:MyConnectionString %>”

SelectCommand=”Select * From Products where ProductID=@ProductID”

UpdateCommand=”Update Products Set ProductName=@ProductName,

CategoryID=@CategoryID,

UnitPrice=@UnitPrice,

DistributorName=@DistributorName

where ProductID=@ProductID”

DeleteCommand=”Delete From Products where ProductID=@ProductID”

InsertCommand=”Insert Into Products (ProductName, CategoryID, UnitPrice,

In this section I’ll implement a server control named MasterDetailControl4 that derives from the

MasterDetailControl2 and overrides its SelectedValue property Recall that the MasterDetailControl2

inherits this property from the BaseMasterDetailControl MasterDetailControl4 overrides this property

to use the ASP.NET Session object as the backing store Recall that the BaseMasterDetailControl’s

imple-mentation of this property uses the ViewState as the backing store In the next section we’ll implement a

cus-tom data control field that will demonstrate the significance of using the ASP.NET Session object as the

backing store Listing 20-7 presents the implementation of MasterDetailControl4

Listing 20-7: The MasterDetailControls4 Server Control

get { return this.Page.Session[“SelectedValue”]; }

set { this.Page.Session[“SelectedValue”] = value; }

}

}

Developing Par tial-Rendering-Enabled

Data Control F ields

The foreign and primary key pairs establish relationships among database tables The value of a foreign key field in a given record is one of the existing values of its corresponding primary key field Most database tables automatically generate the primary key value of a record when the record is added to the table Therefore the actual foreign key value is an auto-generated integer that doesn’t mean anything to end users However, the table that contains the primary key field normally contains other field values that are more meaningful to them

For instance, consider a database that contains tables named Products and Categories The Products table has a foreign key field named CategoryID The Categories table contains the corresponding

Figure 20-4

CategoryDescription , which provide more meaningful information to end users Wouldn’t it be great

if you could provide end users the appropriate user interface with which to view more meaningful

information about the available categories, so they can make more intelligent decisions as to which

cate-gory to choose for a given record? This is exactly what you’re going to do in this section You’ll

imple-ment a custom data control field named MasterDetailField that will present the end users with a user

interface that consists of a DropDownList master server control and a DetailsView detail server control,

so users can view more detailed information about a given foreign key field The MasterDetailField

will take advantage of the ASP.NET AJAX partial rendering infrastructure to retrieve the required data

from the server asynchronously and to update only the necessary part of the page — that is, the detail

server control — without forcing a complete page reload

As you’ll see, the MasterDetailField data control field not only displays detailed information about a

selected foreign key field value but also enables the end user to update this information In other words,

the end user gets to update the records of both the table that contains the primay key field values and the

table that contains the associated foreign key field values, simultaneously

Extending BoundField

Most standard data control fields internally use server controls to display the values of their respective

database fields For example, the ImageField and CheckBoxField data control fields internally use

Image and CheckBox server controls, respectively, to display their field values The data type of the field

and the state of its containing row determine the type of server control used to display the value of the

field For instance, an ImageField data control field uses an Image server control to display its field

value when its containing row is in the normal state, and a TextBox server control when its containing

row is in the Edit or Insert state

The MasterDetailField custom data control field will use a MasterDetailControl4 server control

to display all the legal values of its field when its containing row is in the Edit or Insert state The

MasterDetailField data control field will display the current value of its field as simple text when its

containing row isn’t in the Edit or Insert state The MasterDetailField data control field derives from

the BoundField data control field because BoundField provides all the necessary base functionality

when the containing row isn’t in the Edit or Insert state, such as:

❑ Extracting the current value of the field whose name is the value of the DataField property

The MasterDetailField overrides this property and defines a new property named

DataTextField to replace it because DataTextField is a more appropriate name than

DataField

❑ Displaying the current value as simple text if the current value isn’t null

❑ Displaying the value of the NullDisplayText property if the current value is null

❑ Displaying the value of the HeaderText property as simple text if sorting is disabled and as a

hyperlink if sorting is enabled

❑ Raising the sort event when sorting is enabled and the header hyperlink is clicked

The main shortcoming of the BoundField data control field is that it displays the current value of the

field in a TextBox control when the containing row is in the Edit or Insert state The TextBox control is

not the appropriate server control for editing foreign key fields because it enables users to enter any

value instead of restricting values to the legal ones The MasterDetailField data control field

over-rides the InitializeDataCell , OnDataBindField , and ExtractValuesFromCell methods of the

BoundField data control field to add the support needed when the containing row is in the Edit or Insert state Listing 20-8 shows all the properties and methods of the MasterDetailField data control field In the following sections I’ll walk you through the implementation of these properties and methods

Listing 20-8: The MasterDetailField Data Control Field

namespace CustomComponents{

}

set { throw new global::System.NotImplementedException();

} }

public virtual string DataTextField {

get { return base.DataField;

} set { base.DataField = value;

} }

public virtual string MasterSkinID {

get { return (ViewState[“MasterSkinID”] != null) ? (string)ViewState[“MasterSkinID”] : String.Empty; }

(continued)

set { ViewState[“DataValueField”] = value;

} }

public virtual string MasterDataSourceID {

get { return (ViewState[“MasterDataSourceID”] != null) ? (string)ViewState[“MasterDataSourceID”] : String.Empty;

} set { ViewState[“MasterDataSourceID”] = value;

} }

public virtual string DetailDataSourceID {

get { return (ViewState[“DetailDataSourceID”] != null) ? (string)ViewState[“DetailDataSourceID”] : String.Empty; }

set { ViewState[“DetailDataSourceID”] = value;

} }

protected override void OnDataBindField(Object sender, EventArgs e) {

DropDownList ddl = sender as DropDownList;

if (ddl == null) {

base.OnDataBindField(sender, e);

return;

}

Control parent = ddl.Parent;

DataControlFieldCell cell = null;

while (parent != null) {

cell = parent as DataControlFieldCell;

if (cell != null) break;

parent = parent.Parent;

}

(continued)

Listing 20-8 (continued)

IDataItemContainer container = (IDataItemContainer)cell.Parent;

object dataItem = container.DataItem;

if (dataItem == null || String.IsNullOrEmpty(DataValueField))

if ((rowState & DataControlRowState.Edit) != 0 ||

(rowState & DataControlRowState.Insert) != 0)

throw new InvalidOperationException(

“MasterDetailField could not extract control.”);

string dataValueField = ((DropDownList)mdc.Master).SelectedValue;

if (dictionary.Contains(DataValueField)) dictionary[DataValueField] = int.Parse(dataValueField);

else dictionary.Add(DataValueField, int.Parse(dataValueField));

} } }}

Overriding InitializeDataCell

The BoundField data control field exposes a method named InitializeDataCell that contains the code that generates the appropriate HTML markup text for the data cell The InitializeDataCell method takes two arguments The first argument is the DataControlFieldCell cell being initialized The second argument is the state of the containing row

What HTML markup text the BoundField class’s implementation of the InitializeDataCell method emits depends on the state of its containing row If the containing row is not in the Edit or Insert state, the method simply registers the OnDataBindField method as the callback for the DataBinding event

of the respective DataControlFieldCell instance When the DataBinding event of the cell is raised, the OnDataBindField method extracts the current value of the respective field (the name of the field

is the value of the DataField property) If the current value is null , the value of the NullDisplayText property is displayed Otherwise the current value is displayed as simple text

The BoundField class’s implementation of the InitializeDataCell method in normal state is exactly what you need However, the BoundField class’s implementation of the method when the containing row

is in the Edit or Insert state is not acceptable, because the method instantiates an instance of the TextBox control You need an implementation that instantiates an instance of the MasterDetailControl4 control That is why the MasterDetailField data control field overrides the InitializeDataCell method The

MasterDetailField data control field calls the base version of the InitializeDataCell method when the containing row is in the normal state, because the behavior of the base version is exactly what you need However, the MasterDetailField data control field provides its own implementation when the containing row is in the Edit or Insert state

As Listing 20-8 shows, the MasterDetailField data control field’s implementation of the

InitializeDataCell method instantiates an instance of the MasterDetailControl4 control and sets its MasterDataSourceID and DetailDataSourceID properties to the values of the

MasterDataSourceID and DetailDataSourceID properties of the MasterDetailField data control field, respectively It is the responsibility of page developers to set the MasterDataSourceID and

DetailDataSourceID properties of the MasterDetailField data control field to the values of the ID properties of the appropriate data source controls in the containing page Page developers must also set the DataTextField and DataValueField properties of the MasterDetailField data control field to the names of the appropriate database fields This allows the MasterDetailField data control field to automatically populate its MasterDetailControl4 control with the valid values of the foreign key field Note that InitializeDataCell method also sets the DataKeyNames property of the MasterDetailControl4 control to the value of the DataKeyNames property of the

MasterDetailField Again, it’s the responsibility of page developers to assign the comma-separated

list of primary key field names to the DataKeyNames property of the MasterDetailField :

MasterDetailControl4 mdc = new MasterDetailControl4();

One of the requirements for the MasterDetailField data control field is that it has to set the selected

value of the MasterDetailControl4 control to the current value of the respective foreign key field

This is done in a callback registered for the DataBound event of the DropDownList master server control

of the MasterDetailControl4 control The DropDownList control inherits the DataBound event

from the BaseDataBoundControl class There is a difference between the DataBound event that the

BaseDataBoundControl class exposes and the DataBinding event that the Control class exposes:

the DataBinding event is raised before the data is actually bound, while the DataBound event is raised

after the data binding process finishes

Since the selected value of the MasterDetailControl4 control must be set after the control is bound to

its data source, it is set within the callback for the DataBound event The InitializeDataCell method

registers the OnDataBindField method as the callback for the DataBound event of the DropDownList

master server control:

if (DataTextField.Length != 0 && DataValueField.Length != 0)

((DropDownList)mdc.Master).DataBound += new EventHandler(OnDataBindField);

Handling the DataBound Event

When the DataBinding event of the cell is raised, the OnDataBindField method is called to

display the current value in display mode — that is, as a simple text When the DataBound event of

the DropDownList master server control of the MasterDetailControl4 control is raised, the

OnDataBindField method is called to display the current value in edit mode — that is, as the selected

item of the MasterDetailControl4 control

Before the OnDataBindField method can display the current value in the edit or insert mode, it has to

extract the value The OnDataBindField method uses the parent control of the cell to access the value:

Control parent = ddl.Parent;

DataControlFieldCell cell = null;

while (parent != null)