一起谈.NET技术，asp.net控件开发基础(17)

　　本篇将开始介绍如自定义数据绑定控件,这里感谢很多人的支持,有你们的支持很高兴。这里首先需要大家熟悉asp.net模板控件的使用,还有自定义模板控件.因为数据绑定控件多是基于模板控件的.

　　一.回顾

　　如果你使用过asp.net内置的数据控件(如DataList,Repeater),你一定会这么做

　　1.设置数据源 DataSource属性

　　2.调用数据绑定  DataBind方法

　　3.在控件的不同模板内使用绑定语法显示数据

　　这三步应该是必须要做的

　　其他更多的

　　你可能需要对绑定的数据进行统一的一些操作(如时间格式化),或者对数据的某一项进行操作(对某一项进行格式化),或者需要触发模板控件内的一些事件(如databound事件)。

　　根据上面的一些需求,我们需要这样做

　　1.对绑定的数据进行统一的一些操作: 为数据绑定控件定义Item项(表示列表的一条数据, 如Repeater的RepeaterItem)

　　2.对数据的某一项进行操作: 因为定义了Item项,那你肯定需要一个ItemCollection集合,其可以方便的为你检索数据

　　3.因为定义了RepeaterItem,原先的EventArgs和CommandEventArgs已经无法满足需求,我们需要自定义委托及其一个为控件提供数据的的ItemEventArgs

　　上面三点有些并非必须定义,如第2点,还需要根据具体需求来定.但一个完成的控件是需要的。

　　二.为数据控件做好准备

　　这次的demo为不完整的Datalist控件,来源还是MSDN的例子,我们命名为TemplatedList,此控件未定义ItemCollection集合，好了,根据上面的分析我们先为TemplatedList提供项和委托及为事件提供数据的几个EventArgs,请看下面类图

　　1.TemplatedListCommandEventArgs为Command事件提供数据

　　2.TemplatedListItemEventArgs为一般项提供数据

　　3.TemplatedListItem表示TemplatedList的项

　　三.编写TemplatedList

　　1.TemplatedList主要功能简介

　　提供一个ItemTemplate模板属性,提供三种不同项样式,ItemCommand 事件冒泡事件及4个事件

　　2.实现主要步骤

　　以下为必须

　　(1)控件必须实现 System.Web.UI.INamingContainer 接口

　　(2)定义至少一个模板属性

　　(3)定义DataSource数据源属性

　　(4)定义控件项DataItem,即模板的一个容器

　　(5)重写DataBind 方法及复合控件相关方法(模板控件为特殊的复合控件)

　　当然还有其他额外的属性,样式,事件

　　3.具体实现

　　下面我们来具体看实现方法

　　(1)定义控件成员属性



#region 静态变量


private static readonly object EventSelectedIndexChanged = new object();
private static readonly object EventItemCreated = new object();
private static readonly object EventItemDataBound = new object();
private static readonly object EventItemCommand = new object();
#endregion


#region 成员变量
private IEnumerable dataSource;
private TableItemStyle itemStyle;
private TableItemStyle alternatingItemStyle;
private TableItemStyle selectedItemStyle;
private ITemplate itemTemplate;
#endregion


#region 控件属性


