不过，这里我们既然是要解析callback的实现机制，那还是让我们从一个callback调用的客户端脚本调用开始，看看，微软是怎么实现这个callback机制的。

1、ClientScript.GetCallbackEventReference(...)

要激发一个callback，首先，当然需要在客户端本中发出一个调用。一个典型的调用语法如下：

<script language="javascript" type="text/javascript">
function any_script_function(arg, context)
{
    <%= ClientScript.GetCallbackEventReference(this, "arg", "ReceiveServerData", "context")%>;    
}
</script>
ClientScript.GetCallbackEventReference(...)将根据传入的参数返回实际的回调脚本。这个函数有多个重载版本，因此，这些参数的含义，大家可以参考MSDN。以具体的上面这段示例代码中的参数来说：

- this表示执行回调的的服务端控件是当前这个Page，当前的Page必须实现ICallbackEventHandler接口，包括必须实现string GetCallbackResult()和void RaiseCallbackEvent(eventArgument)这两个接口函数，这个参数也可以是指向某个WEB控件的引用，当然，这个空间也必须实现ICallbackEventHandler接口；

- "arg"是将被传给RaiseCallbackEvent的参数eventArgument的值，可以使人以自定义格式的字符串；

- "ReceiveServerData"是当回调成功之后，处理返回内容的客户端脚本函数的名称，这个函数必须存在于执行回调的页面，并且这个函数可以包含两个参数，例如：

<script type="text/javascript">
    function ReceiveServerData(result, context)
    {
         
    }
</script>
这两个参数，分别是回调的返回数据result，和原封不动被返回的我们激发回调时的这个context参数，当然，这两个参数都是字符串类型的。

- "context"就不用多解释了，记得这个参数会被原封不动的传给指定的返回数据处理函数就行了。MSDN的官方文档说，context一般可用来传递需要在客户端的返回数据处理函数中用来调用的脚本代码，不过实际上，你传什么都可以，把它看成一种从客户端回调的的激发端，到处理返回数据的接收段之间的参数传递通道就行了。

2、WebForm_DoCallback(...)

Ok，明白了以上代码的含义，下面我们来看看，前面的这条“<%= ClientScript.GetCallbackEventReference(this, "arg", "ReceiveServerData", "context")%>;”在运行时会被解析成什么样子呢？我们只要在页面运行时察看页面源码就可以看到，实际上服务器帮我们生成了下面这段script代码：

<script language="javascript" type="text/javascript">
function any_script_function()
{
    WebForm_DoCallback('__Page',arg,ReceiveServerData,context,null,false);    
}
</script>
这段代码是什么意思呢？很显然的他调用了一个系统与定义的script函数：WebForm_DoCallback。我们要把这个函数找出来看看它具体为我们干了什么。在运行时的页面源码中，我们很容易可以找到这段脚本的出处。我们注意到有一个script，src="/TestCallbackWeb/WebResource.axd?d=HEcYmh-7_szSIu1D_mHSEw2&amp;t=632661779991718750"，这里就定义了WebForm_DoCallback。让我们把它用flashget下载下来，将扩展名改为.js。看看源码吧，没有被混淆的，所以很容易看明白。我这里就只把和callback相关的部分贴出来解释一下，见代码中的注释：

//用于存放所有未完成的callback对象的数组__pendingCallbacks
var __pendingCallbacks = new Array();
var __synchronousCallBackIndex = -1;

//回调主函数WebForm_DoCallback
function WebForm_DoCallback(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync) {

    //构造回调参数，回调参数包括了原来页面上的formpostdata和我们传递的目标控件、eventArgument和部分验证信息
    var postData = __theFormPostData +
                "__CALLBACKID=" + WebForm_EncodeCallback(eventTarget) +
                "&__CALLBACKPARAM=" + WebForm_EncodeCallback(eventArgument);
    if (theForm["__EVENTVALIDATION"]) {
        postData += "&__EVENTVALIDATION=" + WebForm_EncodeCallback(theForm["__EVENTVALIDATION"].value);
    }
  
   //下面实例化XMLHTTP对象，如果浏览器支持XMLHTTP则直接用XMLHTTP执行异步回调
    var xmlRequest,e;
    try {
        xmlRequest = new XMLHttpRequest();
    }
    catch(e) {
        try {
            xmlRequest = new ActiveXObject("Microsoft.XMLHTTP");
        }
        catch(e) {
        }
    }
    var setRequestHeaderMethodExists = true;
    try {
        setRequestHeaderMethodExists = (xmlRequest && xmlRequest.setRequestHeader);
    }
    catch(e) {}
    var callback = new Object();
    callback.eventCallback = eventCallback;
    callback.context = context;
    callback.errorCallback = errorCallback;
    callback.async = useAsync;
   
   //获取对应的回调对象
    var callbackIndex = WebForm_FillFirstAvailableSlot(__pendingCallbacks, callback);
    if (!useAsync) {
        if (__synchronousCallBackIndex != -1) {
            __pendingCallbacks[__synchronousCallBackIndex] = null;
        }
        __synchronousCallBackIndex = callbackIndex;
    }
    if (setRequestHeaderMethodExists) {
        xmlRequest.onreadystatechange = WebForm_CallbackComplete;
        callback.xmlRequest = xmlRequest;
        xmlRequest.open("POST", theForm.action, true);
        xmlRequest.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
        xmlRequest.send(postData);
        return;
    }
  
   //万一浏览器不支持XMLHTTP的话，我们IFRAME方案代替，在一个隐藏的IFRAME中执行Postback  
    callback.xmlRequest = new Object();
    var callbackFrameID = "__CALLBACKFRAME" + callbackIndex;
    var xmlRequestFrame = document.frames[callbackFrameID];
    if (!xmlRequestFrame) {
        xmlRequestFrame = document.createElement("IFRAME");
        xmlRequestFrame.width = "1";
        xmlRequestFrame.height = "1";
        xmlRequestFrame.frameBorder = "0";
        xmlRequestFrame.id = callbackFrameID;
        xmlRequestFrame.name = callbackFrameID;
        xmlRequestFrame.style.position = "absolute";
        xmlRequestFrame.style.top = "-100px"
        xmlRequestFrame.style.left = "-100px";
        try {
            if (callBackFrameUrl) {
                xmlRequestFrame.src = callBackFrameUrl;
            }
        }
        catch(e) {}
        document.body.appendChild(xmlRequestFrame);
    }
    var interval = window.setInterval(function() {
        xmlRequestFrame = document.frames[callbackFrameID];
        if (xmlRequestFrame && xmlRequestFrame.document) {
            window.clearInterval(interval);
            xmlRequestFrame.document.write("");
            xmlRequestFrame.document.close();
            xmlRequestFrame.document.write('<html><body><form method="post"><input type="hidden" name="__CALLBACKLOADSCRIPT" value="t"></form></body></html>');
            xmlRequestFrame.document.close();
            xmlRequestFrame.document.forms[0].action = theForm.action;
            var count = __theFormPostCollection.length;
            var element;
            for (var i = 0; i < count; i++) {
                element = __theFormPostCollection[i];
                if (element) {
                    var fieldElement = xmlRequestFrame.document.createElement("INPUT");
                    fieldElement.type = "hidden";
                    fieldElement.name = element.name;
                    fieldElement.value = element.value;
                    xmlRequestFrame.document.forms[0].appendChild(fieldElement);
                }
            }
            var callbackIdFieldElement = xmlRequestFrame.document.createElement("INPUT");
            callbackIdFieldElement.type = "hidden";
            callbackIdFieldElement.name = "__CALLBACKID";
            callbackIdFieldElement.value = eventTarget;
            xmlRequestFrame.document.forms[0].appendChild(callbackIdFieldElement);
            var callbackParamFieldElement = xmlRequestFrame.document.createElement("INPUT");
            callbackParamFieldElement.type = "hidden";
            callbackParamFieldElement.name = "__CALLBACKPARAM";
            callbackParamFieldElement.value = eventArgument;
            xmlRequestFrame.document.forms[0].appendChild(callbackParamFieldElement);
            if (theForm["__EVENTVALIDATION"]) {
                var callbackValidationFieldElement = xmlRequestFrame.document.createElement("INPUT");
                callbackValidationFieldElement.type = "hidden";
                callbackValidationFieldElement.name = "__EVENTVALIDATION";
                callbackValidationFieldElement.value = theForm["__EVENTVALIDATION"].value;
                xmlRequestFrame.document.forms[0].appendChild(callbackValidationFieldElement);
            }
            var callbackIndexFieldElement = xmlRequestFrame.document.createElement("INPUT");
            callbackIndexFieldElement.type = "hidden";
            callbackIndexFieldElement.name = "__CALLBACKINDEX";
            callbackIndexFieldElement.value = callbackIndex;
            xmlRequestFrame.document.forms[0].appendChild(callbackIndexFieldElement);
            xmlRequestFrame.document.forms[0].submit();
        }
    }, 10);
}

