- Shopping Bag ( 0 items )
Build real-world programming skills—and prepare for MCP Exams 70-305 and 70-315—with this official Microsoft study guide. Work at your own pace through the lessons and hands-on exercises to learn how to build Web applications using Visual Basic .NET and Visual C# .NET. Then extend your expertise through additional skill-building exercises. As you gain practical experience with essential Web development tasks, you’re also preparing for MCAD or ...
Ships from: Murphy, TX
Usually ships in 1-2 business days
Ships from: Irving, TX
Usually ships in 1-2 business days
Ships from: Chicago, IL
Usually ships in 1-2 business days
Build real-world programming skills—and prepare for MCP Exams 70-305 and 70-315—with this official Microsoft study guide. Work at your own pace through the lessons and hands-on exercises to learn how to build Web applications using Visual Basic .NET and Visual C# .NET. Then extend your expertise through additional skill-building exercises. As you gain practical experience with essential Web development tasks, you’re also preparing for MCAD or MCSD certification for Microsoft .NET.
Learn how to:
Your kit includes:
A Note Regarding the CD or DVD
The print version of this book ships with a CD or DVD. For those customers purchasing one of the digital formats in which this book is available, we are pleased to offer the CD/DVD content as a free download via O'Reilly Media's Digital Distribution services. To download this content, please visit O'Reilly's web site, search for the title of this book to find its catalog page, and click on the link below the cover image (Examples, Companion Content, or Practice Files). Note that while we provide as much of the media content as we are able via free download, we are sometimes limited by licensing restrictions. Please direct any questions or concerns to firstname.lastname@example.org.
About This Book
Chapter 1: Introduction to Web Programming
Chapter 2: Creating Web Forms Applications
Chapter 3: Working with Web Objects
Chapter 4: Creating a User Interface
Chapter 5: Storing and Retrieving Data with ADO.NET
Chapter 6: Catching and Correcting Errors
Chapter 7: Advanced Web Forms Programming
Chapter 8: Maintaining Security
Chapter 9: Building and Deploying Web Applications
Chapter 10: Testing Web Applications
Chapter 11: Creating Custom Web Controls
Chapter 12: Optimizing Web Applications with Caching
Chapter 13: Formatting Web Application Output
Chapter 14: Providing Help
Chapter 15: Globalizing Web Applications
Questions and Answers
About This Chapter
In this chapter, you will learn about Internet applications and the tools you use to create them. This chapter introduces you to the concepts and terms used throughout this book, including how ASP.NET Web applications work, the parts of a Web application, how the Microsoft .NET Framework is organized, and how to use the Microsoft Visual Studio .NET programming environment. The sections in this chapter will provide a high-level overview of concepts that are explained in greater detail in subsequent chapters.
Before You Begin
To complete the lessons in this chapter, you must have:
Web applications are one of four types of Internet applications that you can create using Visual Studio .NET. In this lesson, you will learn a little about the different types of Internet applications and get an overview of how an ASP.NET Web application works.
Estimated lesson time: 5 minutes
What Can You Create?
Strictly speaking, an Internet application is any application that uses the Internet in any way. That means applications that request that users register over the Internet or that provide Help through the Internet are, to some degree, Internet applications.
That definition is too broad for the subject of a single book. To narrow the focus a bit, let’s identify four types of Internet applications:
You can use Visual Studio .NET to create each of these types of applications. The first type, Web applications, is the subject of this book. Table 1-1 shows the Visual Studio .NET Help topics and the books in this series that deal with each type of Internet application.
Table 1-1 Sources of Information About Internet Applications
|Application type||Use these topics in online Help||Prepare for the MCSD test using|
|Web applications||ASP.NET, Web forms, System.Web namespace||This book|
|Web services||ASP.NET, XML Web Services, System.Web.Services namespace||MCAD/MCSD Self-Paced Training Kit: Developing XML Web Services and Server Components with Microsoft Visual Basic .NET and Microsoft Visual C# .NET|
|Internet-enabled applications||Microsoft Windows forms, HTML Help, WebBrowser control, System.Net namespace||MCAD/MCSD Self-Paced Training Kit: Developing Windows-Based Applications with Microsoft Visual Basic .NET and Microsoft Visual C# .NET|
|Peer-to-peer applications||Accessing the Internet, pluggable protocols, System.Net and System.Net.Sockets namespaces||Online Help topics for these namespaces and MSDN articles on peer-to-peer and client/server applications with the .NET Framework|
How Web Applications Work
Web applications use a client/server architecture. The Web application resides on a server and responds to requests from multiple clients over the Internet, as shown in Figure 1-1.
Figure 1-1 ASP.NET Web application architecture (Image unavailable)
On the client side, the Web application is hosted by a browser. The application’s user interface takes the form of Hypertext Markup Language (HTML) pages that are interpreted and displayed by the client’s browser.
On the server side, the Web application runs under Microsoft Internet Information Services (IIS). IIS manages the application, passes requests from clients to the application, and returns the application’s responses to the client. These requests and responses are passed across the Internet using Hypertext Transport Protocol (HTTP). A protocol is a set of rules that describe how two or more items communicate over a medium, such as the Internet. Figure 1-2 shows how the client and server interact over the Internet.
Figure 1-2 Client/server interaction in a Web application (Image unavailable)
The Web application composes responses to requests from resources found on the server. These resources include the executable code running on the server (what we traditionally think of as the "application" in Microsoft Windows programming), Web forms, HTML pages, image files, and other media that make up the content of the application.
Web applications are much like traditional Web sites, except that the content presented to the user is actually composed dynamically by executable, rather than being served from a static page stored on the server. Figure 1-3 shows how a Web application composes the HTML returned to a user.
Figure 1-3 An ASP.NET Web application response from server resources (Image unavailable)
The executable portion of the Web application enables you to do many things that you can’t do with a static Web site, such as:
This is only a partial list. Basically, you can do anything with a Web application that you can imagine doing with any client/server application. What makes a Web application special is that the client/server interaction takes place over the Internet.
What ASP.NET Provides
ASP.NET is the platform that you use to create Web applications and Web services that run under IIS. ASP.NET is not the only way to create a Web application. Other technologies, notably the CGI, also enable you to create Web applications. What makes ASP.NET special is how tightly it is integrated with the Microsoft server, programming, data access, and security tools.
ASP.NET provides a high level of consistency across Web application development. In a way, this consistency is similar to the level of consistency that Microsoft Office brought to desktop applications. ASP.NET is part of the .NET Framework and is made up of several components.
In addition to the preceding components, ASP.NET also uses the following, more general programming components and Windows tools. These items aren’t part of ASP.NET. However, they are key to ASP.NET programming.
ASP.NET is the most complete platform for developing Web applications that run under IIS. However, it is important to remember that ASP.NET is not platform-independent. Because it is hosted under IIS, ASP.NET must run on Windows servers. To create Web applications that run on non-Windows/IIS servers, such as Linux/Apache, you must use other tools—generally CGI.
Advantages of ASP.NET
ASP.NET has many advantages over other platforms when it comes to creating Web applications. Probably the most significant advantage is its integration with the Windows server and programming tools. Web applications created with ASP.NET are easier to create, debug, and deploy because those tasks can all be performed within a single development environment—Visual Studio .NET.
ASP.NET delivers the following other advantages to Web application developers:
In this lesson, you will learn how ASP.NET organizes a Web application into parts, and you will learn the roles and names of those parts. You will be introduced to Web forms, which are the central user-interface element of Web applications.
ASP.NET is part of the larger .NET Framework, so this lesson will also discuss how the .NET Framework is organized and how .NET applications run differently from the traditional Windows applications you might be used to.
Finally, this lesson ends with a discussion of the programming languages you can use to create Web applications. ASP.NET is not bound to any one programming language, and the end of this lesson lists some of the other available languages and explains some of the major differences between the two languages (Visual Basic .NET and Visual C#) featured in this book.
Estimated lesson time: 10 minutes
Parts of a Web Application
A Web application consists of three parts: content, program logic, and Web configuration information. Table 1-2 summarizes these parts and gives examples of where they reside in an ASP.NET Web application.
Table 1-2 Parts of an ASP.NET Web Application
|Part||Types of files||Description|
|Content||Web forms, HTML, images, audio, video, other data||Content files determine the appearance of a Web application. They can contain static text and images as well as elements that are composed on the fly by the program logic (as in the case of a database query).|
|Program logic||Executable files, scripts||The program logic determines how the application responds to user actions. ASP.NET Web applications have a dynamic-link library (DLL) file that runs on the server, and they can also include scripts that run on the client machine.|
|Configuration||Web configuration file, style sheets, IIS settings||The configuration files and settings determine how the application runs on the server, who has access, how errors are handled, and other details.|
The Web form is the key element of a Web application. A Web form is a cross between a regular HTML page and a Windows form. It has the same appearance as and similar behavior to an HTML page, but it also has controls that respond to events and run code, like a Windows form.
In a completed Web application, the executable portion of the Web form is stored in an assembly (.dll) that runs on the server under the control of the ASP.NET worker process (asp_wp.exe), which runs in conjunction with IIS. The content portion of the Web form resides in a content directory of the Web server, as shown in Figure 1-4.
Figure 1-4 ASP.NET Web application parts on a Web server (Image unavailable)
When a user navigates to one of the Web forms from his or her browser, the following sequence occurs:
Once the user gets the requested Web form, he or she can enter data, select options, click buttons, and use any other controls that appear on the page. Some controls, such as buttons, cause the page to be posted back to the server for event processing, and the sequence repeats itself, as shown in Figure 1-5.
Figure 1-5 How the parts interact (Image unavailable)
This cycle of events is described in greater detail in Lesson 2 of Chapter 2, "Creating Web Forms Applications."
Web Form Components
Web forms can contain several different types of components, as summarized in Table 1-3.
Table 1-3 Components on a Web Form
|Server controls||TextBox, Label, Button, ListBox, DropDownList, DataGrid||These controls respond to user events by running event procedures on the server. Server controls have built-in features for saving data that the user enters between page displays. You use server controls to define the user interface of a Web form.|
|HTML controls||Text Area, Table, Image, Submit Button, Reset Button||These represent the standard visual elements provided in HTML. HTML controls are useful when the more complete feature set provided by server controls is not needed.|
|Data controls||SqlConnection, SqlCommand, OleDbConnection, OleDbCommand, DataSet||Data controls provide a way to connect to, perform commands on, and retrieve data from SQL and OLE databases and XML data files.|
|System components||FileSystemWatcher, EventLog, MessageQueue||These components provide access to various system-level events that occur on the server.|
You use the server and HTML controls to create the user interface on a Web form. The data controls and system components appear on the Web form only at design time to provide a visual way for you to set their properties and handle their events. At run-time, data controls and system components do not have a visual representation. Figure 1-6 shows a Web form containing components.
Figure 1-6 A Web form with components (Image unavailable)
Chapter 4, "Creating a User Interface," provides more detail about using server and HTML controls on a Web form.
The .NET Framework
ASP.NET is an important part of the .NET Framework, but it is just one part. Understanding what else the .NET Framework provides will help you program your ASP.NET application effectively and avoid writing new code to perform tasks that are already implemented within the .NET Framework.
First, a little background. The .NET Framework is the new Microsoft programming platform for developing Windows and Web software. It is made up of two parts:
.NET applications aren’t executed the same way as the traditional Windows applications you might be used to creating. Instead of being compiled into an executable containing native code, .NET application code is compiled into Microsoft intermediate language (MSIL) and stored in a file called an assembly. At run time, the assembly is compiled to its final state by the CLR. While running, the CLR provides memory management, type-safety checks, and other run-time tasks for the application. Figure 1-7 shows how this works.
Figure 1-7 How a .NET application runs (Image unavailable)
Applications that run under the CLR are called managed code because the CLR takes care of many of the tasks that would have formerly been handled in the application’s executable itself. Managed code solves the Windows programming problems of component registration and versioning (sometimes called DLL hell) because the assembly contains all the versioning and type information that the CLR needs to run the application. The CLR handles registration dynamically at run time, rather than statically through the system registry as is done with applications based on the Component Object Model (COM).
The .NET class library provides access to all the features of the CLR. The .NET class library is organized into namespaces. Each namespace contains a functionally related group of classes. Table 1-4 summarizes the .NET namespaces that are of the most interest to Web application programmers.
Table 1-4 Summary of the .NET Framework Class Library
|Category||Namespaces||Provides classes for|
|Common types||System||All the common data types, including strings, arrays, and numeric types. These classes include methods for converting types, for manipulating strings and arrays, and for math and random number tasks.|
|Data access||System.Data, System.Data.Common, System.Data.OleDb, System.Data.SqlClient, System.Data.SqlTypes||Accessing databases. These classes include methods for connecting to databases, performing commands, retrieving data, and modifying data.|
|Debugging||System.Diagnostics||Debugging and tracing application execution.|
|File access||System.IO, System.IO.IsolatedStorage, System.DirectoryServices||Accessing the file system. These include methods for reading and writing files and getting paths and filenames.|
|Network communication||System.Net, System.Net.Sockets||Communicating over the Internet using low-level protocols such as TCP/IP. These classes are used when you’re creating peer-to-peer applications.|
|Security||System.Security, System.Security.Cryptography, System.Security.Permissions, System.Security.Policy, System.Web.Security||Providing user authentication, user authorization, and data encrypting.|
|Web applications||System.Web, System.Web.Caching, System.Web.Configuration, System.Web.Hosting, System.Web.Mail, System.Web.SessionState, System.Web.UI, System.Web.UI.Design, System.Web.UI.WebControls, System.Web.UI.HtmlControls||Creating client/server applications that run over the Internet. These are the core classes used to create ASP.NET Web applications.|
|Web services||System.Web.Services, System.Web.Services.Configuration, System.Web.Services.Description, System.Web.Services.Discovery, System.Web.Services.Protocols||Creating and publishing components that can be used over the Internet. These are the core classes used to create ASP.NET Web services.|
|Windows applications||System.Windows.Forms, System.Windows.Forms.Design||Creating applications using Windows user interface components. These classes provide Windows forms and controls as well as the ability to create custom controls.|
|XML data||System.Xml, System.Xml.Schema, System.Xml.Serialization, System.Xml.Xpath, System.Xml.Xsl||Creating and accessing XML files.|
Because the .NET namespaces organize classes by function, you can use them to help locate the classes and class members that provide the CLR features you want to use. For example, the System namespace is one of the most commonly used namespaces because it contains the classes for all the fundamental data types. Any time you declare a variable with a numeric, a string, or an array type, you are using the System namespace.
This approach allows the .NET Framework to provide built-in methods for converting data types and manipulating strings and arrays. For instance, the following lines of code use the built-in methods of the String and Array classes to sort a list.
Visual Basic .NET
‘ Declare and initialize a string.
Dim strFruit As String = "oranges apples peaches kumquats nectarines mangos"
‘ Declare an array.
Dim arrFruit As String()
‘ Place each word in an array element.
arrFruit = strFruit.Split(" ")
‘ Sort the array.
‘ Put the sorted data back in the string.
strFruit = String.Join(" ", arrFruit)
// Declare and initialize a string.
string strFruit = "oranges apples peaches kumquats nectarines mangos";
// Declare an array.
// Place each word in an array element.
arrFruit = strFruit.Split(" ".ToCharArray());
// Sort the array.
// Put the sorted array back in the string.
strFruit = System.String.Join(" ", arrFruit);
Many of the class methods in the System namespace can be used directly without first creating an object from the class. These are called shared members in Visual Basic .NET and static members in Visual C#. Shared and static members can be called from the class name itself, as in the System.Array.Sort line in the preceding code. Another example of a class with shared/static members is the Math class, as shown by the following Pi and Pow methods:
Visual Basic .NET
‘ Get the area of a circle.
dblCircArea = System.Math.Pi * System.Math.Pow(intRadius, 2)
// Get the area of a circle.
dblCircArea = System.Math.PI * System.Math.Pow(intRadius, 2) ;
The .NET Framework provides 124 different namespaces. Only about 40 of the most common ones are summarized in Table 1-4. For a list of the .NET Framework namespaces, see the topic titled "Class Library" in the Visual Studio .NET online Help.
ASP.NET and, indeed, the whole .NET Framework are programming language–independent. This means that you can choose any language that has implemented a CLR-compliant compiler. In addition to developing its own programming languages, Microsoft has formed partnerships with many language vendors to provide .NET support for Perl, Pascal, Eiffel, Cobol, Python, Smalltalk, and other programming languages.
This book covers creating Web applications with the Visual Basic .NET and the Visual C# programming languages. These two languages are functionally equivalent, which means that they each provide equal capabilities to create Web applications. The differences between the two languages are syntactical and stylistic.
Most current programmers will choose the language they are most familiar with. Current Visual Basic programmers will be more comfortable developing Web applications in Visual Basic .NET; C or C++ programmers will be more comfortable developing with Visual C#.
If you are new to programming or if you are choosing to extend your programming skills to new languages, learning both Visual Basic .NET and Visual C# is a practical goal. This is especially true when you create Web applications, because most of the tasks are performed through the .NET Framework classes, which means Visual Basic .NET code and Visual C# code often look nearly identical.
Table 1-5 summarizes some significant differences between Visual Basic .NET and Visual C#. This information is useful to keep in mind if you are choosing a programming language for the first time or if you are planning to switch between languages.
Table 1-5 Visual Basic .NET and Visual C# Differences
|Feature||Visual Basic .NET||Visual C# .NET|
|Case sensitive||Not case sensitive:
response.write("Yo") ’ OK
response.write("Yo"); // Error!
|Functional blocks||Use beginning and ending statements to declare functional blocks of code:
Sub Show(strX as String)
|Use braces to declare functional blocks of code:
void Show(string strX)
|Implicit type conversions are permitted by default:
Dim X As Integer
You can limit conversions by including an Option Strict On statement at the beginning of modules.
|Implicit type conversions are limited to operations that are guaranteed not to lose information, such as converting from int to float:
int X = 0;
Other type conversions are performed explicitly by casts:
Y = 3.14F;
Or, by using type conversion methods:
|Comments||Comments always start with an apostrophe (‘):
‘ This is a comment.
|There are three different types of comments: block (/* */), inline (//), and documentation (///):
/* Block comments can
|Arrays||Array elements are specified using
arrFruit(1) = "Apple"
|Array elements are specified using square brackets:
arrFruit = "Apple";
|Methods||You can omit parentheses after method names if arguments are omitted:
strX = objX.ToString
|You must include parentheses after all methods:
strX = objX.ToString();
|Statement termination||Statements are terminated by carriage return:
|Statements are terminated by the semicolon (;):
|Statement continuation||Statements are continued using the underscore (_):
intX = System.Math.PI * _
|Statements continue until the semicolon (;) and can span multiple lines if needed:
intX = System.Math.PI *
|String operator||Use the ampersand (&) or plus sign (+) to join strings:
strFruit = "Apples" & _
|Use the plus sign (+) to join strings:
strFruit = "Apples" +
|Comparison operators||Use =, >, <, >=, <=, <> to compare values:
If intX >= 5 Then
|Use ==, >, <, >=, <=, != to compare values:
if (intX >= 5)
|Negation||Use the Not keyword to express logical negation:
If Not IsPostBack Then
|Use the ! operator to express logical negation:
|Object comparison||Use the Is keyword to compare object variables:
If objX Is objY Then
|Use == to compare object variables:
if (objX == objY)
|Object existence||Use the Nothing keyword or the IsNothing function to check whether an object exists:
If IsNothing(objX) Then
|Use the null keyword to check whether an object exists:
if (objX == null)
In addition to the differences shown in Table 1-5, there are significant keyword differences between the two languages. The code examples throughout this book illustrate those differences. The Visual Studio .NET Help topic "Language Equivalents" provides a complete comparison of Visual Basic .NET, Visual C#, and other Microsoft languages.
The Visual Studio .NET programming environment presents new window types, new ways to manage those windows, and new integration with Internet content. This lesson offers a tour of these new features as well as an overview of some of the older Visual Studio .NET debugging and Help features presented from a Web application–programming viewpoint.
If you’ve programmed with earlier versions of Visual Studio and feel like skipping this lesson, be aware that you can no longer make changes to an application while debugging without restarting the application. That particular Visual Studio .NET feature, called edit-and-continue, is no longer available in Visual Basic .NET or Visual C#.
Estimated lesson time: 30 minutes
The Start Page
When you start Visual Studio .NET, the first thing you see is the Start Page, shown in Figure 1-8. The Start Page contains various panes to make information easier to find and to help simplify some common tasks, such as opening a recent file.
The Projects pane, shown in Figure 1-8, displays the four most recently saved projects in the form of hyperlinks. To open one of these recent projects, click the project name. To create a new project or to open an existing project not displayed in the recent projects list, click the appropriate button on the Projects tab.
To the left of the Start Page is a list of other topics containing current information about Visual Studio .NET, other Microsoft products, programming, Web site hosting, and other information. If you click one of these topics, the Start Page displays the topic, as shown in Figure 1-9.
Figure 1-8 The Visual Studio .NET Start Page (Image unavailable)
Figure 1-9 Current Visual Studio .NET headlines (Image unavailable)
The information displayed in the Start Page is dynamic, with much of the information coming from the Internet. This ensures that the information is current; it’s a good idea to check the Headlines and Downloads panes occasionally to get the latest news.
Of particular interest to Web application developers is the Web Hosting pane, shown in Figure 1-10. This pane links to Web sites that will host your ASP.NET Web applications on the Internet.
Figure 1-10 ASP.NET hosting services (Image unavailable)
Some of the sites, like Brinkster, offer limited free hosting. These hosting services are extremely useful when you’re learning ASP.NET because they allow you to share your work with the world without the effort and expense of setting up your own Web server.
The My Profile pane of the Start Page lets you set your preferences for Visual Studio .NET, as shown in Figure 1-11.
These options let you change the default window layout for Visual Studio .NET, set the programming language you most commonly use, and specify whether Help is displayed in the Visual Studio .NET design panes or in a window as a separate application. The Help window can get a little cramped when displayed within Visual Studio .NET, so unless you have a 19-inch monitor, it’s a good idea to select the External Help option.
Figure 1-11 Set your preferences in the My Profile pane (Image unavailable)
Visual Studio .NET Windows
Visual Studio .NET has two types of windows: Document windows and Tool windows. Document windows display the content of your application: the forms, Web pages, and code all appear in Document windows. You can have multiple Document windows open at once, and you can choose between them by clicking their tabs near the top of the screen, as shown in Figure 1-12.
Tool windows display the components you use to create your application. These components include the controls, database connections, classes, and properties you use in the project. Tool windows are displayed to the left and right of the Document windows and they can be set to slide in or out of view by clicking their tabs, as shown in Figure 1-13.
Figure 1-12 A Document window (Image unavailable)
Figure 1-13 The Toolbox window (Image unavailable)
To cause a tabbed Tool window to remain on screen, toggle the Auto Hide button at the top right of the Tool window. The Auto Hide button looks like a tiny pushpin. Click the pushpin again to cause the Tool window to return to tabbed display. You can use the tabbed display to hide the Tool windows on both sides of the Document window and provide more space for editing your application’s content, as shown in Figure 1-14.
Figure 1-14 Tabbed Tool windows around the Document window (Image unavailable)
The tabbed display of the Document and Tool windows is the default setting for Visual Studio .NET. You can turn off this feature to use a more traditional windowed display by choosing Options from the Tools menu and then selecting your preferences from the dialog box shown in Figure 1-15.
Figure 1-15 The Options dialog box (Image unavailable)
The Visual Studio .NET Toolbox displays the controls and components you can add to a Document window. The contents of the Toolbox change depending on the type of document you are currently editing. When you are editing a Web form, for example, the Toolbox displays the server controls, HTML controls, data controls, and other components that you can add to a Web form, as shown in Figure 1-16.
Figure 1-16 The Toolbox window (Image unavailable)
The components in the Toolbox are categorized as shown in Figure 1-16. When you click one of the categories, the Toolbox displays the items in that category. You can scroll through the items in the Toolbox by clicking the up and down arrows at the top and the bottom of the component list.
When the current document is code, the Toolbox contains only the Clipboard Ring, as shown in Figure 1-17. The Clipboard Ring keeps track of the last 20 items you have copied (Ctrl+C) or cut (Ctrl+X) so that you can paste them back into a document.
To paste an item from the Clipboard Ring, click the item and drag it to where you want to insert it. When you move the mouse pointer over an item in the Clipboard Ring, Visual Studio expands that item to show you more of the text it contains.
Figure 1-17 The Clipboard Ring in the Toolbox window (Image unavailable)
Editing Web Documents
You can edit Web forms and HTML documents visually by using the same drag-and-drop techniques that you use when editing Windows forms, or you can edit them as text files. To switch between edit modes, click the Design or HTML tabs at the bottom of the Document window, as shown in Figure 1-18.
Figure 1-18 A Web document in Design mode (Image unavailable)
There is no way to do some tasks visually, so you will often need to edit Web documents as text. Using the HTML mode can also be more convenient than using the visual tools if you are already familiar with HTML. The IntelliSense technology in Visual Studio .NET provides help for completing HTML elements, as shown in Figure 1-19.
Figure 1-19 IntelliSense for HTML elements in Visual Studio .NET (Image unavailable)
You can switch back to Design mode to preview any changes you make in HTML mode simply by clicking on the Design tab at the bottom of the Document window.
Editing Code-Behind Files
Web forms have code files associated with them. These files are created automatically when you create a new Web form and are called code-behind files. Code-behind files have the same base name as the Web form with the .vb or .cs filename extension added, as shown in Figure 1-20 and Figure 1-21.
Figure 1-20 A Web form’s code-behind file (Visual Basic .NET) (Image unavailable)
Figure 1-21 A Web form’s code-behind file (Visual C#) (Image unavailable)
A Web form is associated with its code file by the @Pagedirective found in the Web form’s HTML, as shown here:
Visual Basic .NET
<%@ Page Language="vb" AutoEventWireup="false" Codebehind="Form1.aspx.vb" Inherits="WebApplication1.Webform1"%>
<%@ Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false" Inherits="WebApplication1.WebForm1" %>
Visual Studio automatically maintains the file information in this Page directive, so if you save the Web form with a different file name, the CodeBehind attribute is automatically updated. However, Visual Studio does not automatically maintain the information in the Page directive’s Inherits attribute. If you change the root namespace of the project or class name of a Web form, you must manually update the information in the Web form’s Page directive.
Visual Studio .NET generates a class definition, initialization procedure, and Page_Load event procedure for each Web form’s code-behind file. You shouldn’t change the code in the regions marked Web Form Designer Generated Code, because that code might later be modified by Visual Studio .NET and your changes could be overwritten.
You can hide the generated code by clicking the minus sign (-) to the left of the #Region directive. Clicking the minus sign collapses the region into a single line and changes the minus sign to a plus sign (+), which you can click to expand the region again. You can use this same outlining feature to collapse or expand other blocks of code, such as class definitions and procedures.
The Visual Studio .NET Code Editor also provides completion through IntelliSense for keywords and class members that you use in code, as shown in Figure 1-22.
Figure 1-22 The autocomplete feature (Image unavailable)
If you are programming in Visual Basic, the autocomplete feature will also correct the capitalization of keywords and member names when you complete a line. If you are using Visual C#, however, Visual Studio .NET will not recognize a keyword or member name if it is not capitalized correctly. This is because Visual Basic .NET is not case sensitive, but Visual C# is.
The Visual Studio .NET Code Editor highlights syntax errors and undeclared variables as you complete each line. These errors are underlined with a squiggly line, and if you move the mouse pointer over the error, a description of the error is displayed, as shown in Figure 1-23.
You can turn most of the Code Editor’s automatic features on or off by changing the settings in the Options dialog box shown in Figure 1-15. You can also use the Options dialog box to change automatic indentation, code block completion, and other language-specific settings.
Figure 1-23 Error detection in the Code Editor (Image unavailable)
Editing Single-Source Web Forms
ASP.NET also supports single-source Web forms. As the name implies, a single-source Web form has its code and HTML stored in the same single file. Many of the ASP.NET code samples and tutorials posted on the Web use single-source files because they are easier to distribute and display. For example, the following single-source Web form calculates the area of a circle:
Visual Basic .NET
<%@ Page Language="VB" %>
Private Sub butCalculate_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs)
’ Declare variables.
Dim dblCircArea, dblRadius As Double
’ Convert text input to a double (optional).
If txtRadius.Text <> "" Then _
dblRadius = System.Convert.ToDouble(txtRadius.Text)
’ Calculate area.
dblCircArea = System.Math.PI * System.Math.Pow(dblRadius, 2)
’ Display result.
Sub ShowResult(ByVal Result As Double)
litResult.Text = "<h3>Results</h3>"
litResult.Text += "<p>The circle’s area is: <b>" + Result.ToString() _
<asp:TextBox id="txtRadius" Runat="server"></asp:TextBox>
<asp:Button id="butCalculate" onclick="butCalculate_Click" Runat="server"
<asp:Literal id="litResult" Runat="server"></asp:Literal>
<%@ Page Language="C#" %>
private void butCalculate_Click(object sender, EventArgs e)
// Declare variables.
double dblCircArea, dblRadius;
// Convert text input to a double (optional).
if (txtRadius.Text != "")
dblRadius = Convert.ToDouble(txtRadius.Text);
// Calculate area.
dblCircArea = 2 * Math.PI * Math.Pow(dblRadius, 2);
// Display result.
void ShowResult(double Result)
litResult.Text = "<h3>Results</h3>";
litResult.Text += "<p>The circle’s area is: <b>" + Result.ToString() +
<asp:TextBox id="txtRadius" Runat="server"></asp:TextBox>
<asp:Button id="butCalculate" onclick="butCalculate_Click" Runat="server"
<asp:Literal id="litResult" Runat="server"></asp:Literal>
Visual Studio can edit and even run these single-source Web forms; however, the advanced features like autocomplete are not enabled for any of the code entered between the <script> and </script> elements on the page. For this reason, the code samples in this book are shown as code-behind files.
Visual Studio .NET organizes applications into projects and solutions. A project is a collection of files that will ultimately make up a single executable. A solution is a group of projects that make up a single functional unit. You view the files in a solution by using the Solution Explorer, as shown in Figure 1-24.
Figure 1-24 The Solution Explorer (Image unavailable)
The project shown in bold is the start-up project. The start-up project is the project that runs when you click Start in Visual Studio .NET. When you’re developing multiple projects as part of a single solution, the start-up project usually calls the other projects in the solution.
Information about a solution is stored in a solution file (.sln), which is placed in your My Documents folder by default. You can open the solution using this file, or you can open projects directly using their project files (.vbproj or .csproj), which are placed in the project folders. If you open a project file, Visual Studio .NET creates a new solution file when you save the project.
Running a Project
You can run a project within Visual Studio .NET by clicking Start on the toolbar, by choosing Start from the Debug menu, or by pressing F5. When you run a project, Visual Studio .NET builds the project files and displays any errors that occur in the Task List window, as shown in Figure 1-25.
Figure 1-25 Running a project with build errors (Image unavailable)
Double-clicking the error description in the Task List selects the line with the error in the Document window so that you can correct the error. The Task List also displays comment tasks you have added to your code, such as 'TODO, //TODO, 'UNDONE, //UNDONE, 'HACK, or //HACK. You can add or modify the tokens you use to identify tasks by configuring the Environment settings in the Options dialog box of Visual Studio.
If no errors occur during the build, Visual Studio .NET starts the application in Debug mode and, in the case of a Web application, starts Internet Explorer and displays the application’s start page. If an error occurs while the application is running in Debug mode, Visual Studio .NET displays the error in the browser, as shown in Figure 1-26.
Figure 1-26 A Web application project with run-time errors (Image unavailable)
You have two choices at this point:
Once you locate the error, you must stop the application before you can correct it. In earlier versions of Visual Studio .NET, you could correct errors in Debug mode and continue running the application.
Setting Breakpoints and Watching Variables
You can stop a project at a particular line of code by setting a breakpoint. When Visual Studio .NET runs the project, it will stop the project and display the line with the breakpoint in the Code Editor before that line executes, as shown in Figure 1-27.
Figure 1-27 A project stopped at a breakpoint (Image unavailable)
To set a breakpoint, click the gray margin to the left of the line you want to break at, or select the line and press F9. Figure 1-28 shows a breakpoint that has been set.
Figure 1-28 Setting a breakpoint (Image unavailable)
Once Visual Studio .NET stops at a breakpoint, you can view the value of active variables by moving the mouse pointer over the variable. If the variable is a complex type, such as an object or an array, you can view its data by adding it to the Watch window, as shown in Figure 1-29.
Figure 1-29 The Watch window (Image unavailable)
To add an item to the Watch window, select the item and drag it to the Watch window. Click the plus sign (+) next to the item in the Watch window to view subitems, such as array elements or object properties.
After you have stopped at a breakpoint, you can continue running your application by clicking Continue on the toolbar or by pressing F5. Alternatively, you can execute one line at a time by pressing F10 or F11.
F10 executes each procedure call as a single statement. In other words, F10 steps over a procedure by executing it and stopping at the next line in the current procedure. F11 executes procedure calls by stepping in to the procedure and stopping at the first line in the called procedure. To execute a single line of code outside of the context of the project, type the code in the Command window. Figure 1-30 shows these different techniques.
Figure 1-30 Ways to execute statements (Image unavailable)
The results of statements entered in the Command window are directed to the next line of the command window. For example, the statement ?System.Math.PI displays 3.1415926535897931 on the next line.
Visual Studio .NET includes a combined collection of Help for the programming environment, languages, .NET Framework, technical support, and developer’s network articles. The Help is displayed either within a Document window or outside Visual Studio .NET in a separate window, depending on the preferences you set on the Start Page or in the Options dialog box.
The Help system includes three ways to find topics: the Contents window, the Index window, and the Search window. These windows act like the Tool windows in Visual Studio .NET: they can be "docked" and then hidden or displayed using tabs, as shown in Figure 1-31.
Each of the navigation windows provides a Filter drop-down list that lets you choose a particular programming language or subject to look in. This feature is especially useful in the Search and Index windows because the combined Help collection is large. The Visual Basic And Related filter and the Visual C# And Related filter include most of the topics you need for this book.
Topics that include syntax or code samples have a language filter icon at the top of each page that looks like a funnel. Click the filter icon to change the programming language displayed in the topic or to view all language samples, as shown in Figure 1-32.
Figure 1-31 The Help navigation windows (Image unavailable)
Figure 1-32 Setting the language filter (Image unavailable)
In addition to the Help included with Visual Studio .NET, Microsoft hosts the GotDotNet Web site, at www.gotdotnet.com. That Web site includes tutorials on using ASP.NET and contains links to many other related Web sites.
In this lab, you will familiarize yourself with the Visual Studio .NET programming environment, sign up for Web application hosting, and view the ASP.NET QuickStart Tutorials. These exercises establish a foundation for the specific programming skills you will learn in later chapters.
Estimated lesson time: 30 minutes
Exercise 1: Customize the Visual Studio .NET Environment
In this exercise, you will customize the window display in Visual Studio .NET to maximize the design area. You will also change your Visual Studio .NET settings to display Help in a separate, external window and specify a language filter within Help. When complete, the Visual Studio .NET environment will appear as shown in Figure 1-33.
Figure 1-33 The customized Visual Studio .NET environment (Image unavailable)
When you start Visual Studio .NET for the first time, the default window layout displays the Server Explorer and Toolbox windows as tabs on the left side of the screen and the Solution Explorer and Properties windows on the right side of the screen.
To maximize the screen space for editing Web documents and code
When the Auto Hide feature is on, the window disappears when the mouse pointer moves off it. The window reappears when the mouse pointer moves over the window’s tab at the edge of the screen.
Another Visual Studio .NET default setting is to display Help within a Visual Studio .NET Document window. Help itself has quite a few windows, so this window-within-window display can become crowded.
To display Help in its own window
Figure 1-34 Setting Help options (Image unavailable)
If you experiment with the Visual Studio .NET window layout and don’t like the results, you can restore the default window settings.
To restore the default window settings
Exercise 2: Set Up a Web Hosting Account
In this exercise, you will set up a Web hosting account that will allow you to deploy Web applications for public testing and evaluation over the Internet. You don’t have to have a Web hosting account to complete the lessons in this book, because you can run and debug Web applications locally on your workstation. However, having a Web hosting account enables you to test how your Web application handles multiple simultaneous users, and it also allows you to share your programming achievements with others, which is just plain fun.
To set up Web hosting
Figure 1-35 ASP.NET Web application hosting services (Image unavailable)
The following sections describe the steps for setting up a Web hosting account in greater detail.
Exercise 3: Choose a Service Provider
The Web Hosting pane lists a number of Web hosting service providers that support ASP.NET Web applications. Each of these providers offers a different combination of free and fee-based services. To evaluate which hosting service is right for you, visit the hosting service Web sites by clicking on their links on the Visual Studio Start Page. In addition to cost, you should consider the following:
To register with a service provider
Figure 1-36 ProTier Welcome page (Image unavailable)
The service providers shown in the Web Hosting pane all provide One-Click Hosting, which means that you can upload your completed Web applications directly from the Visual Studio .NET Web Hosting pane.
To upload an application to the hosting service
Figure 1-37 ProTier logon page (Image unavailable)
Figure 1-38 ProTier upload page (Image unavailable)
After you’ve uploaded an application, you and others can view it by navigating to its location on the Internet. The Web hosting service providers don’t require users to sign on to view applications, just to upload them.
Exercise 4: Explore the ASP.NET QuickStart Tutorials
In this exercise, you will install the .NET SDK Samples QuickStart Tutorials and view the QuickStart Tutorials for ASP.NET. The QuickStart Tutorials contain a host of information about the different aspects of the .NET Framework and are one of the best resources for learning how to program using ASP.NET.
To install and view the QuickStart Tutorial for ASP.NET
Figure 1-39 The Microsoft .NET Framework SDK QuickStarts, Tutorials And Samples install page (Image unavailable)
Figure 1-40 The .NET Framework QuickStart Tutorials page (Image unavailable)
Figure 1-41 The ASP.NET QuickStart Tutorials page (Image unavailable)
The ASP.NET QuickStart Tutorials demonstrate how to perform various ASP.NET programming tasks in Visual Basic .NET, Visual C#, and JScript. Most of the samples in the QuickStart Tutorials place server code within script blocks, rather than using code-behind files as is done in this book. In general, it is preferable to use code-behind files because it separates the user interface from the program logic.
The following questions are intended to reinforce key information presented in this chapter. If you are unable to answer a question, review the appropriate lesson and then try the question again. Answers to the questions can be found in the appendix.
int intX = system.math