[
        Category("Style"),
        Description("交替项样式"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        ]
public virtual TableItemStyle AlternatingItemStyle
        {
get
            {
if (alternatingItemStyle == null)
                {
                    alternatingItemStyle = new TableItemStyle();
if (IsTrackingViewState)
                        ((IStateManager)alternatingItemStyle).TrackViewState();
                }
return alternatingItemStyle;
            }
        }


[
        Category("Style"),
        Description("一般项样式"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        ]
public virtual TableItemStyle ItemStyle
        {
get
            {
if (itemStyle == null)
                {
                    itemStyle = new TableItemStyle();
if (IsTrackingViewState)
                        ((IStateManager)itemStyle).TrackViewState();
                }
return itemStyle;
            }
        }


[
         Category("Style"),
         Description("选中项样式"),
         DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
         NotifyParentProperty(true),
         PersistenceMode(PersistenceMode.InnerProperty),
         ]
public virtual TableItemStyle SelectedItemStyle
        {
get
            {
if (selectedItemStyle == null)
                {
                    selectedItemStyle = new TableItemStyle();
if (IsTrackingViewState)
                        ((IStateManager)selectedItemStyle).TrackViewState();
                }
return selectedItemStyle;
            }
        }


[
        Bindable(true),
        Category("Appearance"),
        DefaultValue(-1),
        Description("The cell padding of the rendered table.")
        ]
public virtual int CellPadding
        {
get
            {
if (ControlStyleCreated == false)
                {
return -1;
                }
return ((TableStyle)ControlStyle).CellPadding;
            }
set
            {
                ((TableStyle)ControlStyle).CellPadding = value;
            }
        }


[
        Bindable(true),
        Category("Appearance"),
        DefaultValue(0),
        Description("The cell spacing of the rendered table.")
        ]
public virtual int CellSpacing
        {
get
            {
if (ControlStyleCreated == false)
                {
return 0;
                }
return ((TableStyle)ControlStyle).CellSpacing;
            }
set
            {
                ((TableStyle)ControlStyle).CellSpacing = value;
            }
        }


[
        Bindable(true),
        Category("Appearance"),
        DefaultValue(GridLines.None),
        Description("The grid lines to be shown in the rendered table.")
        ]
public virtual GridLines GridLines
        {
get
            {
if (ControlStyleCreated == false)
                {
return GridLines.None;
                }
return ((TableStyle)ControlStyle).GridLines;
            }
set
            {
                ((TableStyle)ControlStyle).GridLines = value;
            }
        }


[
        Bindable(true),
        Category("Data"),
        DefaultValue(null),
        Description("数据源"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
public IEnumerable DataSource
        {
get
            {
return dataSource;
            }
set
            {
                dataSource = value;
            }
        }


[
        Browsable(false),
        DefaultValue(null),
        Description("项模板"),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(TemplatedListItem))
        ]
public virtual ITemplate ItemTemplate
        {
get
            {
return itemTemplate;
            }
set
            {
                itemTemplate = value;
            }
        }


[
        Bindable(true),
        DefaultValue(-1),
        Description("选中项索引,默认为-1")
        ]
public virtual int SelectedIndex
        {
get
            {
object o = ViewState["SelectedIndex"];
if (o != null)
return (int)o;
return -1;
            }
set
            {
if (value < -1)
                {
throw new ArgumentOutOfRangeException();
                }
//获取上次选中项
                int oldSelectedIndex = SelectedIndex;
                ViewState["SelectedIndex"] = value;


if (HasControls())
                {
                    Table table = (Table)Controls[0];
                    TemplatedListItem item;


//第一次选中项不执行
                    if ((oldSelectedIndex != -1) && (table.Rows.Count > oldSelectedIndex))
                    {
                        item = (TemplatedListItem)table.Rows[oldSelectedIndex];
//判断项类型,为了将选中项还原为数据项
                        if (item.ItemType != ListItemType.EditItem)
                        {
                            ListItemType itemType = ListItemType.Item;
if (oldSelectedIndex % 2 != 0)
                                itemType = ListItemType.AlternatingItem;
                            item.SetItemType(itemType);
                        }
                    }
//第一次执行此项,并一直执行
                    if ((value != -1) && (table.Rows.Count > value))
                    {
                        item = (TemplatedListItem)table.Rows[value];
                        item.SetItemType(ListItemType.SelectedItem);
                    }
                }
            }
        }


#endregion


成员如下(可以看上面类图)


　　1.三个项样式和三个样式属性


　　2.公开DataSource数据源属性,一个模板属性


　　3.SelectedIndex索引属性


　　前面的相信大家都很容易明白,其中的三个项样式我们需要为其重写视图状态管理,不熟悉可以看以前的随笔,这里不再重复。SelectedIndex属性比较复杂,这里重点介绍此属性


　　SelectedIndex索引属性默认为-1,我给出了注释,在赋值前先记录下了上次的选中项,为恢复样式而做准备 


                //获取上次选中项
                int oldSelectedIndex = SelectedIndex;
                ViewState["SelectedIndex"] = value;


当第一次更改SelectedIndex属性时只执行下列代码(将此项标记为选中项),因为初始化时的没有oldSelectedIndex,不需要恢复样式


//第一次执行此项,并一直执行
                    if ((value != -1) && (table.Rows.Count > value))
                    {
                        item = (TemplatedListItem)table.Rows[value];
                        item.SetItemType(ListItemType.SelectedItem);
                    }



再次执行时,恢复oldSelectedIndex选中项样式






//第一次选中项不执行
                    if ((oldSelectedIndex != -1) && (table.Rows.Count > oldSelectedIndex))
                    {
                        item = (TemplatedListItem)table.Rows[oldSelectedIndex];
//判断项类型,为了将选中项还原为数据项
                        if (item.ItemType != ListItemType.EditItem)
                        {
                            ListItemType itemType = ListItemType.Item;
if (oldSelectedIndex % 2 != 0)
                                itemType = ListItemType.AlternatingItem;
                            item.SetItemType(itemType);
                        }
                    }


 


相信这样的解释你会明白


 


　　(2)定义控件成员事件


　　我们可以用上刚才我们声明的委托了,即然你定义了这么多事件,就该为其安排触发的先后.所以这个要特别注意,等下会再次提到.






#region 事件
protected virtual void OnItemCommand(TemplatedListCommandEventArgs e)
        {
            TemplatedListCommandEventHandler onItemCommandHandler = (TemplatedListCommandEventHandler)Events[EventItemCommand];
if (onItemCommandHandler != null) onItemCommandHandler(this, e);
        }


protected virtual void OnItemCreated(TemplatedListItemEventArgs e)
        {
            TemplatedListItemEventHandler onItemCreatedHandler = (TemplatedListItemEventHandler)Events[EventItemCreated];
if (onItemCreatedHandler != null) onItemCreatedHandler(this, e);
        }


protected virtual void OnItemDataBound(TemplatedListItemEventArgs e)
        {
            TemplatedListItemEventHandler onItemDataBoundHandler = (TemplatedListItemEventHandler)Events[EventItemDataBound];
if (onItemDataBoundHandler != null) onItemDataBoundHandler(this, e);
        }


protected virtual void OnSelectedIndexChanged(EventArgs e)
        {
            EventHandler handler = (EventHandler)Events[EventSelectedIndexChanged];
if (handler != null) handler(this, e);
        }


[
        Category("Action"),
        Description("Raised when a CommandEvent occurs within an item.")
        ]
public event TemplatedListCommandEventHandler ItemCommand
        {
            add
            {
                Events.AddHandler(EventItemCommand, value);
            }
            remove
            {
                Events.RemoveHandler(EventItemCommand, value);
            }
        }


[
        Category("Behavior"),
        Description("Raised when an item is created and is ready for customization.")
        ]
public event TemplatedListItemEventHandler ItemCreated
        {
            add
            {
                Events.AddHandler(EventItemCreated, value);
            }
            remove
            {
                Events.RemoveHandler(EventItemCreated, value);
            }
        }


[
        Category("Behavior"),
        Description("Raised when an item is data-bound.")
        ]
public event TemplatedListItemEventHandler ItemDataBound
        {
            add
            {
                Events.AddHandler(EventItemDataBound, value);
            }
            remove
            {
                Events.RemoveHandler(EventItemDataBound, value);
            }
        }


[
        Category("Action"),
        Description("Raised when the SelectedIndex property has changed.")
        ]
public event EventHandler SelectedIndexChanged
        {
            add
            {
                Events.AddHandler(EventSelectedIndexChanged, value);
            }
            remove
            {
                Events.RemoveHandler(EventSelectedIndexChanged, value);
            }
        }
#endregion


　　(3)关键实现


　　我们为控件提供了这么多东西,剩下的事情就是要真正去实现功能了


　　1.重写DataBind方法


　　当控件绑定数据时首先会执行此方法触发DataBinding事件


        //控件执行绑定时执行
        public override void DataBind()
        {

            base.OnDataBinding(EventArgs.Empty);

            //移除控件
            Controls.Clear();
            //清除视图状态信息
            ClearChildViewState();

            //创建一个带或不带指定数据源的控件层次结构
            CreateControlHierarchy(true);
            ChildControlsCreated = true;

            TrackViewState();
        }


　　2.CreateControlHierarchy方法






/// <summary>
/// 创建一个带或不带指定数据源的控件层次结构
/// </summary>
/// <param name="useDataSource">指示是否要使用指定的数据源</param>
        //注意：当第二次执行数据绑定时，会执行两遍
        private void CreateControlHierarchy(bool useDataSource)
        {
            IEnumerable dataSource = null;
int count = -1;


if (useDataSource == false)
            {
// ViewState must have a non-null value for ItemCount because this is checked 
//  by CreateChildControls.
                count = (int)ViewState["ItemCount"];
if (count != -1)
                {
                    dataSource = new DummyDataSource(count);
                }
            }
else
            {
                dataSource = this.dataSource;
            }


//根据项类型开始创建子控件
            if (dataSource != null)
            {
                Table table = new Table();
                Controls.Add(table);


//选中项索引
                int selectedItemIndex = SelectedIndex;
//项索引
                int index = 0;
//项数量
                count = 0;
foreach (object dataItem in dataSource)
                {


ListItemType itemType = ListItemType.Item;
if (index == selectedItemIndex)
                    {


itemType = ListItemType.SelectedItem;
                    }
else if (index % 2 != 0)
                    {
                        itemType = ListItemType.AlternatingItem;
                    }


//根据不同项索引创建样式
                    CreateItem(table, index, itemType, useDataSource, dataItem);
                    count++;
                    index++;
                }
            }
//执行绑定时执行时执行
            if (useDataSource)
            {
//保存项数量
                ViewState["ItemCount"] = ((dataSource != null) ? count : -1);
            }
        }
//创建项
        private TemplatedListItem CreateItem(Table table, int itemIndex, ListItemType itemType, bool dataBind, object dataItem)
        {
            TemplatedListItem item = new TemplatedListItem(itemIndex, itemType);
            TemplatedListItemEventArgs e = new TemplatedListItemEventArgs(item);


if (itemTemplate != null)
            {
                itemTemplate.InstantiateIn(item.Cells[0]);
            }
if (dataBind)
            {
                item.DataItem = dataItem;
            }
//注意事件触发顺序
            OnItemCreated(e);
            table.Rows.Add(item);


if (dataBind)
            {
                item.DataBind();
                OnItemDataBound(e);


item.DataItem = null;
            }


return item;
        }


　　CreateItem方法辅助用于创建项模板,此处注意事件触发顺序,上面已经提到过。此方法根据项索引创建控件中不同的Item项 ,ViewState["ItemCount"]表示项的数量,第一次触发时或者重新执行DataBind方法时方法参数为true,并在初始化以后(回发期间)CreateChildControls方法会调用此方法,其参数为false。数据源不再是实际的数据源,而是新定义的DummyDataSource,其主要实现了一个迭代






internal sealed class DummyDataSource : ICollection
    {
private int dataItemCount;


public DummyDataSource(int dataItemCount)
        {
this.dataItemCount = dataItemCount;
        }


public int Count
        {
get
            {
return dataItemCount;
            }
        }


public bool IsReadOnly
        {
get
            {
return false;
            }
        }


public bool IsSynchronized
        {
get
            {
return false;
            }
        }


public object SyncRoot
        {
get
            {
return this;
            }
        }
public void CopyTo(Array array, int index)
        {
for (IEnumerator e = this.GetEnumerator(); e.MoveNext(); )
                array.SetValue(e.Current, index++);
        }


public IEnumerator GetEnumerator()
        {
return new DummyDataSourceEnumerator(dataItemCount);
        }


private class DummyDataSourceEnumerator : IEnumerator
        {


private int count;
private int index;


public DummyDataSourceEnumerator(int count)
            {
this.count = count;
this.index = -1;
            }


public object Current
            {
get
                {
return null;
                }
            }


public bool MoveNext()
            {
                index++;
return index < count;
            }


public void Reset()
            {
this.index = -1;
            }
        }
    }


　　原因很明显,为了减少对数据源的访问,所以我们平时操作数据的时候,必须重新执行DataBind方法,原因就在此。好了,到了这里差不多主要的事情我们已经完成.接着把剩下的也完成


　　3.呈现


　　又到了Render方法这里了，此方法体只要执行了PrepareControlHierarchy方法,不同的方法做不同的事情,CreateControlHierarchy方法根据索引值指定了不同的项,PrepareControlHierarchy则为不同项呈现不同的样式效果






//为不同类型项加载样式
        private void PrepareControlHierarchy()
        {
if (HasControls() == false)
            {
return;
            }


Debug.Assert(Controls[0] is Table);
            Table table = (Table)Controls[0];


table.CopyBaseAttributes(this);
if (ControlStyleCreated)
            {
                table.ApplyStyle(ControlStyle);
            }


// The composite alternating item style; do just one
// merge style on the actual item.
            Style altItemStyle = null;
if (alternatingItemStyle != null)
            {
                altItemStyle = new TableItemStyle();
                altItemStyle.CopyFrom(itemStyle);
                altItemStyle.CopyFrom(alternatingItemStyle);
            }
else
            {
                altItemStyle = itemStyle;
            }


int rowCount = table.Rows.Count;
for (int i = 0; i < rowCount; i++)
            {
                TemplatedListItem item = (TemplatedListItem)table.Rows[i];
                Style compositeStyle = null;
//根据不同项加载不同样式
                switch (item.ItemType)
                {
case ListItemType.Item:
                        compositeStyle = itemStyle;
break;


case ListItemType.AlternatingItem:
                        compositeStyle = altItemStyle;
break;


case ListItemType.SelectedItem:
                        {
                            compositeStyle = new TableItemStyle();


if (item.ItemIndex % 2 != 0)
                                compositeStyle.CopyFrom(altItemStyle);
else
                                compositeStyle.CopyFrom(itemStyle);
                            compositeStyle.CopyFrom(selectedItemStyle);
                        }
break;
                }


if (compositeStyle != null)
                {
                    item.MergeStyle(compositeStyle);
                }
            }
        }


//控件呈现
        protected override void Render(HtmlTextWriter writer)
        {
// Apply styles to the control hierarchy
// and then render it out.


// Apply styles during render phase, so the user can change styles
// after calling DataBind without the property changes ending
// up in view state.
            PrepareControlHierarchy();


RenderContents(writer);
        }


　　终于差不多了,经过这么多步骤,我们终于完成了,让我们来使用控件,看一下效果
　　又完成一个并不完美的控件,本来还该继续下去的,怕篇幅太大,到这里还没结束,只是刚开始,下次我们继续


上一篇：asp.net控件开发基础(16)


下一篇：asp.net控件开发基础(18)
				


				
时间： 2024-10-23 07:43:28

		
		


		


	

	
	

		


		
一起谈.NET技术，asp.net控件开发基础(17)的相关文章


								

		

			

                ASP.NET控件开发基础(17)
			

		

		

									

				本篇将开始介绍如自定义数据绑定控件,这里感谢很多人的支持,有你们的支持很高兴. 这里首先需要大家熟悉asp.net模板控件的使用,还有自定义模板控件.因为数据绑定控件多是基于模板控件的. 一.回顾 如果你使用过asp.net内置的数据控件(如DataList,Repeater),你一定会这么做 1.设置数据源 DataSource属性 2.调用数据绑定 DataBind方法 3.在控件的不同模板内使用绑定语法显示数据 这三步应该是必须要做的 其他更多的 你可能需要对绑定的数据进行统一的一些操作(			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(18)
			

		

		

									

				本篇继续上篇的讨论,可能大家已经在使用asp.net2.0了,DataSource属性不再使用,而是跟数据源控件搭配使用.现在讨论的绑定技术都是基于1.1版本,先熟悉一下,本质上是一样的,这样一步步的学习.对以后绝对有帮助.因为当你使用数据源控件,只需要设置一个DataSourceID,方便的同时你是否知道数据源控件帮你做了什么事情,如果你想觉的够用了,可以不用了解,但我相信你一定会有需求.上篇最后说过了,讨论还刚刚开始,我们大致把核心的方法都写出来了.下面我们继续. 一.控件对比 我们可以使用			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(16)
			

		

		

									

				这次我们继续讨论.主题是模板控件,模板控件将是复杂控件的起步 1.asp.net内置的模板控件,了解模板控件 如下图,以下为asp.net内置的模板控件 上图的控件一方面是模板控件,另一方面又是数据绑定控件.这里我们暂且不讨论如何实现数据绑定.使用上面控件的话,应该熟悉控件存在着不同的模板,如下图Repeater控件的模板类型. 在不同模板内你可以定义控件显示内容会呈现不同效果.典型的运用就是GridView,其呈现代码会是一个表格代码,而Repeater则是自定义的.其实其是内部已经实现了的,			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(15)
			

		

		

									

				继续我们的话题吧.自定义控件.如果你还不熟悉自定义控件开发的话,还请看看我以前写了几篇,希望对你有帮助 1.1何处继承 自定义控件一般从以下几个基类(此处不包含数据控件) 一.Control类(所有服务器控件的基类,算是比较底层的类,如果控件功能比较简单,要求不多,可直接继承此类.) 二.WebControl类(标准控件的基类,继承此类,你可以继承其丰富的公共属性,若标准控件中的控件没有你需要的控件,你可以继承此类) 三.CompositeControl 类(2.0新增的类,此类继承自WebCo			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(13)
			

		

		

									

				1.减轻服务器压力,增加用户体验 服务器功能是强大的,客户端脚本一点也不弱,现在的ajax技术和Atlas技术就是最好的证明,我们总是期待UI有一个好的效果,flash动画给我们带来了很酷的效果,我们至少也可以为我们的服务器控件添加客户端脚本,一方面减少了服务器端的回传,一方面又能为控件提供非常酷的效果.我想我们都很喜欢ATLAS里面很多很酷的控件吧,而且无刷新,服务器控件与客户端脚本交互使用,那会服务器控件变的更加完美. 经过上面的废话,下面我们进入正题 2.简单为服务器控件添加客户端脚本 我			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(8)
			

		

		

									

				有一些复合控件直接把按钮触发事件所需的事情封装好,另外一种则是自定义事件,更具灵活性,当然这是根据需要设计的.以下会以例子来说明的.下面我们假设我们控件中有两个按钮.以下不列出所有代码,具体可在文章最后下载代码. (1) 直接实现按钮事件 在控件中(以下代码并非实现复合控件)直接实现事件则无需自定义事件,如下代码(如果对数据回传有些不熟悉的话,可先看第三篇,希望对你有帮助) 示例一(只列出局部代码,具体可在文章最后下载代码) void IPostBackEventHandler.RaisePos			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(2)
			

		

		

									

				或许大家还对为何要重写Render方法存有疑惑,希望大家看看我举的例子,能够明白Render方法和其他两个方法的作用,然后真正明白为何一般情况下只须重写Render方法.我们知道我们每次编写控件时,都需要重写Render方法,我们发现在Control类中很多方法可以重写,但我们没有去重写他们,我们需要遵循一个原则,在需要重载的时候再去重写他们 我们还是先来看看与Render方法相关的两个方法 //RenderControl方法的基本实现 public void RenderControl(Htm			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(22)
			

		

		

									

				上两篇讨论了如何定义结合数据源控件的数据绑定控件.这次我们一起来看下数据源控件是如何实现的.asp.net2.0已经为我们提供了很多数据源控件,相信大家都用过了,也希望大家对其有所熟悉.关于它能做什么就不说了.下面我们也一起来看看,如何简单的实现. 一.你必须了解的 1.关于数据源控件(DataSourceControl) 虽然表面看来,给数据绑定控件指定DataSourceID属性,数据源控件帮你做了一切工作,其实不然,数据源控件只负责收集与数据交互的相关信息,如:SqlDataSource的			

		

	

				

		

			

                一起谈.NET技术，asp.net控件开发基础(10)
			

		

		

									

				集合属性相信大家都很熟悉也很常用,如DropDownList,ListBox等控件 <asp:DropDownList ID="DropDownList1" runat="server">            <asp:ListItem>测试1</asp:ListItem>            <asp:ListItem>测试2</asp:ListItem>            <asp:Lis