Transcript No Slide Title

Chapter 1
An introduction to
ASP.NET 4.0
web programming
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 1
Objectives
Knowledge
 Describe these terms: web application, web page, web form,
client, server, URL, HTTP, HTML, HTTP request, HTTP
response, postback, and round trip.
 Name the software component that’s required on the client of any
web application, and name the two software components that are
usually required on the server of any web application.
 Distinguish between static web pages and dynamic web pages,
and explain how each is processed by the web server.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 2
Objectives (continued)
 Describe the four components of a URL, and describe what
happens when you omit the file name from a URL when you
request a web page.
 Explain why HTTP is called a stateless protocol, and list the four
features for managing state that are provided by ASP.NET 4.0.
 List the software components that you need on your own PC if
you want to develop and run ASP.NET 4.0 web applications,
including database applications.
 Name the two main components of the .NET Framework and
describe the purpose of each.
 Describe the three types of environments that can be used for
developing ASP.NET applications.
 Describe the aspx files, code-behind files, and other classes that
make up an ASP.NET 4.0 web application.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 3
Objectives (continued)
 In general terms, describe the way that the files for an ASP.NET
page are compiled and run when the page is requested for the first
time, and when the page receives subsequent requests.
 In other words -- what is involved in page traffic across the net
when you access a particular URL
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 4
Terminology (1)
 Dynamic web pages
 Web application
 Web page
 Web form
 Client/server application
 Clients and Servers
 HTTP – HyperText Transfer Protocol
 Web servers and Web browsers
 Round trip
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 5
Terminology (2)
 IIS
 HTML
 HTML document
 HTML Request
 HTMLResponse




Postback
URL
Render
aspx Code
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 6
Terminology (3)
 State and stateless protocol
 Session
 Session state object
 Session ID
 Application
 Application state
 Application state object




Assembly
Code behind
Page directives
ASP – Active Server Pages
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 7
Components of a web application
Server computer
Client computer
Internet
Web browser
Murach’s ASP.NET 4.0/VB, C1
Web server
Database management system
© 2006, Mike Murach & Associates, Inc.
Slide 8
Terms for describing web applications
 client
 server
 Internet
 intranet
 web browser
 web server
 Internet Information Services (IIS)
 database management system (DBMS)
 Hypertext Markup Language (HTML)
 Hypertext Transfer Protocol (HTTP)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 9
Common web browsers
 Microsoft’s Internet Explorer
 Mozilla Firefox
 Netscape Navigator
 Google Chrome
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 10
Dynamic Vs Static Web Pages
The URL for a static web page
http://www.murach.com/books/ugcs/index.htm
The URL for a dynamic ASP.NET web page
http://msdn.microsoft.com/vs2005/default.aspx
 What’s the difference?
 Handling static pages (HTML documents)
like mine is comparatively simple
 HTTP request
 HTTP response
 pages in addition to aspx – e.g., php
© 2006, Mike Murach & Associates, Inc.
Slide 11
How a web server processes static web pages
 Process begins when user requests a web page by typing a URL or
clicking on a URL link
 Browser uses HTTP to send an HTTP request (name and address of
page requested and address of sender and address of server that will
process the request)
 Server sends requested page back in the form of an HTTP response
 Browser then formats and displays the document
Client
Server
HTTP request
Browser
Web server
HTML file
HTTP response
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 12
How a web server processes dynamic pages

A web application consists of (dynamic) web pages that can change each time they are
displayed
 Your browser sends HTTP request (with address of web page) to the web server (IIS in
our case) (except for the very first request, this is called a postback to the server)
 IIS passes request to application server (ASP.NET in this case) which processes the
page (.html pages are treated differently from .aspx or .php)
 A pure HTML web page is generated and ASP.NET returns it to the web server (IIS)
which sends it back to the browser (HTTP response) for display
Client
Server
HTTP request
Web server
(IIS)
Browser
Application
server
(ASP.NET)
HTTP response
Web
application
forms
(.aspx)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 13
Processing a Dynamic Web Page Request:
The Round Trip
 Dynamic web page – HTML document generated
by a web form. The process goes like this …
 Page request – web server looks up the extension