//该函数在每次回调结束后会调用来检查当前的回调列表中的回调的执行情况，如果，执行完毕的，则从列表中删除回调对象，并删除临时建立的IFRAME
function WebForm_CallbackComplete() {
    for (i = 0; i < __pendingCallbacks.length; i++) {
        callbackObject = __pendingCallbacks[i];
        if (callbackObject && callbackObject.xmlRequest && (callbackObject.xmlRequest.readyState == 4)) {
            WebForm_ExecuteCallback(callbackObject);
            if (!__pendingCallbacks[i].async) {
                __synchronousCallBackIndex = -1;
            }
            __pendingCallbacks[i] = null;
            var callbackFrameID = "__CALLBACKFRAME" + i;
            var xmlRequestFrame = document.getElementById(callbackFrameID);
            if (xmlRequestFrame) {
                xmlRequestFrame.parentNode.removeChild(xmlRequestFrame);
            }
        }
    }
}

//该函数执行我们在回调激发端指定的处理返回数据的script函数，如我们上面范例代码中的ReceiveServerData函数
function WebForm_ExecuteCallback(callbackObject) {
    var response = callbackObject.xmlRequest.responseText;
    if (response.charAt(0) == "s") {
        if ((typeof(callbackObject.eventCallback) != "undefined") && (callbackObject.eventCallback != null)) {
            callbackObject.eventCallback(response.substring(1), callbackObject.context);
        }
    }
    else if (response.charAt(0) == "e") {
        if ((typeof(callbackObject.errorCallback) != "undefined") && (callbackObject.errorCallback != null)) {
            callbackObject.errorCallback(response.substring(1), callbackObject.context);
        }
    }
    else {
        var separatorIndex = response.indexOf("|");
        if (separatorIndex != -1) {
            var validationFieldLength = parseInt(response.substring(0, separatorIndex));
            if (!isNaN(validationFieldLength)) {
                var validationField = response.substring(separatorIndex + 1, separatorIndex + validationFieldLength + 1);
                if (validationField != "") {
                    var validationFieldElement = theForm["__EVENTVALIDATION"];
                    if (!validationFieldElement) {
                        validationFieldElement = document.createElement("INPUT");
                        validationFieldElement.type = "hidden";
                        validationFieldElement.name = "__EVENTVALIDATION";
                        theForm.appendChild(validationFieldElement);
                    }
                    validationFieldElement.value = validationField;
                }
                if ((typeof(callbackObject.eventCallback) != "undefined") && (callbackObject.eventCallback != null)) {
                    callbackObject.eventCallback(response.substring(separatorIndex + validationFieldLength + 1), callbackObject.context);
                }
            }
        }
    }
}

//获取对应的回调对象
function WebForm_FillFirstAvailableSlot(array, element) {
    var i;
    for (i = 0; i < array.length; i++) {
        if (!array[i]) break;
    }
    array[i] = element;
    return i;
}

//再下面是一些辅助函数和与callback关系不大的函数，我就不列出来了，有兴趣的朋友可以自己看看
//
从以上代码我们可以很明白的看到，系统判断您的浏览器是否支持XMLHTTP或IFRAME，如果至少支持其中之一，则用相应的方法执行回调，否则当然就是提示错误了。回调的时候，采用post的方式，异步post到当前页面，然后等待回调结束，此时，由我们指定的返回数据处理script函数来处理返回的数据。

看到这里，我还不知道服务端怎么处理这个根据传过来的参数解析、执行，并返回数据的过程。但是，我们已经知道，WebForm_DoCallback(...)将会将当前页面的web控件的信息都post回去，这就意味着，我们在服务端有可能可以访问到这些web控件的value，这还不错，方便了我们处理当前数据。另一方面，eventArgument既然是一个任意格式的字符串参数，我们肯定要在服务段自己解析它的。

Serverside Callback Operation & Render

好了，那么接下来就让我们来看看在服务端，ASP.NET都为我们做了些什么。

首先，我们知道，当前的Page是必须实现ICallbackEventHandler这个接口的，也就是其包含的两个函数：string GetCallbackResult()和void RaiseCallbackEvent(eventArgument)。根据MSDN的文档，我们知道，在一个callback被post到服务端时，Page将会首先将post回来的form data绑定到当前页面的服务端web控件，接着判断本次post是callback还是postback，如果是postpost，那么自然是原来的那个机制；

如果是callback，则将回调用触发本次callback的控件（在本例中，我们在激发这个callback时，第一个参数指定的是this也就是当前的Page，那么这里当前的Page就是这个触发控件）的RaiseCallbackEvent(eventArgument)，当然，eventArgument也将会正确的传过来，在这个函数的实现代码里我们可以对这个参数进行解析处理，并在某个地方，存储我们准备返回的数据，或者待处理的已经被解析出来的参数；

接着，系统将调用string GetCallbackResult()，在这个函数的实现代码中，我们可以直接返回我们在RaiseCallback函数中存储的准备返回的数据，或者根据待处理的已经被解析出来的参数处理这些参数，并返回结果。这个返回的字符串，自然将以脚本的形式被render回客户端。被返回的脚本细节如下(反编译Page.RenderCallback()的源码)，我们可以看到，返回的结果除了我们需要的结果数据和相应的脚本，没有多余的数据，因此，callback的执行效率应该说还是不错的：

private void RenderCallback()
{
      bool flag1 = !string.IsNullOrEmpty(this._requestValueCollection["__CALLBACKLOADSCRIPT"]);
      try
      {
            string text1 = null;
            if (flag1)
            {
                  text1 = this._requestValueCollection["__CALLBACKINDEX"];
                  if (string.IsNullOrEmpty(text1))
                  {
                        throw new HttpException(SR.GetString("Page_CallBackInvalid"));
                  }
                  for (int num1 = 0; num1 < text1.Length; num1++)
                  {
                        if (!char.IsDigit(text1, num1))
                        {
                              throw new HttpException(SR.GetString("Page_CallBackInvalid"));
                        }
                  }
                  this.Response.Write("<script>parent.__pendingCallbacks[");
                  this.Response.Write(text1);
                  this.Response.Write("].xmlRequest.responseText=\"");
            }
            if (this._callbackControl != null)
            {
                  string text2 = this._callbackControl.GetCallbackResult();
                  if (this.EnableEventValidation)
                  {
                        string text3 = this.ClientScript.GetEventValidationFieldValue();
                        this.Response.Write(text3.Length.ToString(CultureInfo.InvariantCulture));
                        this.Response.Write('|');
                        this.Response.Write(text3);
                  }
                  else
                  {
                        this.Response.Write('s');
                  }
                  this.Response.Write(flag1 ? Util.QuoteJScriptString(text2) : text2);
            }
            if (flag1)
            {
                  this.Response.Write("\";parent.__pendingCallbacks[");
                  this.Response.Write(text1);
                  this.Response.Write("].xmlRequest.readyState=4;parent.WebForm_CallbackComplete();</script>");
            }
      }
      catch (Exception exception1)
      {
            this.Response.Clear();
            this.Response.Write('e');
            if (this.Context.IsCustomErrorEnabled)
            {
                  this.Response.Write(SR.GetString("Page_CallBackError"));
                  return;
            }
            this.Response.Write(flag1 ? Util.QuoteJScriptString(HttpUtility.HtmlEncode(exception1.Message)) : HttpUtility.HtmlEncode(exception1.Message));
      }
}
另外，才发现原来System.Web.UI.Utils这个类中有那么多有用的方便的函数如QuateJScriptString()，以前一直自己手写这样功能的函数呢~~真傻呀~~

Conclusion

至此，我们已经基本上清楚明白callback的前台幕后了。如果您对服务段的处理过程的细节还觉得不够，您也可以自行反编译Page对象，看看其实现代码的细节，还是很有意思的。

