Docstoc

Boot Camp - C - Syringe.Net.Nz

Document Sample
Boot Camp - C - Syringe.Net.Nz Powered By Docstoc
					ASP.net Architecture

Jeremy Boyd,
Senior Technical Lead - Intergen
MSDN Regional Director – New Zealand
A quick word about the RD
program J
    Regional Directors aren't Microsoft employees
    RDs are independent developers who provide
    a link between Microsoft and the local
    community.
    Find out more: http://www.microsoft.com/rd

    Drop us a line if you want to talk shop, ask about the
    new technology coming out of Microsoft, or just see if
    we can help with a technical problem you are having J
    New Zealand RDs – Lukas Svoboda, Jeremy Boyd
    Australia RDs – Adam Cogan, Peter Stanski
Objectives
    Discuss history of ASP.NET
     – Dynamic web content
     – ASP
    Present new ASP.NET architecture
     –   .NET core
     –   Compilation
     –   Code behind
     –   Shadow copying
    Migration from ASP
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
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
ASP.NET == ASP.NExTversion
   On one hand, 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
 Sample ASP file
                                                                           test.asp
server-side    <%@ language=javascript %>
                <%@ language=javascript %>
directive
               <script language='JScript' runat='server'>
server-side
               function Add(x, y)
function
               {
                 return x+y;
               }
               </script>

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

               <html> <body>
               <h1>Test ASP.NET Page</h1>
server-side
                        <%          %>
               <h2>2+2=<%=Add(2,2)%></h2>
evaluation
               <table border="2">
syntax
               <%
               <% for (int i=0; i<10; i++) { %> %>
                             <% %>                    <% %>
                 <tr><td>Row<%=i%> Col0</td><td>Row<%=i%> Col1</td></tr>
               <%    %>
               <% } %>
               </table>
interspersed
               <%
               <% Response.Write("<h2>Written directly to Response</h2>"); %>    %>
server-side
script
               </body> </html>
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
High-level view of ASP.NET
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)
HttpPipeline architecture (IIS 5.0)
 GET /foo/foo.aspx    HTTP/1.1 200 OK ...

                                                   Web Server (Win2000, XP)


                                                 aspnet_wp.exe
                                            (ASP.NET Worker Process)

                                    named pipe       IHttpHandler
                                    connection                      handler

                aspnet_isapi.dll
                (ISAPI Extension)

      INETINFO.EXE (IIS 5.0)
HttpPipeline architecture (IIS 6.0)
                                                         Web Server (Win Server 2003)

     Application Pool #1                            Application Pool #2

                 w3wp.exe                                   w3wp.exe
          (ASP.NET Worker Process)                   (ASP.NET Worker Process)
                     IHttpHandler                                   IHttpHandler
                                    handler                                        handler




      aspnet_isapi.dll                              aspnet_isapi.dll
      (ISAPI Extension)                             (ISAPI Extension)


 kernel                                       http.sys




                      GET /foo/foo.aspx            HTTP/1.1 200 OK ...
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
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
ASP.net Page Compilation
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
.aspx Type Information
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
System.Web.UI.Page

   class Page : TemplateControl, IHttpHandler
   {
     // State management
     public HttpApplicationState Application {get;}
     public HttpSessionState Session {virtual get;}
     public Cache Cache {get;}

       // Intrinsics
       public HttpRequest Request {get;}
       public HttpResponse Response {get;}
       public HttpServerUtility Server {get;}
       public string MapPath(string virtualPath);

       // Client information
       public string ClientTarget {get; set;}
       public IPrincipal User {get;}
       //...
   }
System.Web.UI.Page
 class Page : TemplateControl, IHttpHandler
 {
   // Core
   public UserControl LoadControl(string virtualPath);
   public virtual ControlCollection Controls {get;}
   public override string ID { get; set;}

     public bool IsPostBack {get;}
     protected virtual void
       RenderControl(HtmlTextWriter writer);
     // Events
     public event EventHandler Init;
     public event EventHandler Load;
     public event EventHandler PreRender;
     public event EventHandler Unload;

     //...
 }
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
      Aspx == Class
                              <%@ Page Language="C#" %>
                               <%@ Page Language="C#" %>
                              <html><body>
                              <script language="C#" runat="server">
member variable declaration     private ArrayList _values = new ArrayList();
member function declaration     private void PopulateArray()
                                {
                                    _values.Add("v1");
                                    _values.Add("v2");
                                    _values.Add("v3");
                                    _values.Add("v4");
                                }
                              </script>

                              <h2>aspx==class!</h2>
                              <ul>
                              <%
                              <%
     member function usage       PopulateArray();
                                 for (int i=0; i<_values.Count; i++)
     member variable usage         Response.Output.Write("<li>{0}</li>", _values[i]);
                              %>
                              %>
                              </ul>
                              </body> </html>
Server Side Code Placement in Page Compilation
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
Sample Page with CodeBehind

 <%@ Page Language="C#"
<%@ Page Language="C#"
     Inherits="EssentialAspDotNet.Architecture.SamplePage"%>
    Inherits="EssentialAspDotNet.Architecture.SamplePage"%>
<html><body>

<h2>aspx==class!</h2>
<ul>
<% WriteArray(); %>%>
<%
</ul>
</body> </html>
SamplePage.cs
  namespace EssentialAspDotNet.Architecture
  {
    public class SamplePage : Page
    {
      private ArrayList _values = new ArrayList();
      public SamplePage()
      {
        _values.Add("v1");
        _values.Add("v2");
        _values.Add("v3");
        _values.Add("v4");
      }

          protected void WriteArray()
          {
            for (int i=0; i<_values.Count; i++)
              Response.Output.Write("<li>{0}</li>", _values[i]);
          }
      }
  }
Class Hierarchy created using code behind
Using src attribute to automatically compile code behind



 <%@ Page Language="C#" src="SampleCodeBehind.cs"
<%@ Page Language="C#" src="SampleCodeBehind.cs"
     Inherits="EssentialAspDotNet.Architecture.SamplePage"%>
    Inherits="EssentialAspDotNet.Architecture.SamplePage"%>

<html><body>

<h2>aspx==class!</h2>
<ul>
<% WriteArray(); %>
<%                 %>
</ul>
</body> </html>
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
Shadow Copy Mechanism
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)
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
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" %>
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")
Not VBScript = VB.NET
    – 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")
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" %>
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

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:2
posted:6/19/2013
language:English
pages:39