1 / 37

ASP.NET Architecture

ASP.NET Architecture. Dynamic Web Content. Dynamic web content has traditionally been generated using CGI, ISAPI, or ASP on Microsoft platforms The Common Gateway Interface (CGI) provides dynamic content by directly processing requests and issuing responses in a custom process

ebony
Télécharger la présentation

ASP.NET Architecture

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. ASP.NET Architecture

  2. Dynamic Web Content • Dynamic web content has traditionally been generated using CGI, ISAPI, or ASP on Microsoft platforms • The Common Gateway Interface (CGI) provides dynamic content by directly processing requests and issuing responses in a custom process • The Internet Services API provides similar capability through filter DLLs, reducing the overhead • Active Server Pages (ASP) eliminates the need to author DLLs to provide dynamic content -- integrated server-side script generates HTML

  3. ASP • Active Server Pages (ASP) simplify common tasks ISAPI DLLs were being used for • ASP was introduced because web developers were building ISAPI extension DLLs to perform things like database queries and posting back HTML • Each different type of request required a new ISAPI extension DLL to be written • ASP.DLL is a generic ISAPI DLL that reads .ASP files, parses and executes server side script blocks, and serves up result

  4. ASP.NET == ASP.NExTversion • ASP.NET is an evolution of the ASP and is just the next version of ASP • Same intrinsic objects available • Script and html can be mixed • Some ASP code can be ported with no changes • Server-side Javascript is still supported

  5. Sample ASP file test.asp server-side directive <%@ language=javascript %> <scriptlanguage='JScript'runat='server'> function Add(x, y) { return x+y; } </script> <html><body> <h1>Test ASP Page</h1> <h2>2+2=<%=Add(2,2)%></h2> <tableborder='2'> <% for (var i=0; i<10; i++) { %> <tr><td>Row<%=i%> Col0</td><td>Row<%=i%> Col1</td></tr> <% } %> </table> <% Response.Write("<h2>Written directly to Response</h2>"); %> </body></html> <%@ language=javascript %> server-side function server-side evaluation syntax <% %> <% %> <% %> <% %> <% %> interspersed server-side script <% %>

  6. Fundamental change • ASP.NET is more than just the next version of ASP • Pages are compiled into assemblies improving performance and diagnostics • Code-behind encourages better separation of code from HTML • Extensible, server-side control architecture • Server-side data binding model • Form validation architecture • Web services allow assemblies to expose themselves as SOAP servers

  7. Sample ASP.NET file test.aspx server-side directive <%@ Page Language='C#' %> <scriptrunat="server"> int Add(int x, int y) { return x+y; } </script> <html><body> <h1>Test ASP.NET Page</h1> <h2>2+2=<%=Add(2,2)%></h2> <tableborder="2"> <% for (int i=0; i<10; i++) { %> <tr><td>Row<%=i%> Col0</td><td>Row<%=i%> Col1</td></tr> <% } %> </table> <% Response.Write("<h2>Written directly to Response</h2>"); %> </body></html> <%@ Page Language='C#' %> server-side function server-side evaluation syntax <% %> <% %> <% %> <% %> <% %> interspersed server-side script <% %>

  8. What is ASP.NET? • At a high level, ASP.NET is a collection of .NET classes that collaborate to process an HTTP request and generate an HTTP response • Some classes are loaded from system assemblies • Some classes are loaded from GAC assemblies • Some classes are loaded from local assemblies • To work with ASP.NET, you must build your own classes that integrate into its existing class structure • Some of your classes will be in pre-built assemblies • Some of your classes will be in assemblies generated implicitly from ASP.NET files (aspx, ashx, asmx, ...)

  9. ASP.NET request processing

  10. Pipeline architecture • ASP.NET uses the CLR to replace IIS's ISAPI/ASP architecture • User-defined handler objects used to dispatch HTTP requests • Requests dispatched through ASP.NET-provided ISAPI extension (aspnet_isapi.dll) • Handlers run in an ASP.NET-provided worker process (aspnet_wp.exe in IIS 5, w3wp.exe in IIS 6) • Many IIS features bypassed in favor of ASP.NET-provided features (WAM-based process isolation, ASP object model, and session management)

  11. HttpPipeline architecture (IIS 5.0) GET /foo/foo.aspx HTTP/1.1 200 OK ... Web Server (Win2000, XP) named pipe connection aspnet_wp.exe (ASP.NET Worker Process) IHttpHandler handler aspnet_isapi.dll (ISAPI Extension) INETINFO.EXE (IIS 5.0)

  12. HttpPipeline architecture (IIS 6.0) Web Server (Win Server 2003) Application Pool #1 Application Pool #2 w3wp.exe (ASP.NET Worker Process) w3wp.exe (ASP.NET Worker Process) IHttpHandler IHttpHandler handler handler aspnet_isapi.dll (ISAPI Extension) aspnet_isapi.dll (ISAPI Extension) kernel http.sys GET /foo/foo.aspx HTTP/1.1 200 OK ...

  13. Compilation vs. Interpretation • When ASP.NET pages are first accessed, they are compiled into assemblies • Subsequent access loads the page directly from the assembly • Eliminates inefficiencies of the scripting model of ASP • No performance difference between compiled components and embedded server-side code • Debugging tools shared with all .NET development • Whenever you author a new .aspx file, you are authoring a new class

  14. Page compilation • Every ASP.NET page is compiled into an assembly on first access • The generated assembly contains a single class that derives from System.Web.UI.Page • The generated Page-derived class is the file name of the page, replacing the "." with a "_" (like foo_aspx) • The generated assembly is stored in the 'Temporary ASP.NET Files' directory on the server machine

  15. ASP.NET Page Compilation

  16. ASP.NET basics • Each ASP.NET page is parsed and compiled into a class that extends System.Web.UI.Page • Page class implements IHttpHandler • A lot of the Page class is dedicated to forms/control processing • Exposes HttpContext properties as own properties

  17. .aspx type information

  18. System.Web.UI.Page • The Page class provides facilities for rendering HTML • Response and Request objects are available as properties of the class • Methods for rendering are provided • Events associated with generating the page are defined

  19. System.Web.UI.Page - 1 class Page : TemplateControl, IHttpHandler { // State management publicHttpApplicationState Application {get;} publicHttpSessionState Session {virtualget;} public Cache Cache {get;} // Intrinsics publicHttpRequest Request {get;} publicHttpResponse Response {get;} publicHttpServerUtility Server {get;} publicstringMapPath(stringvirtualPath); // Client information publicstringClientTarget {get; set;} publicIPrincipal User {get;} //... }

  20. System.Web.UI.Page - 2 class Page : TemplateControl, IHttpHandler { // Core publicUserControlLoadControl(stringvirtualPath); publicvirtualControlCollection Controls {get;} publicoverridestring ID { get; set;} publicboolIsPostBack {get;} protectedvirtualvoid RenderControl(HtmlTextWriter writer); // Events publiceventEventHandler Init; publiceventEventHandler Load; publiceventEventHandlerPreRender; publiceventEventHandler Unload; //... }

  21. Class creation • Classes created from .aspx files can be customized • Server-side script blocks are added to the class definition • Member variables • Member functions • Interspersed script is added to a 'Render' function • Executable code

  22. aspx == class <%@ Page Language="C#" %> <html><body> <scriptlanguage="C#"runat="server"> private ArrayList _values = new ArrayList(); private void PopulateArray() { _values.Add("v1"); _values.Add("v2"); _values.Add("v3"); _values.Add("v4"); } </script> <h2>aspx==class!</h2> <ul> <% PopulateArray(); for (int i=0; i<_values.Count; i++) Response.Output.Write("<li>{0}</li>", _values[i]); %> </ul> </body></html> <%@ Page Language="C#" %> member variable declaration member function declaration <% member function usage member variable usage %>

  23. Server-side code placement in page compilation

  24. Code behind • In addition to customizing the generated Page class using embedded code, ASP.NET supports page inheritance • Technique of Page inheritance is called code-behind • Supported through the Inherits attribute of the Page directive • Promotes separation of code and presentation • Code-behind files can be pre-compiled and placed in a directory named /bin at the top level of the application • Code-behind files can be compiled on demand using the src attribute of the Page directive

  25. Sample aspx file with code behind <%@ Page Language="C#" Inherits="EssentialAspDotNet.Architecture.SamplePage"%> <html><body> <h2>aspx==class!</h2> <ul> <% WriteArray(); %> </ul> </body></html> <%@ Page Language="C#" Inherits="EssentialAspDotNet.Architecture.SamplePage"%> <% %>

  26. Sample code-behind file - SamplePage.cs namespace EssentialAspDotNet.Architecture { publicclass SamplePage : Page { private ArrayList _values = new ArrayList(); public SamplePage() { _values.Add("v1"); _values.Add("v2"); _values.Add("v3"); _values.Add("v4"); } protectedvoid WriteArray() { for (int i=0; i<_values.Count; i++) Response.Output.Write("<li>{0}</li>", _values[i]); } } }

  27. Class hierarchy created using code behind

  28. Using src attribute to automatically compile code behind file <%@ Page Language="C#" src="SampleCodeBehind.cs" Inherits="EssentialAspDotNet.Architecture.SamplePage"%> <html><body> <h2>aspx==class!</h2> <ul> <% WriteArray(); %> </ul> </body></html> <%@ Page Language="C#" src="SampleCodeBehind.cs" Inherits="EssentialAspDotNet.Architecture.SamplePage"%> <% %>

  29. Shadow Copying • All assemblies in the /bin directory are shadow copied • Placing assemblies in /bin makes them available to all pages in that application • These assemblies are not referenced directly by ASP.NET • Instead they are copied to an obscure location prior to loading • If the original file ever changes, the file is re-copied • Enables xcopy deployment

  30. Shadow copy mechanism used by ASP.NET

  31. ASP->ASP.NET Migration • Several options for migrating 'classic' ASP applications • Run ASP side-by-side with ASP.NET, developing new pages/apps in ASP.NET • Quickest path, but session and application state is not shared • Convert existing ASP pages to ASP.NET (but keep using old libraries - ADO and msxml) • Access to COM libraries incurs interop boundary crossing • Convert existing ASP pages to ASP.NET with new libraries (ADO.NET and System.XML)

  32. Converting ASP pages to ASP.NET • Some pages can be converted by simply renaming to .aspx • Most pages will need some 'touch up' • Many directives have been changed (or removed) • VBScript is not directly supported (must be VB.NET) • COM object interaction may require ASPCOMPAT mode • Code block placement different in ASP.NET

  33. Updating directives from ASP->ASP.NET • Several directives in ASP are no longer supported • <% option explicit %> • <%@ language="vbscript" %> • Instead, use equivalent ASP.NET directives/attributes • <%@ Page Language="VB" Explicit="true" %>

  34. Not VBScript = VB.NET • Many language changes mean VBScript code needs to be updated • VB.NET doesn't support default properties objRS("au_fname") => objRS.Fields("au_fname") • IsNull won't work when testing DB results IsNull(dbField) => IsDBNull(dbField) • Let and Set are no longer supported Set obj = CreateObject("xx") => obj = CreateObject("xx") • Date() is no longer an expression (it is a type) Date() => DateTime.Now • Parameters must be passed within parentheses Response.Write "hi" => Response.Write("hi")

  35. Interacting with COM • By default, ASP.NET applications will run in an MTA thread when accessing COM objects through interop • Many classic ASP components are STA-threaded which means that all calls incur a thread-switch • Avoid this by using the AspCompat attribute <%@ Page AspCompat="true" %>

  36. Summary • ASP.NET is an evolution of dynamic web page generation techniques • All pages in ASP.NET are compiled assemblies • Code-behind is a useful technique for separating code logic from presentation • Shadow copying enables 'xcopy' deployment • Migrating ASP applications typically requires some explicit conversion on your part

  37. For more information, please contact: Uladzimir Tsikhon Software Engineering Manager, Belarus Recourse Development Department EPAM Systems, Inc. Belarus, MinskPhone: +375(17) 2101662 ext 1756 Fax: +375(17) 2101168 Email: uladzimir_tsikhon@epam.com http://www.epam.com

More Related