总体而言，我们发现，callback无论是兼容性（XMLHTTP或IFRAME我想大多数浏览器都支持吧），还是性能（没有返回不需要的数据），还是使用的便利性（因为ASP.NET帮我们绑定了页面上的当前的Web控件的数据，这就意味着我们可以在callback后的服务端，象postback时一样来写代码，也方便我们移植原来的postback的代码到callback方式的代码）都是非常优秀的。我们也完全可以扩展现有的控件，或者写我们自己的控件以支持这样的callback效果，并且，混合使用callback控件和原来的postback方式的控件也是非常可靠和容易的。这对我们升级原来的基于postback为主的代码，是非常有利的，如果用Atlas来做同样的代码升级和与postback方式的控件混合使用，我可以跟您说，会有很多问题。不信你自己可以试试~~

本文来自CSDN博客，出处：http://blog.csdn.net/lyangsha/archive/2006/12/09/1435820.aspx

ID 表示控件的服务器端编程的标识符，我们写"服务器端的代码"，就要用到这个 ID, 通过这个 ID 可以在服务器端对服务器端控件的属性、方法和时间进行编程访问。（可写）

ClientID 表示由服务器端生成的客户端控件的ID,"经常用于在客户端脚本中访问服务器控件所呈现的 HTML 元素"。一般情况下与服务器端的 ID 相同，有时，不能为控件生成唯一的名称，例如，如果Repeater 空间在它的某个模板中包含一个 Label 控件，则将在客户端生成多个该 Lable 的 HTML 元素, 为防止命名冲突，ASP.NET 为各个服务器控件生成一个唯一的 ClientID ,ClientID 通过将子控件的父控件的 UniqueID 值与控件的 ID 值连接生成，各个部分之间以下划线 _ 连接。（只读）

UniqueID 用于获取服务器控件的唯一的、以分层方式表示的标识符。当将控件放置到重复控件（Repeater、DataList和DataGrid）中时，将可能生成多个服务器端的控件，这就需要区分服务器端的各个控件，以使它们的 ID 属性不冲突。UniqueID 通过将子控件的父控件的 UniqueID 值与控件的 ID 值连接生成，各个部分之间以IdSeparator 属性指定的字符连接。默认情况下， IdSeparator 属性为冒号字符 (:)。此属性为在 .Net Framework2.0种新增加。js与aps.net交互一般情况下使用<%=控件ID.ClientID%>就OK了,但如果用到母版页(MasterPage)则要使用UniqueID获得获值。（只读）

例如，创建以下 ASP.NET 服务器控件：

<asp:textbox id="TextBox1" runat="server" text="Sample Text" />

ClientID 属性被设置为 TextBox1，在基于 HTML 的浏览器中，其结果元素与以下所示类似：

<input name="TextBox1" type="text" value="Sample Text" id="Text1" />

可以使用这些属性在客户端脚本中引用服务器控件。通常，必须在客户端脚本中用完全限定引用来引用控件；如果控件是页面中 form 元素的子控件，则一般使用document.forms[0].TextBox1.value = "New value"在客户端脚本中引用控件。

有些控件将子控件呈现在页面中。这些控件中包括数据列表控件（如GridView、DetailsView、FormView、DataList 和 Repeater 控件）、用户控件和 Web 部件控件。可以看到，在这些情况下，子控件可能不具有唯一的 ID，这可能是因为子控件是在某个模板中定义的，该模板会为每个数据行（数据列表控件）生成新的控件实例，也可能是因为可以从外部源（用户控件和 Web 部件控件）将父控件添加到页面中对于每个子控件：控件的 UniqueID 被呈现为 name。控件的 ClientID 被呈现为 id 属性。

ClientID 和 UniqueID 属性都基于原始的 ID 属性，并用足够的信息进行了修改，以保证页面中结果的唯一性。ClientID的值可在客户端脚本中引用。如果在浏览器中显示一个具有命名容器的页面，则可以查看该页面的源文件，从中找到唯一的 ID，这些 ID 作为命名容器子控件的 name 属性和 id 属性生成。但是，建议不要依赖于直接引用在浏览器中看到的 ID。因为用于生成子控件唯一ID 的公式可能会发生变化，应当获取子控件的 ClientID 属性值，并用该值来引用该子控件。例如，您可能会在页面中动态创建客户端脚本。如果客户端脚本引用一个子控件，则应获取该子控件的 ClientID 属性，并将其嵌入到动态脚本中。

例2：

假设有子控件：

<asp:TextBox ID = "textboxInfo" runat ="server" Text = "Test Text box" name="haha"></asp:TextBox>

那么我们可以在脚本中这样写

var tempt = '<%=textboxInfo.ClientID%>';

var controlname = document.getElementById(tempt).name;

var controlid = document.getElementById(tempt).id;

　　还有一个问题我们需要注意：在使用UniqueID和ClientID的时候要小心点，千万不要“迫不及待”地使用了这些属性，在运行的过程中可能会碰到一些让人头疼的问题.

注意
除了用来分隔 ID 值的是下划线字符而不是 IdSeparator 属性指定的字符以外，为控件生成的 ClientID 值与 UniqueID 值相同。默认情况下，IdSeparator 属性设置为冒号字符 (:)。由于 ClientID 值不包含冒号字符，因此，它可以用于不支持包含冒号的 ID 的 ECMAScript。ClientID 值经常用于以编程方式访问为客户端脚本中的控件呈现的 HTML 元素。有关详细信息，请参见 ASP.NET 网页中的客户端脚本。

总结：
ID，用于server端编程引用控件，没有对应的client值，即不呈现到html中。

UniqueID，
asp.net引擎按控件树层次生成的分层形式限定的标志符，连接符默认为 $ （美元符号）【注：MSDN说默认为 : （冒号），实际是 $ ，可能文档有误吧】，此连接符在asp.net 2.0 中由属性 IdSeparator 指定，在client中呈现为html元素的name属性
此属性主要用来提交（PostBack）客户端数据，如Request.Form[someControl.UnqiueID]

ClientID，
由父控件的UnqiueID连接本身ID而成，但是连接符不一样，默认为   _ （下划线），此连接符在asp.net 2.0 中由属性 ClientIDSeparator 指定，在client中呈现为html元素的id属性，此属性主要在客户端教本中使用，如 var o = document.getElementById('<% = someControl.ClientID %>');

关于 UniqueID的层次分隔符号，1.x 中为 :（冒号），而 2.0 已实现为 $（美元符），主要原因可能是 javascript 中标识符是允许 $，而不允许 : 的。（当你偷懒的时候，可以在 js 中直接使用表单元素的 name属性应用该表单元素，而不用 document.getElementsByName 或者 document.getElementById，不推荐:)

ASP.NET 使用的回发机制（简单版本）是通过一个原型为 __doPostBack(<ControlUniqueID>, <CommandArgs>) 的 javascript 函数

