.net页面对象模型
外文资料原文
https://www.360docs.net/doc/5a11812946.html, PAGE OBJECT MODEL
Summary: Learn about the eventing model built around https://www.360docs.net/doc/5a11812946.html, Web pages and the various stages that a Web page experiences on its way to HTML. The https://www.360docs.net/doc/5a11812946.html, HTTP run time governs the pipeline of objects that transform the requested URL into a living instance of a page class first, and into plain HTML text next. Discover the events that characterize the lifecycle of a page and how control and page authors can intervene to alter the standard behavior. (6 printed pages) Introduction: Each request for a Microsoft? https://www.360docs.net/doc/5a11812946.html, page that hits Microsoft? Internet Information Services (IIS) is handed over to the https://www.360docs.net/doc/5a11812946.html, HTTP pipeline. The HTTP pipeline is a chain of managed objects that sequentially process the request and make the transition from a URL to plain HTML text happen. The entry point of the HTTP pipeline is the HttpRuntime class. The https://www.360docs.net/doc/5a11812946.html, infrastructure creates one instance of this class per each AppDomain hosted within the worker process (remember that the worker process maintains one distinct AppDomain per each https://www.360docs.net/doc/5a11812946.html, application currently running).
The HttpRuntime class picks up an HttpApplication object from an internal pool and sets it to work on the request. The main task accomplished by the HTTP application manager is finding out the class that will actually handle the request. When the request is for an .aspx resource, the handler is a page handler—namely, an instance of a class that inherits from Page. The association between types of resources and types of handlers is stored in the configuration file of the application. More exactly, the default set of mappings is defined in the
for .aspx resources.
An extension can be associated with a handler class, or more in general, with a handler factory class. In all cases, the HttpApplication object in charge for the request gets an object that implements the IHttpHandler interface. If the association resource/class is resolved in terms of a HTTP handler, then the returned class will implement the interface directly. If the resource is bound to a handler factory, an extra step is necessary. A handler factory class implements the IHttpHandlerFactory interface whose GetHandler method will return an IHttpHandler-based object.
How can the HTTP run time close the circle and process the page request? The IHttpHandler interface features the ProcessRequest method. By calling this method on the object that represents the requested page, the https://www.360docs.net/doc/5a11812946.html, infrastructure starts the process that will generate the output for the browser.
The Real Page Class
The type of the HTTP handler for a particular page depends on the URL. The first time the
URL is invoked, a new class is composed and dynamically compiled to an assembly. The source code of the class is the outcome of a parsing process that examines the .aspx sources. The class is defined as part of the namespace ASP and is given a name that mimics the original URL. For example, if the URL endpoint is page.aspx, the name of the class is ASP.Page_aspx. The class name, though, can be programmatically controlled by setting the ClassName attribute in the
@Page directive.
The base class for the HTTP handler is Page. This class defines the minimum set of methods and properties shared by all page handlers. The Page class implements the IHttpHandler interface.
Under a couple of circumstances, the base class for the actual handler is not Page but a different class. This happens, for example, if code-behind is used. Code-behind is a development technique that insulates the code necessary to a page into a separate C# or Microsoft Visual Basic? .NET class. The code of a page is the set of event handlers and helper methods that actually create the behavior of the page. This code can be defined inline using the runat=server> tag or placed in an external class—the code-behind class. A code-behind class is a class that inherits from Page and specializes it with extra methods. When specified, the code-behind class is used as the base class for the HTTP handler. The other situation in which the HTTP handler is not based on Page is when the configuration file of the application contains a redefinition for the PageBaseType attribute in the The PageBaseType attribute indicates the type and the assembly that contains the base class for page handlers. Derived from Page, this class can automatically endow handlers with a custom and extended set of methods and properties. The Page Lifecycle Once the HTTP page handler class is fully identified, the https://www.360docs.net/doc/5a11812946.html, run time calls the handler's ProcessRequest method to process the request. Normally, there is no need to change the implementation of the method as it is provided by the Page class. This implementation begins by calling the method FrameworkInitialize, which builds the controls tree for the page. The method is a protected and virtual member of the TemplateControl class—the class from which Page itself derives. Any dynamically generated handler for an .aspx resource overrides FrameworkInitialize. In this method, the whole control tree for the page is built. Next, ProcessRequest makes the page transit various phases: initialization, loading of view state information and postback data, loading of the page's user code and execution of postback server-side events. After that, the page enters in rendering mode: the updated view state is collected; the HTML code is generated and then sent to the output console. Finally, the page is unloaded and the request is considered completely served. During the various phases, the page fires a few events that Web controls and user-defined code can intercept and handle. Some of these events are specific for embedded controls and subsequently can't be handled at the level of the .aspx code. A page that wants to handle a certain event should explicitly register an appropriate handler. However, for backward compatibility with the earlier Visual Basic programming style, https://www.360docs.net/doc/5a11812946.html, also supports a form of implicit event hooking. By default, the page tries to match special method names with events; if a match is found, the method is considered a handler for the event. https://www.360docs.net/doc/5a11812946.html, provides special recognition of six method names. They are Page_Init, Page_Load, Page_DataBind, Page_PreRender, and Page_Unload. These methods are treated as handlers for the corresponding events exposed by the Page class. The HTTP run time will automatically bind these methods to page events saving developers from having to write the necessary glue code. For example, the method named Page_Load is wired to the page's Load event as if the following code was written. this.Load += new EventHandler(this.Page_Load); The automatic recognition of special names is a behavior under the control of the AutoEventWireup attribute of the @Page directive. If the attribute is set to false, any applications that wish to handle an event need to connect explicitly to the page event. Pages that don't use automatic event wire-up will get a slight performance boost by not having(51-aspx) to do the extra work of matching names and events. You should note that all Microsoft Visual Studio? .NET projects are created with the AutoEventWireup attribute disabled. However, the default setting for the attribute is true, meaning that methods such as Page_Load are recognized and bound to the associated event. The execution of a page consists of a sequence of stages listed in the following table and is characterized by application-level events and/or protected, overridable methods. Table 1. Key events in the life of an https://www.360docs.net/doc/5a11812946.html, page Some of the stages listed above are not visible at the page level and affect only authors of server controls and developers who happen to create a class derived from Page. Init, Load, PreRender, Unload, plus all postback events defined by embedded controls are the only signals of life that a page sends to the external world. Stages of Execution The first stage in the page lifecycle is the initialization. This stage is characterized by the Init event, which fires to the application after the page's control tree has been successfully created. In other words, when the Init event arrives, all the controls statically declared in the .aspx source file have been instantiated and hold their default values. Controls can hook up the Init event to initialize any settings that will be needed during the lifetime of the incoming Web request. For example, at this time controls can load external template files or set up the handler for the events. You should notice that no view state information is available for use yet. Immediately after initialization, the page framework loads the view state for the page. The view state is a collection of name/value pairs, where controls and the page itself store any information that must be persistent across Web requests. The view state represents the call context of the page. Typically, it contains the state of the controls the last time the page was processed on the server. The view state is empty the first time the page is requested in the session. By default, the view state is stored in a hidden field silently added to the page. The name of this field is __VIEWSTATE. By overriding the LoadViewState method—a protected overridable method on the Control class—component developers can control how the view state is restored and how its contents are mapped to the internal state. Methods like LoadPageStateFromPersistenceMedium and its counterpart SavePageStateToPersistenceMedium can be used to load and save the view state to an alternative storage medium—for example, Session, databases, or a server-side file. Unlike LoadViewState, the aforementioned methods are available only in classes derived from Page. Once the view state has been restored, the controls in the page tree are in the same state they were the last time the page was rendered to the browser. The next step consists of updating their state to incorporate client-side changes. The postback data-processing stage gives controls a chance to update their state so that it accurately reflects the state of the corresponding HTML element on the client. For example, a server TextBox control has its HTML counterpart in an element. In the postback data stage, the TextBox control will retrieve the current value of tag and use it to refresh its internal state. Each control is responsible for extracting values from posted data and updating some of its properties. The TextBox control will update its Text property whereas the CheckBox control will refresh its Checked property. The match between a server control and a HTML element is found on the ID of both. At the end of the postback data processing stage, all controls in the page reflect the previous state updated with changes entered on the client. At this point, the Load event is fired to the page. There might be controls in the page that need to accomplish certain tasks if a sensitive property is modified across two different requests. For example, if the text of a textbox control is modified on the client, the control fires the TextChanged event. Each control can take the decision to fire an appropriate event if one or more of its properties are modified with the values coming from the client. Controls for which these changes are critical implement the IPostBackDataHandler interface, whose LoadPostData method is invoked immediately after the Load event. By coding the LoadPostData method, a control verifies if any critical change has occurred since last request and fires its own change event. The key event in the lifecycle of a page is when it is called to execute the server-side code associated with an event triggered on the client. When the user clicks a button, the page posts back. The collection of posted values contains the ID of the button that started the whole operation. If the control is known to implement the IPostBackEventHandler interface (buttons and link buttons will do), the page framework calls the RaisePostBackEvent method. What this method does depends on the type of the control. With regard to buttons and link buttons, the method looks up for a Click event handler and runs the associated delegate. After handling the postback event, the page prepares for rendering. This stage is signaled by the Pretender event. This is a good time for controls to perform any last minute update operations that need to take place immediately before the view state is saved and the output rendered. The next state is SaveViewState, in which all controls and the page itself are invited to flush the contents of their own ViewState collection. The resultant view state is then serialized, hashed, Base64 encoded, and associated with the __VIEWSTATE hidden field. The rendering mechanism of individual controls can be altered by overriding the Render method. The method takes an HTML writer object and uses it to accumulate all HTML text to be generated for the control. The default implementation of the Render method for the Page class consists of a recursive call to all constituent controls. For each control the page calls the Render method and caches the HTML output. The final sign of life of a page is the Unload event that arrives just before the page object is dismissed. In this event you should release any critical resource you might have (for example, files, graphical objects, database connections). Finally, after this event the browser receives the HTTP response packet and displays the page. Summary The https://www.360docs.net/doc/5a11812946.html, page object model is particularly innovative because of the eventing mechanism. A Web page is composed of controls that both produce a rich HTML-based user interface and interact with the user through events. Setting up an eventing model in the context of Web applications is challenging. It's amazing to see that client-side generated events are resolved with server-side code, and the output of this is visible as the same HTML page, only properly modified. To make sense of this model it is important to understand the various stages in the page lifecycle and how the page object is instantiated and used by the HTTP run time. 译文中午 https://www.360docs.net/doc/5a11812946.html, 页面对象模型 摘要：了解围绕https://www.360docs.net/doc/5a11812946.html, Web 页构建的事件模型，以及一个Web 页面在其转变为HTML 的历程中的各个阶段。https://www.360docs.net/doc/5a11812946.html, HTTP 运行时控制对象管线，对象管线首先将所请求的URL 转换为一个页面类的活动实例，然后将其转换为普通HTML 文本。本文将探讨一个页面的生存周期中的各个特征事件，并了解控件和页面编写者如何介入其中以改变其标准行为。 简介：Microsoft Internet 信息服务(IIS) 所收到的对某Microsoft https://www.360docs.net/doc/5a11812946.html, 页面的每个请求都被移交给https://www.360docs.net/doc/5a11812946.html, HTTP 管线。HTTP 管线由一系列托管对象组成，这些对象按顺序处理该请求，并完成从URL 到普通HTML 文本的转换。HTTP 管线的入口点是HttpRuntime 类。https://www.360docs.net/doc/5a11812946.html, 基础结构为辅助进程中所承载的每个AppDomain 创建此类的一个实例（请注意，该辅助进程为当前正在运行的每个https://www.360docs.net/doc/5a11812946.html, 应用程序维护一个不同的AppDomain）。 HttpRuntime 类从内部池中选取一个HttpApplication 对象，并让其处理该请求。HTTP 应用程序管理器所完成的主要任务就是找出将实际处理该请求的类。如果请求.aspx 资源，则处理程序就是一个页面处理程序—即某个继承自Page 的类的一个实例。资源类型和处理程序类型之间的关联关系存储于该应用程序的配置文件中。更准确地说，在 machine.config 文件的 type="System.Web.UI.PageHandlerFactory"/>扩展名可关联到一个处理程序类，或者更普遍地关联到一个处理程序工厂(handler factory) 类。在所有情况下，负责处理请求的HttpApplication 对象都会获得一个实现IHttpHandler 接口的对象。如果根据HTTP 处理程序来解析关联资源/类，那么所返回的类将直接实现该接口。如果资源绑定到处理程序工厂，则需要另外一个步骤。处理程序工厂类实现IHttpHandlerFactory 接口，而该接口的GetHandler 方法返回一个基于IHttpHandler 的对象。 HTTP 运行时如何能完成整个循环并处理页面请求呢？IHttpHandler 接口特别提供了ProcessRequest 方法。通过对代表所请求页面的对象调用此方法，https://www.360docs.net/doc/5a11812946.html, 基础结构启动相应过程，从而针对浏览器生成输出。 真正的Page 类 特定页面的HTTP 处理程序类型取决于URL。当首次调用URL 时，将构建一个新类并将该类动态地编译成一个程序集。用于检查.aspx 来源的语法分析过程的输出结果就是该类的源代码。该类被定义为ASP 命名空间的一部分，并被赋予一个与原始URL 相似的名称。例如，如果URL 终结点是page.aspx，则类名称为ASP.Page_aspx。但是，也可通过编程设置@Page 指令的ClassName 属性来控制类的名称。 HTTP 处理程序的基类是Page。此类定义了所有页面处理程序所共享的方法和属性的最小集合。Page 类中实现IHttpHandler 接口。 在某些情况下，实际处理程序的基类并非Page，而是一个不同的类。例如，如果使用 了代码隐藏，就会出现这种情况。代码隐藏是一种开发方法，它将页面所需的代码封装到一个单独的C# 或Microsoft Visual https://www.360docs.net/doc/5a11812946.html, 类中。页面的代码就是一组事件处理程序和帮助器方法，用以实际创建该页面的行为。可以利用 B: 也可以直接给window.location属性赋值，window.location="url",与A不同的是有历史记录 C: 对于document,location不是不是对象，document.location=document.url 一、Response对象 Response对象是HttpResponse类的一个实例。该类主要是封装来自https://www.360docs.net/doc/5a11812946.html,操作的HTTP响应信息。 1.Response对象的属性 ①BufferOutput 说明：获取或设置一个值，该值指示是否缓冲输出，并在完成处理整个页之后将其发送 属性值：如果缓冲了到客户端的输出，则为true；否则为false。默认为true ②Cache 说明：获取Web页的缓存策略（过期时间、保密性、变化子句） 属性值：包含有关当前响应的缓存策略信息的HttpCachePolicy对象 ③Charset 说明：获取或设置输出流的HTTP字符集 属性值：输出流的HTTP字符集 ④IsClientConnected 说明：获取一个值，通过该值指示客户端是否仍连接在服务器上 属性值：如果客户端当前仍在连接，则为true；否则为false 2.Response对象的方法 Response对象可以输出信息到客户端，包括直接发送信息给浏览器、重定向浏览器到另一个URL或设置cookie的值。https://www.360docs.net/doc/5a11812946.html,中引用对象方法的语法是“对象名.方法名”。“方法”就是嵌入到对象定义中的程序代码，它定义对象怎样去处理信息。使用嵌入的方法，对象便知道如何去执行任务，而不用提供额外的指令。 ①Write 说明：将指定的字符串或表达式的结果写到当前的HTTP输出 ②End 说明：停止页面的执行并得到相应结果 ③Clear 说明：用来在不将缓存中的内容输出的前提下，清空当前页的缓存，仅当使用了缓存输出时，才可以利用Clear方法 ④Flush 说明：将缓存中的内容立即显示出来。该方法有一点和Clear方法一样，它在脚本前面没有将Buffer属性设置为True时会出错。和End方法不同的是，该方法调用后，该页面可继续执行 ⑤Redirect WebDypro两个页面之间传值 WebDynpro for ABAP TM Scenario: To create and run a simple WebDynpro Application. We would accept an input value from the user on first screen and display the value entered on the second screen. Note:Please refer to the SAP? help for detailed information of the components used in this document. Procedure: 1.Go to transaction SE80. Please note that there is no separate transaction for creation of WebDynpro application other than SE80. 2.Select “WebDynpro Comp./Intf” from t he list (as shown below) 3.Create a new WebDynpro component by the name ZSAPTECHNICAL_DEMO. Assign it to the local object. 4.Right click on the WebDynpro component “ZSAPTECHNICAL_DEMO” and create a view. https://www.360docs.net/doc/5a11812946.html,内置对象小结： 1．Response对象 Response对象是HttpResponse类的一个实例。该类主要是封装来自https://www.360docs.net/doc/5a11812946.html,操作的HTTP响应信息。 服务器端利用Response对象的一些方法向客户端(浏览器)输出信息。 Response对象可以输出信息到客户端，包括直接发送信息给浏览器、重定向浏览器到另一个URL或设置cookie的值。 常用方法：Response.Write()，Response.Redirect()。 ① Write 说明：将指定的字符串或表达式的结果写到当前的HTTP输出 ⑤ Redirect 说明：使浏览器立即重定向到程序指定的URL 2．Request对象 Request对象用于获取从浏览器向服务器所发送的请求中的信息。当用户单击“提交”按钮时，包含在输入控件中的数据信息将会与表单一起被发送到服务器端。服务器端的Request对象就会读取通过HTTP请求发送的数据。 服务器端常常使用Request对象从客户端得到数据，它有两个常用方法，Form[]方法和QueryString[]方法。前者用来获取客户端以Post方式提交的数据，后者获取以Get方式提交的数据。 它还有一些有用的属性，可以获取客户端的一些信息，如客户端版本，客户端IP地址，当前网站的物理路径。 Request对象的属性 ① QueryString 说明：获取 HTTP 查询字符串变量集合 ② Browser 说明：获取有关正在请求的客户端的浏览器功能的信息 Request对象的方法 ①MapPath 说明：为当前请求将请求的URL中的虚拟路径映射到服务器上的物理路径。 3. Server对象 Server对象提供的方法和属性可以访问服务器，如MapPath()方法可以得到服务器上某文件的物理路径，HTMLEncode()可以对字符进行编码，输出平时无法输出的字符。 向使用 MultiView 和 GridView 控件的 JavaScript 弹出窗口要发送值和从之接收值 下载源代码 介绍 很多时候，我们要在我们的应用程序中创建一个弹出窗口。 通常当我们弹出一个窗口 ，我们还要使调用窗口和弹出的窗口进行交互。本文中我将展示如何在一个 https://www.360docs.net/doc/5a11812946.html, 应用程序中创建一个弹出窗口 （使用 JavaScript）和如何从弹出窗口返回值到原始的调用页面并自动引发该页上的按钮的单击事件。 另外，我将使用 MultiView 控件和 带分页的GridView 控件。 第一步：创建第一个页面 创建一个新的 https://www.360docs.net/doc/5a11812946.html, 网站，默认情况下您会自动创建 Default.aspx。在该页上添加一个标签、一文本框 (用于输入学生 ID)、一个链接按钮（单击它将弹出弹出窗口）和一个提交按钮。 您可以从工具箱中添加所有这些项。 为了提供更好的对齐方式，我把这些控件放到了 HTML table中。 下面是我在这里是我写了 div 标记内的完整代码。 ASPNET对象
WebDypro两个页面之间传值
网络技术-数据库-HTTP开发-ASPNET内置对象小结-298
弹出页面和原页面之间传值