- •Table of Contents
- •Preface
- •What is ASP.NET?
- •Installing the Required Software
- •Installing the Web Server
- •Installing Internet Information Services (IIS)
- •Installing Cassini
- •Installing the .NET Framework and the SDK
- •Installing the .NET Framework
- •Installing the SDK
- •Configuring the Web Server
- •Configuring IIS
- •Configuring Cassini
- •Where do I Put my Files?
- •Using localhost
- •Virtual Directories
- •Using Cassini
- •Installing SQL Server 2005 Express Edition
- •Installing SQL Server Management Studio Express
- •Installing Visual Web Developer 2005
- •Writing your First ASP.NET Page
- •Getting Help
- •Summary
- •ASP.NET Basics
- •ASP.NET Page Structure
- •Directives
- •Code Declaration Blocks
- •Comments in VB and C# Code
- •Code Render Blocks
- •ASP.NET Server Controls
- •Server-side Comments
- •Literal Text and HTML Tags
- •View State
- •Working with Directives
- •ASP.NET Languages
- •Visual Basic
- •Summary
- •VB and C# Programming Basics
- •Programming Basics
- •Control Events and Subroutines
- •Page Events
- •Variables and Variable Declaration
- •Arrays
- •Functions
- •Operators
- •Breaking Long Lines of Code
- •Conditional Logic
- •Loops
- •Object Oriented Programming Concepts
- •Objects and Classes
- •Properties
- •Methods
- •Classes
- •Constructors
- •Scope
- •Events
- •Understanding Inheritance
- •Objects In .NET
- •Namespaces
- •Using Code-behind Files
- •Summary
- •Constructing ASP.NET Web Pages
- •Web Forms
- •HTML Server Controls
- •Using the HTML Server Controls
- •Web Server Controls
- •Standard Web Server Controls
- •Label
- •Literal
- •TextBox
- •HiddenField
- •Button
- •ImageButton
- •LinkButton
- •HyperLink
- •CheckBox
- •RadioButton
- •Image
- •ImageMap
- •PlaceHolder
- •Panel
- •List Controls
- •DropDownList
- •ListBox
- •RadioButtonList
- •CheckBoxList
- •BulletedList
- •Advanced Controls
- •Calendar
- •AdRotator
- •TreeView
- •SiteMapPath
- •Menu
- •MultiView
- •Wizard
- •FileUpload
- •Web User Controls
- •Creating a Web User Control
- •Using the Web User Control
- •Master Pages
- •Using Cascading Style Sheets (CSS)
- •Types of Styles and Style Sheets
- •Style Properties
- •The CssClass Property
- •Summary
- •Building Web Applications
- •Introducing the Dorknozzle Project
- •Using Visual Web Developer
- •Meeting the Features
- •The Solution Explorer
- •The Web Forms Designer
- •The Code Editor
- •IntelliSense
- •The Toolbox
- •The Properties Window
- •Executing your Project
- •Using Visual Web Developer’s Built-in Web Server
- •Using IIS
- •Using IIS with Visual Web Developer
- •Core Web Application Features
- •Web.config
- •Global.asax
- •Using Application State
- •Working with User Sessions
- •Using the Cache Object
- •Using Cookies
- •Starting the Dorknozzle Project
- •Preparing the Sitemap
- •Using Themes, Skins, and Styles
- •Creating a New Theme Folder
- •Creating a New Style Sheet
- •Styling Web Server Controls
- •Adding a Skin
- •Applying the Theme
- •Building the Master Page
- •Using the Master Page
- •Extending Dorknozzle
- •Debugging and Error Handling
- •Debugging with Visual Web Developer
- •Other Kinds of Errors
- •Custom Errors
- •Handling Exceptions Locally
- •Summary
- •Using the Validation Controls
- •Enforcing Validation on the Server
- •Using Validation Controls
- •RequiredFieldValidator
- •CompareValidator
- •RangeValidator
- •ValidationSummary
- •RegularExpressionValidator
- •Some Useful Regular Expressions
- •CustomValidator
- •Validation Groups
- •Updating Dorknozzle
- •Summary
- •What is a Database?
- •Creating your First Database
- •Creating a New Database Using Visual Web Developer
- •Creating Database Tables
- •Data Types
- •Column Properties
- •Primary Keys
- •Creating the Employees Table
- •Creating the Remaining Tables
- •Executing SQL Scripts
- •Populating the Data Tables
- •Relational Database Design Concepts
- •Foreign Keys
- •Using Database Diagrams
- •Diagrams and Table Relationships
- •One-to-one Relationships
- •One-to-many Relationships
- •Many-to-many Relationships
- •Summary
- •Speaking SQL
- •Reading Data from a Single Table
- •Using the SELECT Statement
- •Selecting Certain Fields
- •Selecting Unique Data with DISTINCT
- •Row Filtering with WHERE
- •Selecting Ranges of Values with BETWEEN
- •Matching Patterns with LIKE
- •Using the IN Operator
- •Sorting Results Using ORDER BY
- •Limiting the Number of Results with TOP
- •Reading Data from Multiple Tables
- •Subqueries
- •Table Joins
- •Expressions and Operators
- •Transact-SQL Functions
- •Arithmetic Functions
- •String Functions
- •Date and Time Functions
- •Working with Groups of Values
- •The COUNT Function
- •Grouping Records Using GROUP BY
- •Filtering Groups Using HAVING
- •The SUM, AVG, MIN, and MAX Functions
- •Updating Existing Data
- •The INSERT Statement
- •The UPDATE Statement
- •The DELETE Statement
- •Stored Procedures
- •Summary
- •Introducing ADO.NET
- •Importing the SqlClient Namespace
- •Defining the Database Connection
- •Preparing the Command
- •Executing the Command
- •Setting up Database Authentication
- •Reading the Data
- •Using Parameters with Queries
- •Bulletproofing Data Access Code
- •Using the Repeater Control
- •More Data Binding
- •Inserting Records
- •Updating Records
- •Deleting Records
- •Using Stored Procedures
- •Summary
- •DataList Basics
- •Handling DataList Events
- •Editing DataList Items and Using Templates
- •DataList and Visual Web Developer
- •Styling the DataList
- •Summary
- •Using the GridView Control
- •Customizing the GridView Columns
- •Styling the GridView with Templates, Skins, and CSS
- •Selecting Grid Records
- •Using the DetailsView Control
- •Styling the DetailsView
- •GridView and DetailsView Events
- •Entering Edit Mode
- •Using Templates
- •Updating DetailsView Records
- •Summary
- •Advanced Data Access
- •Using Data Source Controls
- •Binding the GridView to a SqlDataSource
- •Binding the DetailsView to a SqlDataSource
- •Displaying Lists in DetailsView
- •More on SqlDataSource
- •Working with Data Sets and Data Tables
- •What is a Data Set Made From?
- •Binding DataSets to Controls
- •Implementing Paging
- •Storing Data Sets in View State
- •Implementing Sorting
- •Filtering Data
- •Updating a Database from a Modified DataSet
- •Summary
- •Security and User Authentication
- •Basic Security Guidelines
- •Securing ASP.NET 2.0 Applications
- •Working with Forms Authentication
- •Authenticating Users
- •Working with Hard-coded User Accounts
- •Configuring Forms Authentication
- •Configuring Forms Authorization
- •Storing Users in Web.config
- •Hashing Passwords
- •Logging Users Out
- •ASP.NET 2.0 Memberships and Roles
- •Creating the Membership Data Structures
- •Using your Database to Store Membership Data
- •Using the ASP.NET Web Site Configuration Tool
- •Creating Users and Roles
- •Changing Password Strength Requirements
- •Securing your Web Application
- •Using the ASP.NET Login Controls
- •Authenticating Users
- •Customizing User Display
- •Summary
- •Working with Files and Email
- •Writing and Reading Text Files
- •Setting Up Security
- •Writing Content to a Text File
- •Reading Content from a Text File
- •Accessing Directories and Directory Information
- •Working with Directory and File Paths
- •Uploading Files
- •Sending Email with ASP.NET
- •Configuring the SMTP Server
- •Sending a Test Email
- •Creating the Company Newsletter Page
- •Summary
- •The WebControl Class
- •Properties
- •Methods
- •Standard Web Controls
- •AdRotator
- •Properties
- •Events
- •BulletedList
- •Properties
- •Events
- •Button
- •Properties
- •Events
- •Calendar
- •Properties
- •Events
- •CheckBox
- •Properties
- •Events
- •CheckBoxList
- •Properties
- •Events
- •DropDownList
- •Properties
- •Events
- •FileUpload
- •Properties
- •Methods
- •HiddenField
- •Properties
- •HyperLink
- •Properties
- •Image
- •Properties
- •ImageButton
- •Properties
- •Events
- •ImageMap
- •Properties
- •Events
- •Label
- •Properties
- •LinkButton
- •Properties
- •Events
- •ListBox
- •Properties
- •Events
- •Literal
- •Properties
- •MultiView
- •Properties
- •Methods
- •Events
- •Panel
- •Properties
- •PlaceHolder
- •Properties
- •RadioButton
- •Properties
- •Events
- •RadioButtonList
- •Properties
- •Events
- •TextBox
- •Properties
- •Events
- •Properties
- •Validation Controls
- •CompareValidator
- •Properties
- •Methods
- •CustomValidator
- •Methods
- •Events
- •RangeValidator
- •Properties
- •Methods
- •RegularExpressionValidator
- •Properties
- •Methods
- •RequiredFieldValidator
- •Properties
- •Methods
- •ValidationSummary
- •Properties
- •Navigation Web Controls
- •SiteMapPath
- •Properties
- •Methods
- •Events
- •Menu
- •Properties
- •Methods
- •Events
- •TreeView
- •Properties
- •Methods
- •Events
- •HTML Server Controls
- •HtmlAnchor Control
- •Properties
- •Events
- •HtmlButton Control
- •Properties
- •Events
- •HtmlForm Control
- •Properties
- •HtmlGeneric Control
- •Properties
- •HtmlImage Control
- •Properties
- •HtmlInputButton Control
- •Properties
- •Events
- •HtmlInputCheckBox Control
- •Properties
- •Events
- •HtmlInputFile Control
- •Properties
- •HtmlInputHidden Control
- •Properties
- •HtmlInputImage Control
- •Properties
- •Events
- •HtmlInputRadioButton Control
- •Properties
- •Events
- •HtmlInputText Control
- •Properties
- •Events
- •HtmlSelect Control
- •Properties
- •Events
- •HtmlTable Control
- •Properties
- •HtmlTableCell Control
- •Properties
- •HtmlTableRow Control
- •Properties
- •HtmlTextArea Control
- •Properties
- •Events
- •Index
Chapter 5: Building Web Applications
All these commands are also available from the Debug toolbar, which is shown in Figure 5.52.
Figure 5.52. The Debug toolbar
This toolbar appears by default when you’re debugging, but if it doesn’t, you can make it display by right-clicking the toolbar and selecting Debug. The Debug toolbar reflects the commands you can find in the Debug menu, which is depicted in Figure 5.53, and the button on the extreme right gives you easy access to the various debugging windows.
Figure 5.53. Debugging windows accessible from the toolbar
Other Kinds of Errors
Along with the runtime errors we’ve seen so far, ASP.NET can also throw the following kinds of errors:
configuration errors |
These are caused by problems in the Web.config |
|
file. Try adding an incorrect tag to Web.config, and |
|
the next time you try to load the application, an |
|
error will occur. |
parser errors |
Parser errors are caused by the use of incorrect syn- |
|
tax in an ASP.NET script page; for instance, prob- |
|
lems in the definitions of ASP.NET controls in- |
|
cluded in a web form will cause parser errors. |
compilation errors |
These errors are raised by the compiler when there’s |
|
a syntax error in the page’s C# or VB code, and will |
|
be caught by Visual Web Developer. |
210
Other Kinds of Errors
If you try to execute a page that contains compilation errors with Visual Web Developer, those errors will be signaled right away, and the page won’t be loaded in the web browser (see Figure 5.54).
Figure 5.54. Visual Web Developer warns about a compilation error
If you’d like to try this for yourself, write some VB code, but terminate one of the lines with a semicolon as if you were writing C# code, as shown in the snippet below.
Visual Basic
Sub Page_Load(s As Object, e As EventArgs)
timeLabel.Text = DateTime.Now.ToString();
End Sub
If you try to run this code, Visual Web Developer will present you with the message shown in Figure 5.54. If you choose Yes, a previous version of the code that used to compile successfully will be executed. Usually, this isn’t what you want: you’ll prefer to investigate the problem and fix the error. If you choose No, Visual Web Developer will display a window called Error List. Double-click the entry in the Error List, and the offending portion of code will be highlighted in the editor. Moreover, hovering your cursor over the highlighted code will display a tooltip containing a few details about the error, as Figure 5.55 illustrates.
After such a demonstration, I hope you agree that Visual Web Developer is a fantastic tool. What you’ve just seen is merely a common-sense feature in the world of Visual Web Developer, though—much more exciting and powerful features are available!
211
Chapter 5: Building Web Applications
Figure 5.55. Visual Web Developer explaining an error in a tooltip
Custom Errors
If you’re not running your application through Visual Web Developer, ASP.NET will report errors by displaying a message in the browser window, as we saw in Figure 5.46. The default error message that’s shown to remote users doesn’t contain code or other sensitive data, but you can customize the page that’s displayed to visitors when errors occur using a Web.config setting called customErrors.
We define the customErrors element as a child of the system.web element like so:
File: Web.config (excerpt)
<configuration>
<system.web>
212
Handling Exceptions Locally
<customErrors mode="modeValue"
defaultRedirect="errorPage.aspx" />
</system.web>
</configuration>
The defaultRedirect attribute of the customErrors element is used to specify the page that’s used to report errors. We can then choose whether this error page is shown to everybody, to nobody, or only to users who access the site from another network using the mode attribute. The possible values for the mode attribute are:
On |
When mode is On, ASP.NET uses user-defined custom error pages, |
|
instead of its default error page, for both local and remote users. |
Off |
When mode has a value of Off, ASP.NET uses its default error |
|
page for both local and remote users. The customErrors element |
|
has no effect when mode is set to Off. |
RemoteOnly |
When mode has the RemoteOnly value, the ASP.NET error page |
|
is shown only to local users, and the custom error page is shown |
|
to remote users. RemoteOnly is the default value, and is generally |
|
the safest option during development. If the defaultRedirect |
|
attribute is present, remote visitors will see the page mentioned; |
|
otherwise, they’ll see a generic error that doesn’t contain debug- |
|
ging information. |
Handling Exceptions Locally
As you can see, unless you handle any exceptions that are raised in your code yourself, they’ll be caught by the debugger. If you’re not running the code within Visual Web Developer, the exceptions will be caught by the ASP.NET runtime, which displays the errors in the browser.
Additionally, C# and VB enable you to handle runtime errors using the
Try-Catch-Finally construct.
The basic syntax of Try-Catch-Finally is as follows:
Visual Basic
Try
' Code that could generate the exception that you want to handle
213
Chapter 5: Building Web Applications
Catch ex As Exception
'Code that is executed when an exception is generated
'The exception's details are accessible through the ex object Finally
'Code that is guaranteed to execute at the end, no matter if
'an exception occurred
End Try
The equivalent C# syntax looks like this:
C#
try
{
//Code that could generate the exception that you want to
//handle
}
catch (Exception ex)
{
//Code that is executed when an exception is generated
//The exception's details are accessible through the ex
//object
}
finally
{
//Code that is guaranteed to execute at the end, no matter
//if an exception occurred
}
As a basic rule of thumb, we’ll place inside the Try block any code that we suspect might generate errors that we’ll want to handle. If an exception is generated, the code in the Catch block will be executed. If the code in the Try block doesn’t generate any exceptions, the code in the Catch block won’t execute. In the end, whether an exception occurred or not, the code in the Finally block will execute.
That’s an important point: the code in the Finally block will always execute, no matter what! As such, it’s good practice to place any “mission-critical” code in that block. For example, if database operations are performed in the Try block, a good practice would be to close the database connection in the Finally block to ensure that no open connections remain active on the database server—con- suming resources!—or to keep database objects locked.
Exceptions propagate from the point at which they were raised up through the call stack of your program. The call stack is the list of methods that are being executed. So, if method A calls a method B, which in turn calls method C, the call stack will be formed of these three methods, as Figure 5.56 illustrates.
214
Handling Exceptions Locally
Figure 5.56. A simple call stack
In this scenario, an exception that’s raised in method C can be handled within the same function, provided the offending code is inside a Try/Catch block. If this isn't the case, the exception will propagate to method B, which also has the opportunity to handle the exception, and so on. If no method handles the exception, it will be intercepted either by the Visual Web Developer debugger or the ASP.NET runtime.
In the Try-Catch-Finally construct, both the Finally and Catch blocks are optional. You can use only the Try and Catch blocks if there’s no need for a Finally block; you might use only Try and Finally blocks if you want your code always to perform a particular action when an exception is thrown, but you want the exception to propagate up the call stack.
In more complex scenarios, you can use more layers of error handling. In these scenarios, you’ll want to handle the error partially in the place in which it occurred, but you’ll still want to let it propagate so that the upper layers take note of it, and perform further processing. Exceptions are thrown using the Throw keyword (throw in C#), like so:
Visual Basic
Try
'Code that could generate and exception that you want to handle Catch ex As Exception
'Code that is executed when an exception is generated
Throw ex
End Try
C#
try
{
//Code that could generate the exception that you want to
//handle
215
Chapter 5: Building Web Applications
}
catch (Exception ex)
{
// Code that is executed when an exception is generated throw ex;
}
We could modify our array example to include Try and Catch blocks like this:
Visual Basic File: ErrorTest.aspx.vb (excerpt)
Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) Handles Me.Load
Dim a(10) As Integer Dim i As Integer
Try
For i = 1 To 11 a(i) = i
Next
Catch ex As Exception
messageLabel.Text = "Exception!<br />" & ex.Message
End Try |
|
End Sub |
|
C# |
File: ErrorTest.aspx.cs (excerpt) |
protected void Page_Load(object sender, EventArgs e)
{
int[] a = new int[10]; int i;
try
{
for (i = 0; i < 11; i++)
{
a[i] = i;
}
}
catch(Exception ex)
{
messageLabel.Text = "Exception!<br />" + ex.Message;
}
}
Provided you have a Label control named messageLabel in your web form, you’ll see the message shown in Figure 5.57 when you run this code.
216
Handling Exceptions Locally
Figure 5.57. Catching an exception
In the code above, we can see that the Catch block receives an Exception object as a parameter. This object describes the exception that has caused the Catch block to execute. In our code, we use one of the Exception object’s many prop- erties—in this case, Message—to display some information about the error.
In .NET, all exceptions are .NET classes derived from the Exception class. This means that, in fact, each exception is a different class (in our case, ex is an
IndexOutOfRangeException object), but we can treat ex as the generic Exception class to access the generic details of any error.
The Exception class contains the following properties:
Message
the error message
Source
the name of the exception’s source
StackTrace
the names of the methods that were called just before the error occurred
TargetSite
an instance of the MethodBase class that represents the method that caused the error
217