in its list of application mappings
 If .aspx, the file is passed on to ASP.NET for
processing (things get interesting and complex)
 ASP.NET is an Application Server (there are others,
such as for PHP etc)
 ASP.NET runs the web form, generating a pure HTML
document  Server  browser
 From client to server to client: round trip
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 14
Processing a Dynamic Page Request
 This request – response sequence is called a
round-trip
 At the end of a round-trip the Server
Application ends and its state is lost
 This is important as we shall see – saving state
 Once browser has the form at the client
machine the user can make changes
 Clicking buttons, typing text, drop down
selections etc
 Page then sent back to the Server (postback)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 15
Two ways to request a web page
 Enter a URL into your browser
 Click a link on one web page that refers to another web page.
 Show an example of how this works -Amazon -->
Marriott -->
Southwest -->
 Notice -- you are not the only one on the web at any time. Web
forms are flying all over the place -- between millions of client
machines and millions of servers
 Once a request-response round trip has been completed, there
is no facility anywhere in this process for remembering much
about the state of what just transpired UNLESS you do it
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 16
What IIS looks for by default
when a URL doesn’t include a file name
 Default.htm
 Default.asp
 index.htm
 iisstart.asp
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 17
Why state is difficult to track in web applications
Client
Browser
Browser
Browser
Murach’s ASP.NET 4.0/VB, C1
First HTTP request:
The browser requests a
page.
First HTTP response:
The server returns the
requested page and the
application ends.
Next HTTP request:
The browser requests another
page. The server has no way
to associate the browser with
its previous request.
© 2006, Mike Murach & Associates, Inc.
Server
Web server
Web server
Web server
Slide 18
State Concepts
 State refers to the data maintained by an
application for a single user.
 Includes variables (reference and value) and
control properties and values
 An application must maintain a separate
state for each user.
 HTTP doesn’t keep track of state between
round trips so the web application authors
(YOU) must.
 HTTP is a stateless protocol.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 19
Four ASP.NET 2.0 features for maintaining state
 View state (bottom rung)
 Session state
 Application state
 Profiles (top rung)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 20
View State Concepts
 View state maintains the value of form
control properties (but not of any variables
used in processing the form)
 In other words, your basic form remains in
tact
 View state is implemented by default.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 21
Session State Concepts
 For each user, ASP.NET creates a session state
object that contains a session ID.
 The session ID is passed from the server to the
browser and back to the server.
 The session state object is kept on the server.
 To maintain session state across an application
(for a single user), you can add program variable
and control property values to the session state
object to save them across server applications
(round trips)
© 2006, Mike Murach & Associates, Inc.
Slide 22
Application State Concepts
 When an user application begins, ASP.NET creates an
user application state object.
 To maintain values that apply to all users, you can add
program values to the user application state object.
 Note the distinction between what we commonly think
of as an application (herein called a user application)
and a round trip (also referred to as an application)
 From the time you log on to a website until you log off
is what I call a user application
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 23
The New Profile Feature of ASP.NET 4.0
 With ASP.NET 4.0, you can maintain a profile for each
user of an application.
 Profiles are stored in a database so they’re maintained from
one user session to another.
 Profiles make it easier to personalize an application.
 This could be called a benefit to the user. But these days,
perhaps too much is remembered.
 It is nice to remember what is in your cart
 But is it so nice to be bombarded with information about
recent purchases or "people who bought x also bought y"
information?
(SKIP TO SLIDE 36)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 24
Client requirements for ASP.NET
application development





Windows 2000 or later
.NET Framework 2.0
Internet Explorer (or other browser)
Visual Studio 2005 (or Web Developer Express Edition)
SQL Server 2005 Express Edition (for database
applications)
 IIS (for testing applications with IIS)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 25