function __doPostBack(eventTarget, eventArgument) {
    if (!theForm.onsubmit || (theForm.onsubmit() != false)) {
         theForm.__EVENTTARGET.value = eventTarget;
         theForm.__EVENTARGUMENT.value = eventArgument;
         theForm.submit();
     }
}
此函数的第一个参数 <ControlUniqueID> 对应引起页面回发控件的客户端 name 属性/服务端 UniqueID 属性，当用户引发一个事件，如点击按钮，选择列表框的某一项，首先通过 _doPostBack 函数将此值存在隐藏域中，然后提交页面。
在服务器端，ASP.NET 引擎通过 HttpRequest.HttpMethod 确定请求是否为 post 方式，若是，则检索HttpRequest.Request.Form["__EVENTTARGET']， 获取引发回发的控件唯一标识符，并在页面控件集合层次中查找，若找到此控件，则将在适当阶段引发服务器端事件。

另补充控件变化规律如下:

控件名字发生变化是因为 INamingContainer这个接口。这个接口没有任何方法，仅只作为一个标记。ASP.NET维护控件name和id生成的规律是:NamingContainer爷爷$NamingContainer爸爸$该控件的ID。id则一般将$换为"_"。
你把控件直接放到form下，它头顶唯一一个NamingContainer是Page，但是这个是特殊的逻辑，不会生成__Page_控件名，所以就只剩控件名了，于是ID看起来没有变化。
当你把控件放到Repeater中时，Repeater自己被INamingContainer标记，同时，每一次循环，它会把模板内的控件重新生成一遍，同时生成一个RepeaterItem， 把这些根据模板生成的控件加入RepeaterItem的子控件。这个RepeaterItem也是一个NamingContainer. 于是控件中就会带有:
RepeaterID(Data)_RepeaterItemID(ctl + 号码)_控件ID.

不过非runat=server控件因为不由ASP.NET维护, 不会发生变化. UserControl.ascx由于其基类也是一个NamingContainer, 所以如果你把控件放入.ascx, 然后在页面上引用, 则前面又会多一层UserControl的ID.

通过controls集合访问服务器控件：

在VS2005中新建一个.aspx文件，打开HTML页会发现一个原先的声明从
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
变成了
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">!
很早以前就称的HTML的接班人XHTML，现在MS终于要将它扶正了..
这样在写HTML代码时就要注意了,
如:
<font>
    <div>
    </font>
    </div>
是无法在Vs2005中的Design模式中正确显示的[很明显的错误，但在HTML可以正常显示].. ,XHTML的语法比HTML严格的

多
而关于XHTML和HTML的区别，如果不是非常明白http://www.blueidea.com/tech/site/2004/1911.asp这个文章可以参考一下。

Form

Form新添加了几个功能比较有用的是defaultbutton、defaultfocus。从字面的意思大家就可以理解了以前在ASP.NET中让人头痛的默认提交表单按钮和设置焦点在ASP.NET 2.0已经提供了，不用象以前那样自己写javascript来控制了

关于焦点在也可以代码中通过 this.SetFocus()来设置了,看得出来ASP.NET2.0是设计是多么的细致。

Header
在代码中可能通过
this.Header.Metadata.Add("taye", "value");
this.Header.Title = "value";
this.Header.LinkedStyleSheets.Add("style.css");
来控制Title,Meta,Style等[好象LinkedStyleSheets只能是text/css???]
this.Header.StyleSheet.RegisterStyle()
方法将一个style内嵌到网页中去.

这样页面几乎所以部分都可以得到控制了

有些人也许会想那<html>和<body>呢
我们先来运行一下面这个代码.

   private void Page_Load(object sender, EventArgs e)
    {
        foreach (Control ctl in Page.Controls)
        {
            Response.Write(ctl.ToString() + "<BR/>");

            LiteralControl lc = ctl as LiteralControl;

            if (lc != null)
            {
                Response.Write(lc.Text);
            }
        }

    }

你将会看到一个正常页的有如下五个控件
System.Web.UI.LiteralControl
System.Web.UI.HtmlControls.HtmlHead
System.Web.UI.LiteralControl
System.Web.UI.HtmlControls.HtmlForm
System.Web.UI.LiteralControl

而三个LiteralControl的控件的内容分别为

System.Web.UI.LiteralControl
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >

System.Web.UI.LiteralControl
<body>
    
System.Web.UI.LiteralControl
</body>
</html>

所以如果你要对body或<!DOCTYPE..>或<html>进行控制那你就找到这相应的控件以后再进行相应的修改吧。只要对

LiteralControl.Text进行修改就可以.

--------------------------------------------------------------------------

从外部的js文件中获取ASPX页面的控件ClientID

前言

当使用MasterPage、UserControl等容器时，为了避免控件的重复命名，asp.net会自动将容器中的控件生成一个ClientID（Control Tree中的可生成，否则不会生成）。

例如：ContentPlaceHolder1中的Button1默认情况下会生“ctl00_ContentPlaceHolder1_Button1”的ClientID。我们在Render出来的mark up中看到的也是这些ClientID。所以，当我们使用JavaScript对控件元素进行操作的时候，必须使用ClientID来对控件进行查找。

Inline情况下的解决方案

如果JavaScript代码写在.aspx文件中时，也就是Inline Script时。在页面生成的时候，我们能够通过绑定机制将控件的ClientID绑定到页面Mark up中，故可使用：

-->document.getElementById("<%=Me.txtTest.ClientID %>" )
来获取一个控件的真实引用，当然，FindControl等方法也可以写在<%=...%>中用来绑定服务端数据到客户端。

external JS情况下的解决方案

然而，部分情况下，为了解耦，我们常常把JavaScript单独写在.js文件中，再引用到aspx文件中去。这种情况下，.js文件内的代码不能通过<%=...%>来进行服务端数据的绑定，所以上面的方法是不能用的。

此时简单点的解决方案就是直接在JavaScript中写控件的ClientID，但这样增加了JS文件和ASPX的耦合度，非常不推荐使用。

我常用的方法有两种，在此抛砖引玉：

案例：

Default5.aspx是MasterPage.master 的内容页，本例中的主要文件。

JScript.js是一个外部的js文件，用来处理JavaScript操作。

Button1是Default5.aspx中的一个<ASP:Button>，用来显示效果。

Button2是Default5.aspx中的一个<input type=button>，用来触发JavaScript。

需求：点击Button2，将Button1上的文本改成“from extended js”

方案一：使用内联JS访问器

要想在外部JS中获得ASPX动态生成的ClientID，可以通过在ASPX页面中添加访问器的方式来实现，类似OO语言中的属性：

我们在Default5.aspx中添加如下代码：作用：①声明getClientId访问器，并注册Button1的ClientID。②引用JScript.js文件

--><script type="text/javascript">
    function getClientId()
    {
     var paraId1 = '<%= Button1.ClientID %>';
     return {Id1:paraId1};
    }
</script>
<script type="text/javascript" src="JScript.js"></script>

接下来，我们在JScript.js中，就可以这样来实现需求：

-->function ChangeText()
{
    var btn=document.getElementById(getClientId().Id1);
    btn.value="from extended js";
}

getClientId().Id1 貌似很OO，而且还支持VS2008很蹩脚的JS智能提示，打上“.”之后就可以在提示中选择Id1了。

如果有多个控件需要注册，只需将他们注册到访问器中即可，下面是一个完整的Demo代码：

></script>//引用外部js
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="ContentPlaceHolder1" Runat="Server">
    <asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
    <asp:Button ID="Button1" runat="server" Text="Button" />
    <input id="Button2" type="button" value="button" onclick="ChangeText();" />
</asp:Content>

function ChangeText()
{
    var btn=document.getElementById(getClientId().Id1);
    btn.value="from extended js";
   
    var btn=document.getElementById(getClientId().Id2);
    btn.value="from extended js";
}

方案二：使用JS全局变量

还有一种方法也比较OO，就是使用JS全局变量，同样，也需要在Default5.aspx中添加一段JS代码，作为全局变量，来提供ClientID：

--><script type="text/javascript">

    var globals = {};
    globals.controlIdentities = {};
    globals.controlIdentities.someControl1 = '<%= Button1.ClientID %>';
    globals.controlIdentities.someControl2 = '<%= TextBox1.ClientID %>';
</script>
<script type="text/javascript" src="JScript.js"></script>

接下来，我们在JScript.js中，就可以这样来实现需求：

-->function ChangeText()

{
    var btn=document.getElementById(globals.controlIdentities.someControl1);
    btn.value="from extended js";
}

globals.controlIdentities.someControl1，同样，也支持VS2008很蹩脚的JS智能提示，打上“.”之后就可以在提示中选择someControl1了。下面是一个完整的Demo代码：

></script>
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="ContentPlaceHolder1" Runat="Server">
    <asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
    <asp:Button ID="Button1" runat="server" Text="Button" />
    <input id="Button2" type="button" value="button" onclick="ChangeText();" />
</asp:Content>

function ChangeText()
{
    var btn=document.getElementById(globals.controlIdentities.someControl1);
    btn.value="from extended js";
   
    var txt=document.getElementById(globals.controlIdentities.someControl2);
    btn.value="from extended js";
}

结束语：

在上面两种方法中，也没有真正的实现aspx和js的完全解耦，所以，在js文件中，最好还是加上：

-->///<reference path="Default5.aspx"/>
上面的方法是我常用的，今天仓促的总结了一下，希望在此能够抛砖引玉，谢谢！

--------------------------------------------------------------------------

ASP.Net中如何使用ClientID

ASP.Net 提供了代码和页面分离的机制，在大多数情况下，这种机制工作得非常好。但是，如果需要使用客户端java脚本来做些工作，你就会遇到麻烦了。问题出在你在设计阶段为server端控件设置的ID值和页面运行时控件实际的ID值不一致。例如，新建一个Web site,增加一个 aspx page,在页面上加入一个text box控件：

<asp:TextBox ID="mytext" Runat=server></asp:TextBox>   
运行这个页面，从View source中会看到运行时的结果：

<Input name="mytext" type="text" id="mytext" />
这时我们看到设计阶段的ID值和运行时控件的ID值是一样的，没有问题，这是因为这是一个单纯的aspx页面。如果在页面中包含一个用户自定义的web control或使用了master pages (ASP.NET 2.0)，情况就不乐观了。

我们增加一个新的user control名为mycontrol.ascx. 在mycontrol.ascx中加入同样的text box。再把这个自定义控件加入到一个aspx 页面， 将此控件的ID设置为myControl. 在浏览器中运行这个页面，得到的html是这样的：

<Input name="myControl:mytext" type="text" id="myControl_mytext" />
text box控件的设计阶段ID= mytext，但运行时得到的ID=myControl_mytext。也就是在原来的ID前面增加了包含text box控件的容器myControl的ID。在使用master pages时，所有的aspx 页面都是被包含在一个容器中的， 而且还常常会有容器的嵌套。如果在客户端使用JavaScript去按照ID查找控件就会失败。解决这个问题可以有多个方法。

最简单的：

<script language="javascript" type ="text/javascript>
        var x=<% Response.Write("'"+myControl.ClientId+"';" ) %>
        function doSomething()
        {
        Var myControl=document.getElementById(x);
        }
</script>

这种方法对于一个两个控件比较适用。不过由于必须在aspx页面中设置，不能将javascript集中起来管理了。

那么，有没有可以不进行硬编码的方法呢?本文提供了一种方法，可以使用ASP.Net现有技术实现，并且适合所有的ASP.Net framework版本。

解决方案
关键是创建一个不会被服务器端修改的客户端控件。在自定义控件上增加一个hidden input，将它设为literal server side control：

<input type=hidden id="ctrlPrefix" name="ctrlPrefix" value='<asp:Literal Runat=server ID=ctrlPrefix></asp:Literal>'>
还要注意，这个hidden input控件需要加入到控件容器里面。因为我们后面要用它来得到控件的ID。在后台代码中对Page_Load 事件加入如下处理：

string []elm =ctrlPrefix.ClientID.Split('_');          

ctrlPrefix.Text = ctrlPrefix.ClientID.Replace(elm[elm.Length - 1],"");   
我们得到控件的client id，包含了控件的ID加上控件容器的ID作为前缀。第二行代码将ctrlPrefix.ClientID的后面一段去掉，得到容器的ID前缀，返回值包含了_。编译后运行这个页面，结果如下：

<input name="myControl:mytext" type="text" id="myControl_mytext" /><input type=hidden id="ctrlPrefix" name="ctrlPrefix" value='myControl_'>
现在，hidden input中已经保存了容器的ID前缀。下面，我们用JavaScript来利用hidden input处理控件查找。

增加一个新的方法getCrtlPrefix()
//returns the container prefix as all controls have that on their ids

function getCrtlPrefix()
{
           var prefix;            
           var        objCrtlPrefix = document.getElementById("ctrlPrefix");

           if (objCrtlPrefix)

                 prefix = objCrtlPrefix.value;                

           return prefix;
}

这个方法得到hidden input的值并返回，这样我们就得到了ID的前缀。第二个方法用来查询空间

function readValue(ctrlName)
{      
var prefix = getCrtlPrefix();          
var        objCrtl = document.getElementById(prefix + ctrlName);
           if (objCrtl)                 alert ( "Prefix: " + prefix + " - value: " + objCrtl.value);
           else                 alert("not found!");
}
这个方法显示textbox控件的值。你会注意到，这里调用了getCtrlPrefix来计算textbox控件的ClientID。 我们可以增加一个按钮来调用这个方法：

<input type=button value="Read Value" onclick="javascript:readValue('mytext')">
这个html button会调用readValue。最后，把这个javascript的js文件加入aspx中。

<script language="JavaScript" src="mycontrol.js"></script>
运行这个页面，在text box中输入写数据，然后点击按钮，会出现一个消息对话框来显示ID前缀以及text box中的数据。

本文来自CSDN博客，出处：http://blog.csdn.net/jamestaosh/archive/2009/07/22/4370127.aspx

      很多非泛型集合类都有对应的泛型集合类，我觉得最好还是养成用泛型集合类的好习惯，他不但性能上好而且 功能上要比非泛型类更齐全。下面是常用的非泛型集合类以及对应的泛型集合类：

    

非泛型集合类	泛型集合类
ArrayList	List<T>
HashTable	DIctionary<T>
Queue	Queue<T>
Stack	Stack<T>
SortedList	SortedList<T>

            我们用的比较多的非泛型集合类主要有 ArrayList类 和 HashTable类，其中当我们经常性的操作 数据信息时往往用HashTable 来存储将要写入到数据库或者返回的信息，在这之间要不断的进行类型的转化，他给我们的帮助应该是非常大的，如果我们操纵的数据类型相对确定的化 用Dictionary<TKey,TValue>集合类来存储数据就方便多了，例如我们需要在电子商务网站中存储用户的购物车信息( 商品名，对应的商品个数)时，完全可以用Dictionary<string,int > 来存储购物车信息，而不需要任何的类型转化。

            下面是简单的例子，包括声明，填充键值对，移除键值对，遍历键值对

             Dictionary<string, string> myDic = new Dictionary<string, string>();

            myDic.Add("aaa", "111");

            myDic.Add("bbb", "222");

            myDic.Add("ccc", "333");

            myDic.Add("ddd", "444");

            //如果添加已经存在的键，add方法会抛出异常

            try

            {

                myDic.Add("ddd","ddd");

            }

            catch (ArgumentException ex)

            {

                Console.WriteLine("此键已经存在：" + ex.Message);

            }

            //解决add()异常的方法是用ContainsKey()方法来判断键是否存在

            if (!myDic.ContainsKey("ddd"))

            {

                myDic.Add("ddd", "ddd");

            }

            else

            {

                Console.WriteLine("此键已经存在：");

            }

            //而使用索引器来负值时，如果建已经存在，就会修改已有的键的键值，而不会抛出异常

            myDic ["ddd"]="ddd";

            myDic["eee"] = "555";

            //使用索引器来取值时，如果键不存在就会引发异常

            try

            {

                Console.WriteLine("不存在的键\"fff\"的键值为：" + myDic["fff"]);

            }

            catch (KeyNotFoundException ex)

            {

                Console.WriteLine("没有找到键引发异常：" + ex.Message);

            }

            //解决上面的异常的方法是使用ContarnsKey() 来判断时候存在键，如果经常要取健值得化最好用 TryGetValue方法来获取集合中的对应键值

            string value = "";

            if (myDic.TryGetValue("fff", out value))

            {

                Console.WriteLine("不存在的键\"fff\"的键值为：" + value );

            }

            else

            {

                Console.WriteLine("没有找到对应键的键值");

            }

            //下面用foreach 来遍历键值对

            //泛型结构体 用来存储健值对

            foreach (KeyValuePair<string, string> kvp in myDic)

            {

                Console.WriteLine("key={0},value={1}", kvp.Key, kvp.Value);

            }

            //获取值得集合

            foreach (string s in myDic.Values)

            {

                Console.WriteLine("value={0}", s);

            }

            //获取值得另一种方式

            Dictionary<string, string>.ValueCollection values = myDic.Values;

            foreach (string s in values)

            {

                Console.WriteLine("value={0}", s);

            }

          //获取键的集合和获取值得集合类似

      常用的属性和方法如下：

	常用属性	属性说明
	Comparer	获取用于确定字典中的键是否相等的 IEqualityComparer。
	Count	获取包含在 Dictionary 中的键/值对的数目。
	Item	获取或设置与指定的键相关联的值。
	Keys	获取包含 Dictionary 中的键的集合。
	Values	获取包含 Dictionary 中的值的集合。
	常用的方法	方法说明
	Add	将指定的键和值添加到字典中。
	Clear	从 Dictionary 中移除所有的键和值。
	ContainsKey	确定 Dictionary 是否包含指定的键。
	ContainsValue	确定 Dictionary 是否包含特定值。
	Equals	已重载。 确定两个 Object 实例是否相等。 （从 Object 继承。）
	GetEnumerator	返回循环访问 Dictionary 的枚举数。
	GetHashCode	用作特定类型的哈希函数。GetHashCode 适合在哈希算法和数据结构（如哈希表）中使用。 （从 Object 继承。）
	GetObjectData	实现 System.Runtime.Serialization.ISerializable 接口，并返回序列化 Dictionary 实例所需的数据。
	GetType	获取当前实例的 Type。 （从 Object 继承。）
	OnDeserialization	实现 System.Runtime.Serialization.ISerializable 接口，并在完成反序列化之后引发反序列化事件。
	ReferenceEquals	确定指定的 Object 实例是否是相同的实例。 （从 Object 继承。）
	Remove	从 Dictionary 中移除所指定的键的值。
	ToString	返回表示当前 Object 的 String。 （从 Object 继承。）
	TryGetValue	获取与指定的键相关联的值。

systemroot\System32\Inetsrv\MBSchema.xml             存储配置文件的架构。架构定义了在某些配置数据库节点可设置哪些 IIS 属性。

systemroot\System32\Inetsrv\History\History File        存储由 IIS 自动创建的配置数据库历史文件。

systemroot\System32\Inetsrv\MetaBack\Backup File   存储通过使用“备份/还原配置”功能按需创建的配置数据库备份文件。

从历史文件还原配置数据库

当启用了历史功能时，IIS 会定期创建名为历史文件的备份文件。历史文件是配置数据库配置文件 (MetaBase.xml) 和与之匹配的配置数据库架构文件 (MBSchema.xml) 的副本。从历史文件还原配置数据库的过程类似于从备份文件还原配置数据库。
要点 您必须是本地计算机上 Administrators 组的成员或者必须被委派了相应的权限，才能执行下列步骤。作为安全性的最佳操作，请使用不属于 Administrators 组的帐户登录计算机，然后使用运行方式命令以管理员身份运行 IIS 管理器。在命令提示符下，键入 runas /user:administrative_accountname "mmc %systemroot%\system32\inetsrv\iis.msc"。
使用 IIS 管理器还原配置数据库

在 IIS 管理器中，右键单击本地计算机，指向“所有任务”，然后单击“备份/还原配置”。
在“备份”列表中，单击要还原的“自动备份”，然后单击“还原”。
如果要继续，请阅读出现的消息，然后单击“是”。
单击“确定”。
有时候可能需要在不使用 IIS 管理器的情况下还原配置数据库。例如，如果配置更改不当或者更改时出现了可扩展标记语言 (XML) 语法错误，且 IIS 管理器无法枚举配置数据库，请使用下列步骤还原配置数据库：
手动还原配置数据库
打开命令提示符窗口。从“开始”菜单，单击“运行”。
在“打开”框中，键入 cmd，然后单击“确定”。
停止 IIS 服务。在命令提示符处，键入 iisreset /stop，然后按 Enter。命令提示符窗口将显示下列内容：
正在尝试停止...
Internet 服务已成功停止
如果 IIS 服务不停止，且可能要重新启动计算机，请键入 iisreset /stop /rebootonerror，然后按 Enter。
创建当前配置数据库文件的副本。在命令提示符处，键入 cd systemroot\System32\Inetsrv，然后按 Enter 以找到配置数据库文件所在的文件夹。接下来，键入 copy MBSchema.xml MBSchema.old，然后按 Enter 以复制架构文件。最后，键入 copy MetaBase.xml Metabase.old，然后按 Enter 以复制配置数据库配置文件。
查找配置数据库历史文件。在命令提示符处，键入 cd systemroot\System32\Inetsrv\History，然后按 Enter。
选择所需的历史文件版本。在命令提示符处，键入 dir，然后按 Enter。所有的文件都按如下格式显示：
<date> <time>   <file size> MBSchema_<identifying number>_0000000000.xml
<date> <time>   <file size> MetaBase_<identifying number>_0000000000.xml

当将 IIS 配置数据库还原到早期版本时，您需要相匹配的配置数据库架构文件和配置数据库配置文件。通过文件的标识号来选择匹配文件。
将所选历史架构文件复制到现有的配置数据库架构中。在命令提示符处，键入 copy /y MBSchema_<identifying number>_0000000000.xml systemroot\System32\Inetsrv\MBSchema.xml，然后按 Enter。使用该命令，您可以在复制文件的同时对其重新命名。
将匹配的历史配置文件复制到现有的配置数据库配置中。在命令提示符处，键入 copy /y Metabase_<identifying number>_0000000000.xml systemroot\System32\Inetsrv\MetaBase.xml，然后按 Enter。同样，该命令复制文件并同时对其重新命名。
要点 如果您混淆了名称或复制了不匹配的架构和配置文件，当启动 IIS 服务时，配置数据库还原将失败。

重新启动 IIS。在命令提示符处，键入 iisreset /start，然后按 Enter。命令提示符处显示下列内容：
正在尝试启动...
Internet 服务已成功启动
如果 IIS 服务不重新启动，请从第 4 步开始重复上述步骤，然后将另一组历史文件复制到当前的配置数据库文件中。
从备份文件还原配置数据库
IIS 管理员可以使用 IIS 管理器或命令行管理脚本创建备份文件。备份文件是配置数据库配置文件 (MetaBase.xml) 和与之匹配的配置数据库架构文件 (MBSchema.xml) 的便携式副本。通过使用配置数据库配置的备份/还原功能，可以从备份文件还原配置数据库。

备份 IIS 配置数据库
使用配置的备份/还原功能，可创建 IIS 配置数据库的完整备份副本。配置数据库的备份文件提供一种在数据库被破坏时还原配置数据库配置和架构数据的方法。备份文件可还原到创建备份的计算机上，也可以还原到安装了 Windows Server 2003 家族的其他计算机上。

备份文件只包含配置数据；不包括内容。要同时备份内容，请使用 Windows 备份功能。详细信息，请参阅备份和还原数据。

注意 配置数据库在备份过程中处于锁定状态。

安全备份
当创建安全备份时，管理员提供一个 IIS 用来加密备份文件的密码。密码被加密并存储在备份文件的标头中。只加密备份文件中的管理员密码和安全属性；备份文件中的所有其他信息都是纯文本。在加密备份文件之后，不能更改备份文件中的密码。

不安全备份
当创建不安全的备份时，管理员不提供密码。因此，不安全的备份文件用空密码加密，Administrators 组的任何成员都能使用不安全的备份文件还原配置数据库。只加密空密码和安全属性；备份文件中的所有其他信息都是纯文本。

要点 您必须是本地计算机上 Administrators 组的成员或者必须被委派了相应的权限，才能执行下列步骤。作为安全性的最佳操作，请使用不属于 Administrators 组的帐户登录计算机，然后使用运行方式命令以管理员身份运行 IIS 管理器。在命令提示符下，键入 runas /user:administrative_accountname "mmc %systemroot%\system32\inetsrv\iis.msc"。

备份 IIS 配置数据库

在 IIS 管理器中，右键单击本地计算机，指向“所有任务”，然后单击“备份/还原配置”。
单击“创建备份”，然后在“配置备份名称”框中键入备份文件的名称。请注意，备份文件名是不区分大小写的。
可选：如果要创建安全备份，请选中“使用密码加密备份”复选框，在“密码”框中键入密码，然后在“确认密码”框中键入相同的密码。
单击“确定”。

在创建备份时，会创建两个采用如下格式命名的文件：
name.mdx
name.scx
其中 name 是管理员用来命名备份集的名称，x 是备份集的版本号，从 0（零）开始。版本号对于每个使用相同名称的备份集按 1 递增。例如，如果两次都使用 mybackup 名称作为备份集名称，则在第一次备份时创建的文件是 mybackup.md0 和 mybackup.sc0；在第二次备份时，文件名为 mybackup.md1 和 mybackup.sc1。在默认情况下，备份文件存储在 systemroot\System32\Inetsrv\MetaBack 文件夹中。

还原 IIS 配置数据库备份
可将配置数据库备份还原到创建备份的同一台计算机上，也可以还原到其他计算机上。因为配置数据库备份不包括内容文件，所以，如果要将配置数据库备份还原到其他服务器上，还必须复制内容文件。内容文件所在的位置和驱动器必须与原服务器相同。不支持从早期版本的 IIS 中还原备份。

要点 在将配置数据库从一台计算机还原到另一台计算机之前，必须首先从配置数据库文件中删除计算机特定的信息。有关该问题的重要信息，请参阅计算机和系统特定的信息和复制 IIS 配置。

还原 IIS 配置数据库备份

在 IIS 管理器中，右键单击本地计算机，指向“所有任务”，然后单击“备份/还原配置”。
在“备份”列表中，单击要还原的备份，然后单击“还原”。
注意 如果希望将 IIS 还原到初始配置，请还原由 IIS 安装程序自动创建的名为“初始备份”的备份。

如果要继续，请阅读出现的消息，然后单击“是”。
如果要还原安全备份，系统将提示您输入在创建备份时键入的密码。键入该密码，然后单击“确定”。请注意，密码是区分大小写的。
单击“确定”。

SSL 证书
如果在 Web 服务器上使用安全套节字层 (SSL) 证书，并将配置数据库备份还原到安装的其他操作系统上，则会在证书不可用或者未安装时产生错误。如果缺少站点的 SSL 证书，连接会断开，IIS 显示“页不可用”消息。服务器在事件日志中记录以下警告：“解决办法是在相同的证书存储位置重新安装证书并重新启动 IIS。在重新安装证书之后无法重新启动 IIS 会导致不断出现错误日志和断开连接。”

http://doc.51windows.net/iismmc/?url=/iismmc/htm/mb_sec_filelevel.htm

方法二：
把Form的KeyPreView设为true，然后在Form的KeyPress中增加下列代码：
       if (e.KeyChar == '\r')
       this.SelectNextControl(this.ActiveControl, true, true, true, true);

怎样使用通用网址？
★答：通用网址提供了四种访问方式：1、 中文网址：输入企业、产品的全称或简称即可直达目标，如输入"信诺立"，可以直接到达信诺立公司的网站； 2、 英文网址：输入"IBM"即可访问IBM的网站； 3、 拼音网址：输入拼音、拼音字头如"QJD"就可访问的全聚德集团的网站； 4、 数字网址：输入企业的电话号码、股票代码即可直达。

企业已经有了通用域名，还需要通用网址吗？
★答：通用网址是通用域名的伙伴，但两者处在不同层次。企业注册了通用网址后，通用域名将依然存在，并在后台存发挥作用。域名不是品牌正如通信地址不能代表一个企业的形象一样，拥有域名仅仅拥有了网上的地址，通用网址才是企业的网上招牌。通用网址在域名基础上发挥作用，又是更高效、更成熟的访问标准，是对域名的继承和发展。它可以帮助企业解决网络营销和产品推广的困难。---1、对于用户：通用网址更加方便实用； ---2、对于企业：通用网址保护了企业的品牌资源，锁定客户、带来商机； ---3、技术实现：通用网址可以支持智能查询，而域名输入必须精确； ---4、发展趋势：域名日趋繁复，不易记忆，功能有限。通用网址降低了网络的复杂性，是对域名体系的发展而不是否定。

本文来自CSDN博客，出处：http://blog.csdn.net/impeller/archive/2008/03/05/2152195.aspx

view plaincopy to clipboardprint?
using System;  
    using System.Collections.Generic;  
    using System.Text;  
    using System.Threading;  
      
    namespace StartThread  
    {  
        class MyThreadParameter  
        {  
            private int interval;  
            private int loopCount;  
            /// <summary>  
            /// 循环次数  
            /// </summary>  
            public int LoopCount  
            {  
                get { return loopCount; }  
            }  
          
            /// <summary>  
            /// 线程的暂停间隔  
            /// </summary>  
            public int Interval  
            {  
                get { return interval; }  
            }  
            /// <summary>  
            /// 构造函数  
            /// </summary>  
            /// <param name="interval">线程的暂停间隔</param>  
            /// <param name="loopCount">循环次数</param>  
            public MyThreadParameter(int interval,int loopCount)  
            {  
                this.interval = interval;  
                this.loopCount = loopCount;  
            }  
        }  
        class Program  
        {  
            int interval = 200;  
            static void Main(string[] args)  
            {  
                Program p = new Program();  
      
                Thread parameterThread = new Thread(new ParameterizedThreadStart(p.MyParameterRun));  
                parameterThread.Name = "Thread A:";  
                MyThreadParameter paramter = new MyThreadParameter(50, 20);  
                parameterThread.Start(paramter);  
            }  
       
      
            /// <summary>  
            /// 带多个参数的启动方法  
            /// </summary>  
            /// <param name="ms">方法参数</param>  
            public void MyParameterRun(object ms)  
            {  
                MyThreadParameter parameter = ms as MyThreadParameter;//类型转换  
                if (parameter != null)  
                {  
                    for (int i = 0; i < parameter.LoopCount; i++)  
                    {  
                        Console.WriteLine(Thread.CurrentThread.Name + "系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());  
                        Thread.Sleep(parameter.Interval);//让线程暂停  
                    }  
                }  
            }  
        }  
    }
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace StartThread
{
     class MyThreadParameter
     {
         private int interval;
         private int loopCount;
         /// <summary>
         /// 循环次数
         /// </summary>
         public int LoopCount
         {
             get { return loopCount; }
         }

         /// <summary>
         /// 线程的暂停间隔
         /// </summary>
         public int Interval
         {
             get { return interval; }
         }
      /// <summary>
      /// 构造函数
      /// </summary>
         /// <param name="interval">线程的暂停间隔</param>
         /// <param name="loopCount">循环次数</param>
         public MyThreadParameter(int interval,int loopCount)
         {
             this.interval = interval;
             this.loopCount = loopCount;
         }
     }
     class Program
     {
         int interval = 200;
         static void Main(string[] args)
         {
             Program p = new Program();

             Thread parameterThread = new Thread(new ParameterizedThreadStart(p.MyParameterRun));
             parameterThread.Name = "Thread A:";
             MyThreadParameter paramter = new MyThreadParameter(50, 20);
             parameterThread.Start(paramter);
         }


         /// <summary>
         /// 带多个参数的启动方法
         /// </summary>
         /// <param name="ms">方法参数</param>
         public void MyParameterRun(object ms)
         {
             MyThreadParameter parameter = ms as MyThreadParameter;//类型转换
             if (parameter != null)
             {
                 for (int i = 0; i < parameter.LoopCount; i++)
                 {
                     Console.WriteLine(Thread.CurrentThread.Name + "系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
                     Thread.Sleep(parameter.Interval);//让线程暂停
                 }
             }
         }
     }
}

第二种方法和上面方法有些相似，也是需要引入外部类，并且将Thread实例放在引入的类中，这种情况适合于在线程中处理的业务逻辑比较复杂的情况。在前不久处理的一个项目中我用过这种情况，它是用来实现双向数据传输的。
如果实现上面的效果，代码如下：

view plaincopy to clipboardprint?
using System;  
    using System.Collections.Generic;  
    using System.Text;  
    using System.Threading;  
      
    namespace StartThread  
    {  
        class MyThreadParameter  
        {  
            private int interval;  
            private int loopCount;  
            private Thread thread;  
              
        /// <summary>  
        /// 构造函数  
        /// </summary>  
            /// <param name="interval">线程的暂停间隔</param>  
            /// <param name="loopCount">循环次数</param>  
            public MyThreadParameter(int interval,int loopCount)  
            {  
                this.interval = interval;  
                this.loopCount = loopCount;  
                thread = new Thread(new ThreadStart(Run));  
            }  
      
            public void Start()  
            {  
                if (thread != null)  
                {  
                    thread.Start();  
                }  
            }  
      
            private void Run()  
            {  
                for (int i = 0; i < loopCount; i++)  
                {  
                    Console.WriteLine("系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());  
                    Thread.Sleep(interval);//让线程暂停  
                }  
            }  
        }  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                MyThreadParameter parameterThread = new MyThreadParameter(30, 50);  
                parameterThread.Start();  
            }  
      
        }  
    }
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace StartThread
{
     class MyThreadParameter
     {
         private int interval;
         private int loopCount;
         private Thread thread;
        
/// <summary>
/// 构造函数
/// </summary>
         /// <param name="interval">线程的暂停间隔</param>
         /// <param name="loopCount">循环次数</param>
         public MyThreadParameter(int interval,int loopCount)
         {
             this.interval = interval;
             this.loopCount = loopCount;
             thread = new Thread(new ThreadStart(Run));
         }

         public void Start()
         {
             if (thread != null)
             {
                 thread.Start();
             }
         }

         private void Run()
         {
             for (int i = 0; i < loopCount; i++)
             {
                 Console.WriteLine("系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
                 Thread.Sleep(interval);//让线程暂停
             }
         }
     }
     class Program
     {
         static void Main(string[] args)
         {
             MyThreadParameter parameterThread = new MyThreadParameter(30, 50);
             parameterThread.Start();
         }

     }
}

上面的代码的运行效果和前面的代码运行效果类似，只不过是将业务处理代码放在一个单独的类MyThreadParameter中，使得MyThreadParameter看起来也像一个Thread，实际上维护的还是其内部的Thread，在一些大型系统中这样做的好处是便于维护。

总结：在本篇主要讲述如何启动线程的问题，在启动时可能会遇到无需参数、需要多个参数的情况，在这里讲述了如何解决这些问题的思路。在.net类库中虽然存在着庞大的类库，但是并不是总会有合适的类来解决我们所遇到的问题，但是只要肯动脑筋总会想到合适的办法。

本文来自CSDN博客，出处：http://blog.csdn.net/zhoufoxcn/archive/2009/08/03/4402999.aspx

view plaincopy to clipboardprint?
using System;  
    using System.Collections.Generic;  
    using System.Text;  
    using System.Threading;  
      
    namespace StartThread  
    {  
        class Program  
        {  
            int interval = 200;  
            static void Main(string[] args)  
            {  
                Program p = new Program();  
                Thread nonParameterThread = new Thread(new ThreadStart(p.NonParameterRun));  
                nonParameterThread.Start();  
            }  
            /// <summary>  
            /// 不带参数的启动方法  
            /// </summary>  
            public void NonParameterRun()  
            {  
                for (int i = 0; i < 10; i++)  
                {  
                    Console.WriteLine("系统当前时间毫秒值："+DateTime.Now.Millisecond.ToString());  
                    Thread.Sleep(interval);//让线程暂停  
                }  
        }  
    }
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace StartThread
{
     class Program
     {
         int interval = 200;
         static void Main(string[] args)
         {
             Program p = new Program();
             Thread nonParameterThread = new Thread(new ThreadStart(p.NonParameterRun));
             nonParameterThread.Start();
         }
         /// <summary>
         /// 不带参数的启动方法
         /// </summary>
         public void NonParameterRun()
         {
             for (int i = 0; i < 10; i++)
             {
                 Console.WriteLine("系统当前时间毫秒值："+DateTime.Now.Millisecond.ToString());
                 Thread.Sleep(interval);//让线程暂停
             }
     }
}

程序的运行效果我们不用运行也会知道，那就是在循环中将系统当前时间的毫秒部分输出出来，在每次输出之后会将当前线程暂停一下，直到10次之后运行完毕，终止线程的执行。
在上面的代码中我们是通过定义全局变量的方法来指定线程暂停间隔，按照这种方法，假如要运行10个线程，每个线程的暂停间隔不一样的话，就需要定义10个全局变量，虽然最终不影响系统的运行效果，但是总觉得不是太爽。
有没有比较简单一点的办法呢？有！那就是使用带参数的启动方法。
带参数的启动方法
如果要在实例化线程时要带一些参数，就不能用ThreadStart委托作为构造函数的参数来实例化Thread了，而要ParameterizedThreadStart委托，和ThreadStart一样的是它也是线程启动时要执行的方法，和ThreadStart不同的是，它在实例化时可以用一个带有一个Object参数的方法作为构造函数的参数，而实例化ThreadStart时所用到的方法是没有参数的。
为什么是Object这样的参数呢？很简单，因为在.net中Object是所有类型的基类，用它可以表示Array(数组）、Interface（接口）、ValueType（值类型，如bool,byte,char,short,int,float,long,double等）、class(类）等.net中的类型。当然，这也意味着如果你要启动一个线程，给它传递一个int类型参数时，必须在启动方法中进行相应的类型转换。
下面就是一个例子，在启动线程时指定了线程的暂停间隔，代码如下：

view plaincopy to clipboardprint?
using System;  
    using System.Collections.Generic;  
    using System.Text;  
    using System.Threading;  
      
    namespace StartThread  
    {  
        class Program  
        {  
            int interval = 200;  
            static void Main(string[] args)  
            {  
                Program p = new Program();  
      
                Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));  
                parameterThread.Name = "Thread A:";  
                parameterThread.Start(30);  
            }  
         
            /// <summary>  
            /// 带参数的启动方法  
            /// </summary>  
            /// <param name="ms">让线程在运行过程中的休眠间隔</param>  
            public void ParameterRun(object ms)  
            {  
                int j = 10;  
                int.TryParse(ms.ToString(), out j);//这里采用了TryParse方法，避免不能转换时出现异常  
                for (int i = 0; i < 10; i++)  
                {  
                    Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());  
                    Thread.Sleep(j);//让线程暂停  
                }  
            }  
        }  
    }
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace StartThread
{
     class Program
     {
         int interval = 200;
         static void Main(string[] args)
         {
             Program p = new Program();

             Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));
             parameterThread.Name = "Thread A:";
             parameterThread.Start(30);
         }
   
         /// <summary>
         /// 带参数的启动方法
         /// </summary>
         /// <param name="ms">让线程在运行过程中的休眠间隔</param>
         public void ParameterRun(object ms)
         {
             int j = 10;
             int.TryParse(ms.ToString(), out j);//这里采用了TryParse方法，避免不能转换时出现异常
             for (int i = 0; i < 10; i++)
             {
                 Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
                 Thread.Sleep(j);//让线程暂停
             }
         }
     }
}

在这个方法里，我们在启动线程时顺便指定了线程的暂停间隔，也就是这句：
parameterThread.Start(30);
线程启动时运行的方法是public void ParameterRun(object ms)，这个值为30的int类型变量被装箱成object，所以在方法中还需要将它转换成int类型，这个可以通过拆箱或者其它办法解决。
假如我们要启动两个线程，每个线程的暂停间隔不一样，启动代码如下：

view plaincopy to clipboardprint?
using System;  
    using System.Collections.Generic;  
    using System.Text;  
    using System.Threading;  
      
    namespace StartThread  
    {  
        class Program  
        {  
            int interval = 200;  
            static void Main(string[] args)  
            {  
                Program p = new Program();  
      
                Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));  
                parameterThread.Name = "Thread A:";  
                parameterThread.Start(30);  
                //启动第二个线程  
                parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));  
                parameterThread.Name = "Thread B:";  
                parameterThread.Start(60);  
            }  
         
            /// <summary>  
            /// 带参数的启动方法  
            /// </summary>  
            /// <param name="ms">让线程在运行过程中的休眠间隔</param>  
            public void ParameterRun(object ms)  
            {  
                int j = 10;  
                int.TryParse(ms.ToString(), out j);//这里采用了TryParse方法，避免不能转换时出现异常  
                for (int i = 0; i < 10; i++)  
                {  
                    Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());  
                    Thread.Sleep(j);//让线程暂停  
                }  
            }  
        }  
    }
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace StartThread
{
     class Program
     {
         int interval = 200;
         static void Main(string[] args)
         {
             Program p = new Program();

             Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));
             parameterThread.Name = "Thread A:";
             parameterThread.Start(30);
             //启动第二个线程
             parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));
             parameterThread.Name = "Thread B:";
             parameterThread.Start(60);
         }
   
         /// <summary>
         /// 带参数的启动方法
         /// </summary>
         /// <param name="ms">让线程在运行过程中的休眠间隔</param>
         public void ParameterRun(object ms)
         {
             int j = 10;
             int.TryParse(ms.ToString(), out j);//这里采用了TryParse方法，避免不能转换时出现异常
             for (int i = 0; i < 10; i++)
             {
                 Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
                 Thread.Sleep(j);//让线程暂停
             }
         }
     }
}