Visual Studio 2005 Editions
 Standard Edition
 Professional Edition
 Team System
 Visual Web Developer 2005 Express Edition
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 26
New programming features for ASP.NET 2.0
 Master pages
 Site navigation
 Themes
 Data sources and bound-data controls
 Login and user registration
 Profiles
 Web parts
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 27
The .NET Framework
.NET Applications
Visual Basic
Visual C#
Visual J#
Visual C++
Other languages
.NET Framework
.NET Framework Class Library
Windows Forms classes
ASP.NET classes
Other classes
Common Language Runtime
Managed applications
Common Type System
Intermediate Language
Operating System and Hardware
Windows 2000 / 2003
Murach’s ASP.NET 4.0/VB, C1
Windows XP
Other operating systems
© 2006, Mike Murach & Associates, Inc.
Slide 28
The primary components of .NET Framework 2.0
 Class Library
 Common Language Runtime (CLR)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 29
The Class Library
 Provides pre-written code in the form of classes that are available
to all of the .NET programming languages.
 These classes are organized into groups called namespaces.
 The classes that support ASP.NET web programs are stored in the
System.Web namespace.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 30
The Common Language Runtime
 Manages the execution of .NET programs
 Coordinates functions like memory management, code execution,
and security
 Includes the Common Type System that ensures that all .NET
applications use the same data types
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 31
Microsoft Intermediate Language
 All .NET programs are compiled into Microsoft Intermediate
Language (MSIL).
 MSIL is stored on disk in an assembly.
 The assemblies are run by the CLR.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 32
Standalone development
Windows 2000 or later
.NET Framework 2.0
Visual Studio 2005
Optional: IIS, SQL Server
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 33
Local area network development
Windows 2000 or later
.NET Framework 2.0
Visual Studio 2005
Optional: IIS, SQL Server
Windows 2000 Server or later
.NET Framework
IIS 5.0 or later (6.0 recommended)
SQL Server
LAN connection
Client
Murach’s ASP.NET 4.0/VB, C1
Server
© 2006, Mike Murach & Associates, Inc.
Slide 34
Internet development
Windows 2000 or later
.NET Framework 2.0
Visual Studio 2005
Windows 2000 Server or later
.NET Framework
IIS 5.0 or later (6.0 recommended)
FrontPage Server Extensions
FTP server
SQL Server
Internet
connection
Client
Murach’s ASP.NET 4.0/VB, C1
Server
© 2006, Mike Murach & Associates, Inc.
Slide 35
How an ASP.NET Application Works
 Refer to the figure on the next slide
 It is a web form (an Order form in this case)
 It is being viewed in design form
 There is a lot of “stuff” behind this form
 We have to learn about this “stuff”
 Note the similarities here between a web
form page and your windows forms pages.
 Also note the differences the smart tag
arrow and drop down menu that shows up
when you access that arrow
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 36
The Order form in Design view
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 37
Web Forms and Windows Forms –
A Few Differences using VB 2010
 Solution Explorer provides two directories:
 App_Code
App_Data (usually a database)
 ASP.NET keeps two files for a form – both
files are generated as you build your form
 aspx file – holds HTML code and asp tags for
server controls
 aspx.vb – holds VB.NET code-behind
 The smart tag arrow and drop down menu
that shows up when you access that arrow
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 38
The aspx and Visual Basic files
in the Shopping Cart application
Folder
App_Code
App_Code
(root)
(root)
(root)
(root)
Murach’s ASP.NET 4.0/VB, C1
File
CartItem.vb
Product.vb
Cart.aspx
Cart.aspx.vb
Order.aspx
Order.aspx.vb
Type
Business class
Business class
Aspx
Code-behind
Aspx
Code-behind
© 2006, Mike Murach & Associates, Inc.
Slide 39
Dissecting the Order.aspx Form (see Slide 8 & 44) 
 Page directive has four attributes
 Specifies code behind file
 Indicates the Order.aspx class inherits Order class
(note use of verb inherit – the aspx code inherits the vb
code)
 Content of web page defined within div tags
 asp tags define server controls
 They and the form are processed at server
 Converted to HTML and returned to browser (rendered)
 Postback - page must be posted back to server
 Automatically happens for button controls
 Must be specified for other controls
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 40
The aspx file for the Order form
<%@ Page Language="VB" AutoEventWireup="false"
CodeFile="Order.aspx.vb" Inherits="Order" %>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Chapter 3: Shopping Cart</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Image ID="Image1" runat="server"
ImageUrl="~/Images/banner.jpg" /><br /><br />
<asp:Label ID="Label1" runat="server"
Text="Please select a product:"></asp:Label>
<asp:DropDownList ID="ddlProducts" runat="server"
Width = "150px"
DataSourceID="AccessDataSource1"
DataTextField="Name"
DataValueField="ProductID" AutoPostBack="True">
</asp:DropDownList>
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 41
The aspx file for the Order form (continued)
<asp:AccessDataSource ID="AccessDataSource1"
runat="server"
DataFile="~/App_Data/Halloween.mdb"
SelectCommand="SELECT [ProductID], [Name],
[ShortDescription],
[LongDescription], [ImageFile], [UnitPrice]
FROM [Products] ORDER BY [Name]">
</asp:AccessDataSource>
<br />

Note that the controls are now web controls, not
windows controls

Auto-postback is set to true for the dropdownlist.
What does this mean?
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 42
The aspx file for the Order form (continued)
<table>
<tr >
<td style="width: 250px; height: 22px">
<asp:Label ID="lblName" runat="server"
Font-Bold="false"
Font-Size="Larger">
</asp:Label>
</td>
<td style="width: 20px" rowspan=4>
</td>
<td rowspan="4" valign="top">
<asp:Image ID="imgProduct"
runat="server" Height="200" />
</td>
</tr>
.
.
(Code for 3 more rows of a table)
.
</table>
<br />
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 43
The aspx file for the Order form (continued)
<asp:Label ID="Label3" runat="server"
Text="Quantity:"
Width="80px" BorderWidth = "0px"></asp:Label>
<asp:TextBox ID="txtQuantity" runat="server"
Width="80px">
</asp:TextBox>
<asp:Button ID="btnAdd" runat="server"
Text="Add to Cart" />&nbsp;
<asp:Button ID="btnCart" runat="server"
PostBackUrl="~/Cart.aspx" Text="Go to Cart" />
</div>
</form>
</body>
</html>
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 44
Dissecting the Order (Code-Behind) 
 The file name is Order.aspx.vb
 Partial classes have to be combined with other
partial classes in order to compile (where are the
declarations for the controls???)
 Load event raised each time a page is loaded
 Each time a page is requested, ASP.NET initializes
it (hidden) and raises the load event
 Page properties: IsPostback, Response, Session, etc
 DataBind – if initial page load bind ddl to a list
If Not IsPostBack Then ddlProducts.DataBind()
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 45
The code-behind file for the Order form
Imports System.Data
Partial Class Order
Inherits System.Web.UI.Page
Private SelectedProduct As Product
Protected Sub Page_Load(ByVal sender As Object, _
ByVal e As System.EventArgs) Handles Me.Load
If Not IsPostBack Then
‘If initial load. Done once.
ddlProducts.DataBind()
End If
SelectedProduct = Me.GetSelectedProduct()
lblName.Text = SelectedProduct.Name
lblShortDescription.Text = _
SelectedProduct.ShortDescription
lblLongDescription.Text = _
SelectedProduct.LongDescription
lblUnitPrice.Text = _
FormatCurrency(SelectedProduct.UnitPrice)
imgProduct.ImageUrl = "Images\Products\" & _
SelectedProduct.ImageFile
End Sub
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 46
The code-behind file for the Order form (cont.)
Private Function GetSelectedProduct() As Product
Dim dvProduct As DataView = _
CType(AccessDataSource1.Select( _
DataSourceSelectArguments.Empty), DataView)
dvProduct.RowFilter = "ProductID = '" & _
ddlProducts.SelectedValue & "'"
Dim Product As New Product
Product.ProductID = _
dvProduct(0)("ProductID").ToString
Product.Name = dvProduct(0)("Name").ToString
Product.ShortDescription = _
dvProduct(0)("ShortDescription").ToString
Product.LongDescription = _
dvProduct(0)("LongDescription").ToString
Product.UnitPrice = CDec(dvProduct(0)("UnitPrice"))
Product.ImageFile = _
dvProduct(0)("ImageFile").ToString
Return Product
End Function
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 47
The code-behind file for the Order form (cont.)
Protected Sub btnAdd_Click(ByVal sender As Object, _
ByVal e As System.EventArgs) _
Handles btnAdd.Click
Dim CartItem As New CartItem
CartItem.Product = SelectedProduct
CartItem.Quantity = CType(txtQuantity.Text, Integer)
Me.AddToCart(CartItem)
Response.Redirect("Cart.aspx")
End Sub
Private Sub AddToCart(ByVal CartItem As CartItem)
Dim Cart As SortedList = GetCart()
Dim sProductID As String = SelectedProduct.ProductID
If Cart.ContainsKey(sProductID) Then
CartItem = CType(Cart(sProductID), CartItem)
CartItem.Quantity += CType(txtQuantity.Text, _
Integer)
Else
Cart.Add(sProductID, CartItem)
End If
End Sub
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 48
The code-behind file for the Order form (cont.)
Private Function GetCart() As SortedList
If Session("Cart") Is Nothing Then
Session.Add("Cart", New SortedList)
End If
Return CType(Session("Cart"), SortedList)
End Function
End Class
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 49
Processing an ASP.NET Application (A) 
Complicated – lots of compilations
 Order.aspx and Order.aspx.vb are generated normally