对上面的代码做一点说明，就是线程启动之后，线程的实例不必再存在，例如在上面的代码中我用的是同一个实例实例化了两个线程，并且这两个线程运行很正常。

本文来自CSDN博客，出处：http://blog.csdn.net/zhoufoxcn/archive/2009/08/03/4402999.aspx

老板：万分欢迎，没有你我们的公司肯定大不一样！  
职员：如果工作太累，搞不好我会辞职的  
老板：放心，我不会让这样的事情发生的！  
职员：我双休日可以休息吗？  
老板：当然了！这是底线！  
职员：平时会天天加班到凌晨吗？  
老板：不可能，谁告诉你的？  
职员：有餐费补贴吗？  
老板：还用说吗，绝对比同行都高！  
职员：有没有工作猝死的风险？  
老板：不会！你怎么会有这种念头？  
职员：公司会定期组织旅游吗？  
老板：这是我们的明文规定！  
职员：那我需要准时上班吗？  
老板：不，看情况吧  
职员：工资呢？会准时发吗？  
老板：一向如此！  
职员：事情全是新员工做吗？  
老板：怎么可能，你上头还有很多资深同事！  
职员：如果领导职位有空缺，我可以参与竞争吗啊？  
老板：毫无疑问，这是我们公司赖以生存的机制！  
职员：你不会是在骗我吧？

进入公司后看真实的一幕（从后往前读）

HTML代码：
<select class="combo_address" name="dest">
<optgroup label="=== 请选择文件夹 ===">
<option value="7152116" selected>/</option>
<option value="7152117">/我的文档/</option>
<option value="7152122">/我的文档/新建文件夹/</option>
<option value="7152123">/我的文档/新建文件夹/001/</option>
<option value="7152124">/我的文档/新建文件夹/001/002/</option>
<option value="7152118">/我的图片/</option>
<option value="7152119">/我的音乐/</option>
<option value="7152120">/我的多媒体/</option>
<option value="7152121">/我的软件/</option>
</optgroup>
<optgroup label="=== 请选择文件夹 ===">
<option value="7152116" selected>/</option>
</optgroup>
</select>