in design mode as you drag and drop controls etc (see Chapter 2)
 1. Whenever a web page is requested (through a web-server such
as IIS), IIS looks at the extension for the page and figures out
which Application Server should process the page (In our case it
will be ASP.NET).
 2. ASP.NET reads the aspx file for the page and generates a class
(Order_aspx) and a partial class (Order)which contains the
declarations for the form and its controls
 3. The two partial classes (Order, Order.aspx.vb) and are
compiled together and provide all the event handling needed for
the entire page (yields the Order class dll)
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 50
Processing an ASP.NET Application (B) 
 4. An Order_aspx file is generated by ASP.NET and
compiled to another dll.
 It contains all the code needed to initialize the given web page
 Inherits the Order class – so any object instan-tiated from
the Order_aspx class will contain
 the code that creates the web page
 the event handlers provided by the Order class
 5. VB compiler is called to compile class files in the App_Code
file producing another dll
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 51
Processing an ASP.NET Application (C) 
 FINALLY – ASP.NETcreates an instance of the
page and raises appropriate events
 The events are processed by the event handlers for
the page
 HTML is generated and the page is rendered
 To complete the round trip, the HTML page is
passed back to the web server and on to the client
side browser
 Note that all dlls (steps 1-4) are generated only the
first time a page is called. They are cached.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 52
How an ASP.NET application is compiled
Order.aspx
Order.aspx.vb
Web form
Code-behind file
Order
(partial class)
Other classes
Class files in
App_Code folder
1
ASP.NET runtime
4
2
Order_aspx
Order
(partial class)
Compiler
Compiler
Order
class
(dll)
3
Order.aspx
class
(dll)
Compiler
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Other
classes
(dll)
Slide 53
This is what happens when an ASP.NET 4.0 page
is requested for the first time
1. The aspx file for the web form gets divided into a full class and a
partial class.
2. The partial class is compiled with the code-behind file (another
partial class) into an assembly (.dll).
3. The remaining class gets compiled into another assembly that
inherits the class in the first assembly.
4. Any other class files in the application’s App_Code folder are
compiled into a single assembly.
5. ASP.NET creates an instance of the page from the page’s final
assembly.
6. ASP.NET raises the appropriate events, and the page generates the
HTML that’s passed back to IIS for the response.
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 54
This is what happens when an ASP.NET 4.0 page
is requested again
 ASP.NET creates an instance of the page from the page’s final
assembly.
 ASP.NET raises the appropriate events, and the page generates
the HTML that’s passed back to IIS for the response.
Notes
 The classes aren’t recompiled UNLESS they were changed since
the last recompilation.
 Pages are either posted back via a change to a button control or, if
specified, a change to some other control.
 Until the postback occurs, all the events that took place up to that
point are "held" for processing (in the order in which they
occurred). Processing is not always immediate
Murach’s ASP.NET 4.0/VB, C1
© 2006, Mike Murach & Associates, Inc.
Slide 55