ASP.NET 2.0 All-In-One Desk Reference For Dummies®

Table of contents

1. Copyright
   1. Dedication
2. About the Author
3. Author’s Acknowledgments
4. Publisher’s Acknowledgments
5. Introduction
   1. About This Book
   2. How to Use This Book
   3. How This Book Is Organized
      1. Book I: ASP.NET Basics
      2. Book II: Web Controls
      3. Book III: HTML
      4. Book IV: C#
      5. Book V: Visual Basic
      6. Book VI: Database Programming
      7. Book VII: Using the .NET Framework
      8. Book VIII: Advanced ASP.NET Programming
   4. Icons Used in This Book
   5. Where to Go from Here
6. I. ASP.NET Basics
   1. 1. Welcome to ASP.NET Programming
      1. What Is ASP.NET, and Why Is It So Great?
         1. Windows and IIS dependence
         2. Object orientation
         3. Choice of languages
         4. Visual Studio
      2. Understanding Web Servers and Browsers
      3. Understanding Static Web Pages
      4. Understanding Dynamic Web Pages
      5. Looking at a Simple ASP.NET Application
      6. The .aspx (Markup) File for the Simple Calculator Application
      7. The Code-Behind File of the Simple Calculator Application
   2. 2. Installing Visual Studio Web Developer 2005 Express Edition or Visual Studio 2005
      1. Looking at Visual Studio 2005 Editions
      2. Considering Visual Web Developer 2005 Express Edition
      3. Installing Visual Web Developer 2005 Express Edition
      4. Registering Visual Web Developer 2005 Express Edition
      5. Installing Visual Studio 2005
   3. 3. Creating Your First ASP.NET 2.0 Application
      1. Understanding Visual Studio Projects
      2. Creating a New Web Site
      3. Using the Solution Explorer
      4. Working with Controls
      5. Setting Properties
      6. Setting the Page Title
      7. Looking at the Source Code
      8. Adding Some Code
      9. Running the Application
   4. 4. Understanding Postback, Events, and Code-Behind
      1. Understanding Postback
      2. Using the IsPostBack Variable
      3. Understanding Events
      4. Using the Handles Clause in Visual Basic
      5. Designating an Event Handler in C#
      6. Using C#’s Auto Event Wireup
      7. Understanding Code-Behind
      8. Using Single-File Pages
   5. 5. Creating Multipage Applications
      1. Understanding the Basics of a Multipage Application
      2. Adding Pages
      3. Redirecting to Another Page
      4. Adding Classes
      5. Using Session State
      6. Looking into Data Binding
      7. Using Master Pages
         1. Creating a Master Page
         2. Creating a content page
      8. The C# Version of the Shopping Cart Application
      9. The VB.NET Version of the Shopping Cart Application
   6. 6. Testing and Debugging Your ASP.NET Applications
      1. Creating a Simple Calculator Application
      2. Running an ASP.NET Application
      3. Dealing with Errors
      4. Working in Break Mode
      5. Displaying Variable Data
      6. Stepping Through a Program
      7. Setting Breakpoints
      8. Using Response.Write for Debugging
7. II. Web Controls
   1. 1. Using Basic Web Server Controls
      1. Using Label Controls
      2. Using TextBox Controls
      3. Using Button Controls
      4. Using CheckBox Controls
         1. Checking the Checked property
         2. Another way to check the Checked property
      5. Using RadioButton Controls
      6. Using Image Controls
   2. 2. Using Validation Controls
      1. Validating the Hard Way
      2. Validation Controls to the Rescue!
      3. Using the RequiredFieldValidator Control
      4. Using the CompareValidator Control
      5. Using the RangeValidator Control
      6. Using the RegularExpressionValidator
      7. Using a CustomValidator Control
      8. Using the ValidationSummary Control
      9. Using the CausesValidation and ValidationGroup Properties
   3. 3. Using List Controls
      1. Using the CheckBoxList Control
         1. Creating columns
         2. Aligning text with check boxes
         3. Spacing things out
      2. Working with ListItem Elements
         1. Using the Text property
         2. Using the Value property
         3. Determining which items are selected
         4. Using the Collection Editor dialog box
      3. Toiling with the RadioButtonList Control
      4. Utilizing ListBox Controls
      5. Employing DropDownList Controls
      6. Accomplishing More with List Items in Code
         1. Adding an item to a list
         2. Clearing the list
         3. Selecting and deselecting items
         4. Finding an item
   4. 4. Using Advanced Web Server Controls
      1. Using the MultiView Control
      2. Utilizing the Wizard Control
         1. Creating steps in Visual Studio
         2. Using Wizard events
         3. Looking at the code for a Wizard control
      3. Working with the Calendar Control
      4. Making Use of the FileUpload Control
   5. 5. Working with User Controls
      1. Introducing User Controls
      2. Creating a User Control
      3. Adding a User Control to a Page
      4. Adding Properties to a User Control
      5. Putting User-Control Properties to Work
8. III. HTML
   1. 1. HTML Basics
      1. XHTML Rulez!
         1. XHTML and the W3C
         2. The strict upbringing of XHTML
         3. Making your HTML well-formed
         4. More XHTML requirements
         5. Taking characters as an entity
      2. VWDE’s Support for XHTML
         1. A solemn DOCTYPE declaration
         2. Validity spy
         3. Letting VWDE fix old code
            1. Fixing a missing attribute
            2. Crossing the great div(ide)
            3. Slashing squiggly lines
            4. Magical chorded keystrokes
         4. You can go your own way
      3. Editing Code in Source View
         1. Preserving source code
         2. Cleaning up source code
         3. Using the Tag Navigator
         4. Collapsing and outlining
         5. No Comment!
      4. Editing Pages in Design View
         1. Establishing a position in Design view
         2. Positioning a Single Control
         3. Viewing an HTML document’s structure
         4. Manipulating the DOM
      5. Formatting Text
         1. The Formatting toolbar
         2. The Format menu
         3. Properties pages
   2. 2. Creating Tables
      1. Some Basic Table Talk
         1. Adding headers, a caption, and a summary
         2. Grouping and spanning columns and rows
      2. Creating Tables in the Designers
         1. The Toolbox table
         2. The table designer
         3. The ASP.NET table tool
      3. Creating Tables Programmatically
         1. Building a table by using the Repeater control
         2. Building an ASP.NET table from scratch
      4. Creating a Table-Based Framework
   3. 3. Working with Forms
      1. Understanding Forms
      2. Creating a Form
         1. A call to action — sent by post
         2. Staying on target
         3. Your special events form
      3. Working with Text Boxes
         1. Creating text fields with <input>
         2. Creating a password text box
         3. Super-sizing a text field
      4. Working with Buttons
         1. Creating a submit button
         2. Creating a reset button
         3. Creating an ordinary button
         4. Creating an image button
         5. Creating submit, reset, and ordinary buttons another way
      5. Working with Check Boxes and Radio Buttons
         1. Creating a check box
         2. Creating a radio button
      6. Using Drop-Down Lists and List Boxes
         1. Creating a drop-down list
         2. Creating a list box
         3. Creating a hierarchical drop-down list and list box
      7. Checking Form Submissions with ASP.NET
      8. Setting the Tab Order
   4. 4. Using Styles and Style Sheets
      1. Understanding Styles
         1. Cascading Style Sheets
            1. Will that be inline, embedded, or external?
            2. In case of a dispute, the closest wins
         2. Style selectors and other syntax
      2. Working with Styles in Visual Studio 2005 and Visual Web Developer
         1. Setting the CSS validation schema
         2. Creating inline styles in Design view
         3. Creating inline styles in Source view
         4. Building external style sheets
         5. Creating a class with style
      3. Using Span and Div for Styles and Positions
         1. Highlighting text with <span>
         2. Creating a layer with <div>
         3. Showing and hiding the <div>
      4. Creating and Applying Styles in Code
         1. Applying inline styles in code
         2. Inserting embedded styles with code
         3. Letting users choose their style sheet
   5. 5. Using Client-Side Script
      1. Sampling Client-Side Script on Microsoft.com
         1. Compensating for browser differences
         2. Embedding multimedia content
         3. Tracking page views and statistics
         4. Making the page interactive
         5. Creating random content and surveys
      2. Embedding Script in an ASP.NET Page
         1. Embedding a block of script
         2. Inserting a hidden field into a page
         3. Embedding code so that it executes on startup
         4. Embedding code to catch a page submit
         5. Capturing the hidden field
         6. Referencing external scripts
         7. Storing an array of values in a page
      3. Using Client-Side Scripts in ASP.NET
         1. Identifying page elements by using script
         2. Using alert() to stop users cold
         3. confirm() a drastic action
         4. Creating a rollover effect
      4. Client-Side Script and Validation Controls
      5. How Auto-Postback Uses Client-Side Script
      6. Using Client-Side Callbacks
         1. Creating the Web page interface
         2. Preparing the JavaScript
         3. Building the server-side algorithm
         4. Implementing ICallbackEventHandler
         5. Generating the callback code
         6. Making the callback call
         7. Callback source code
9. IV. C#
   1. 1. C# Programming Basics
      1. Dealing with Keywords
      2. Working with Statements
         1. Types of statements
         2. White space
      3. Working with Blocks
      4. Creating Identifiers
      5. Crafting Comments
         1. Single-line comments
         2. Delimited comments
      6. Introducing Object-Oriented Programming
         1. Understanding classes and objects
         2. Coding a class
         3. Creating an object from a class
      7. Using .NET Framework Classes
      8. Declaring Variables
         1. Declaring two or more variables in one statement
         2. Declaring instance variables
         3. Declaring local variables
      9. Initializing Variables
         1. Initializing variables with assignment statements
         2. Initializing variables with initializers
      10. Working with Built-in Data Types
          1. Integer (int) types
          2. Floating-point types
          3. The decimal type
          4. The char type
          5. The boolean type
      11. Working with Strings
          1. Declaring and initializing strings
          2. Combining strings
          3. Converting strings to primitives
      12. Working with Arithmetic Operators
      13. Dividing Integers
      14. Combining Operators
      15. Using the Unary Plus and Minus Operators
      16. Using Increment and Decrement Operators
      17. Using the Assignment Operator
      18. Using Compound Assignment Operators
   2. 2. Doing Things Conditionally in C#
      1. Using Simple boolean Expressions
      2. Using if Statements
         1. Simple if statements
         2. if-else statements
         3. Nested if statements
         4. else-if statements
      3. Mr. Spock’s Favorite Operators (the Logical Ones, of Course)
         1. Using the ! operator
         2. Using the & and && operators
         3. Using the | and || operators
      4. Pulling the Ol’ Switch-er-oo
         1. Creating else-if monstrosities
         2. Using the switch statement
         3. A better version of the Voter-Error-Code Decoder program
   3. 3. Going Around in Circles (Or, Looping in C#)
      1. Your Basic while Loop
         1. The while statement
         2. A counting loop
      2. Breaking Out of a Loop
      3. Looping Forever
      4. Using the continue Statement
      5. Understanding do-while Loops
      6. The Famous for Loop
         1. The formal format of the for loop
         2. Scoping out the counter-variable
         3. Counting even numbers
         4. Counting backward
         5. for loops without bodies
         6. Ganging up your expressions
         7. Omitting expressions
         8. Breaking and continuing your for loops
      7. Nesting Your Loops
   4. 4. Using Methods and Exceptions
      1. The Basics of Making Methods
      2. A Simple Example
      3. Methods that Return Values
         1. Declaring the method’s return type
         2. Using the return statement to return the value
      4. Using Methods that Take Parameters
         1. Declaring parameters
         2. Understanding pass-by-value
      5. Understanding Exceptions
      6. Catching Exceptions
      7. Catching Different Exception Types
      8. Using the Exception Message
      9. Using a finally Block
   5. 5. Getting into Object-Oriented Programming
      1. What Is Object-Oriented Programming?
      2. Understanding Objects
         1. Objects have identity
         2. Objects have type
         3. Objects have state
         4. Objects have behavior
      3. The Life Cycle of an Object
      4. Working with Related Classes
         1. Inheritance
         2. Interfaces
      5. Declaring a Class
         1. Picking class names
         2. What goes in the class body
      6. Using Fields
      7. Creating Properties
      8. Using Methods
      9. Creating Constructors
         1. Basic constructors
         2. Default constructors
      10. Using this
      11. Working with Static Members
          1. Working with static fields or properties
          2. Using static methods
   6. 6. Working with Inheritance
      1. Understanding Inheritance
         1. A real-world explanation
         2. A fun explanation
         3. A business-world explanation
         4. Inheritance hierarchies
      2. Creating Derived Classes
      3. Overriding Methods
      4. Protecting Your Members
      5. Using this and base in Your Derived Classes
      6. Inheritance and Constructors
      7. Casting Up and Down
      8. Determining an Object’s Type: The is Operator
      9. Poly What?
10. V. Visual Basic
    1. 1. Mastering the Basics of Visual Basic
       1. Looking at Classes, Structures, and Modules
       2. Working with Source Files
       3. Creating Sub Procedures
       4. Working with Statements
       5. Creating Identifiers
       6. Adding Comments to Your Code
       7. Declaring Variables
       8. Working with Data Types
          1. Integer types
          2. Floating-point types
          3. The decimal type
          4. The char type
          5. The Boolean type
       9. Working with Strings
          1. Declaring and initializing strings
          2. Combining strings
          3. Converting strings
       10. Working with Arithmetic Operators
       11. Combining Operators
       12. Using Assignment Statements
       13. Using Assignment Operators
    2. 2. Controlling Your Programs
       1. Using If Statements
          1. The basic If statement
          2. The single-line If
          3. The Else clause
          4. Nesting If statements
          5. The ElseIf structure
       2. Using Conditional Expressions
       3. Getting Logical
          1. Using the Not operator
          2. Working with the And operator
          3. Utilizing the AndAlso operator
          4. Using the Or and OrElse operators
       4. Using the Select Case Statement
       5. Working with For/Next Loops
          1. Using While loops
          2. Utilizing Do loops
          3. Exiting a loop
          4. Nesting your loops
    3. 3. Working With Procedures, Exceptions, and Arrays
       1. Using Sub Procedures
       2. Working with Functions
       3. Getting Finicky about Parameters
       4. Understanding Exceptions
          1. Catching exceptions
          2. Using a Finally block
       5. Using Arrays
          1. Creating an array
          2. Initializing an array
          3. Using For loops with arrays
          4. Using two-dimensional arrays
    4. 4. Exploring Object-Oriented Programming
       1. Introducing Object-Oriented Programming
          1. Objects have identity
          2. Objects have type
          3. Objects have state
          4. Objects have behavior
       2. Creating Objects from Classes
       3. Declaring Classes
          1. Using fields
          2. Creating properties
          3. Using methods
          4. Creating constructors
       4. Using Shared Members
    5. 5. Demystifying Inheritance in VB.NET
       1. Understanding Inheritance
       2. Understanding Inheritance Hierarchies
       3. Creating a Derived Class
       4. Overriding Methods
       5. Using Protected Members
       6. Using the MyBase Keyword
       7. Using Casting with Inheritance
       8. Determining an Object’s Type
       9. Confronting Polymorphism
11. VI. Database Programming
    1. 1. Accessing Data with ADO.NET
       1. Understanding the Basics of Relational Databases
          1. Gathering data into tables
          2. Organizing with rows and columns
          3. Distinguishing data with primary keys and foreign keys
             1. Understanding the primary key
             2. Utilizing the foreign key
          4. Indexing your data for fast retrieval
       2. Working with Databases Using SQL
          1. Creating a table with CREATE TABLE
             1. Specifying a primary key
             2. Implementing a foreign key
             3. Creating an index with CREATE INDEX
          2. Deleting a table with DROP TABLE
          3. Getting data with SELECT
          4. Selecting only specific rows with the WHERE clause
          5. Adding data with INSERT
          6. Modifying data with UPDATE
          7. Removing data with DELETE
       3. Piecing Together SQL Statements
       4. Connecting to Data with ADO.NET
       5. Issuing Database Commands
          1. Calling statements that return no data
          2. Calling a stored procedure
          3. Calling statements that return one data item
       6. Displaying Data on a Web Page
       7. Retrieving Data from a Table
       8. Adding Security to Your SQL Statements — Read This!
    2. 2. Displaying and Editing Data for the Web
       1. Writing Data to a Page with a Label
       2. Binding to Data
          1. Creating a data source
          2. Using a data source
       3. Repeating Through a Result Set
          1. Setting server control properties in a Repeater control
          2. Adding some style to the Repeater control
          3. Altering the look of the Repeater control’s rows
       4. Creating a Data-Entry Page
    3. 3. Displaying and Editing with the GridView Control
       1. Setting Up the AdventureWorks Database
       2. Creating a GridView Control
       3. Formatting the Display
       4. Editing and Deleting Data with a GridView
       5. Sorting and Paging the Data in Your Grid
       6. Customizing the Columns in a Grid
          1. Specifying headers
          2. Displaying formatted text with the BoundField type
          3. Displaying images from a URL with the ImageField type
    4. 4. Displaying and Editing Detail Data
       1. Introducing the DetailsView and FormView Controls
       2. Displaying a Record with a DetailsView Control
          1. Moving through data by paging
          2. Using GridView and DetailsView controls together
          3. Editing Data with a DetailsView
          4. Searching and displaying details
       3. Displaying Record Details with a FormView Control
          1. Using GridView and FormView controls together
          2. Editing data with a FormView
    5. 5. Advanced Data Retrieval
       1. Ditching the Eval Method
       2. Binding to Different Kinds of Data
          1. Skipping the SQLDataSource
          2. Binding SqlDataAdapter results to controls
          3. Attaching arrays to data-bound controls
       3. Advanced Usage of Repeater Controls
          1. Creating a table around a Repeater
          2. Handling Repeater events
    6. 6. Reading XML and Generic Data
       1. Putting Together Some XML
       2. Transforming XML into a Formatted Table
       3. Displaying XML in a TreeView Control
       4. Accessing Generic Data with an ObjectDataSource Control
12. VII. Using the .NET Framework
    1. 1. Handling Strings
       1. Formatting Strings
          1. Supplying parameters other than strings
          2. Formatting the numeric parameters
          3. Formatting dates and times
          4. Customizing data formats
       2. Handling Special HTML Characters in Strings
       3. Splitting and Combining Strings
          1. Splitting strings
          2. Combining strings
       4. Converting to Strings with the ToString Method
       5. Converting Strings to Numbers
       6. Piecing Together Strings with a StringBuilder
    2. 2. Manipulating Dates and Times
       1. Getting the Current Date and Time
       2. Reading the Components of a DateTime Structure
       3. Streaming a DateTime Structure
       4. Handling Local Times Versus Universal Times
       5. Calculating with Dates
       6. Parsing a Date-Time String
    3. 3. Storing Objects in Specialized Collections
       1. Iterating Through a Collection
       2. Using the ArrayList Class
          1. Sorting a list
          2. Comparing different types
       3. Using the Hashtable Class
       4. Using the Stack Class
       5. Using the Queue Class
       6. Collecting Strings
          1. Using the StringCollection class
          2. Using the StringDictionary class
       7. Ordering Associations with the OrderedDictionary
    4. 4. Building Strongly Typed Collections with Generic Classes
       1. Understanding the Name Game
       2. Using the Generic List Class
       3. Working with the Generic LinkedList Class
       4. Employing the Generic Dictionary Class
       5. Using the Generic SortedDictionary Class
       6. Using the Generic Stack Class
       7. Working with the Generic Queue Class
13. VIII. Advanced ASP.NET Programming
    1. 1. Security: Using Login Controls
       1. Understanding Authentication and Authorization
       2. Implementing Forms Authentication
          1. Creating the Web site
          2. Adding pages to the resto Web site
          3. Implementing membership features
          4. Creating users
          5. Creating access rules for the pages
             1. Allowing anonymous users access to the root
             2. Denying access for all users
             3. Allowing access to one user — John Oliver
             4. Reviewing the access rules
          6. Using the Login control
             1. Adding the Login control to the page
             2. Testing the Login control
          7. Using the LoginName control
          8. Using the LoginStatus control
          9. Using the LoginView control
          10. Using the PasswordRecovery control
              1. Configuring the SMTP settings
              2. Adding the PasswordRecovery control to a page
              3. Testing the password recovery feature
          11. Using the ChangePassword control
          12. Assigning users to roles
          13. Giving permissions to a role
       3. Peering into the Application Programming Interface (API)
          1. Using the Membership and MembershipUser classes
             1. Adding members programmatically
             2. Deleting members programmatically
             3. Updating members programmatically
             4. Displaying all members programmatically
          2. Using the Roles class
             1. Adding a role programmatically
             2. Deleting a role programmatically
             3. Adding users to a role programmatically
             4. Listing all roles
    2. 2. Using Profiles
       1. Understanding Profiles
       2. Enabling Anonymous User Profiles
          1. Deciding what data to store
          2. Enabling profiles in the configuration file
          3. Generating the database
          4. Exploring the profile database
       3. Building the Profile-Based Web Page
          1. Adding control markup to the page
          2. Adding code to retrieve profile values
          3. Displaying the date and time in the chosen language
          4. Storing the language choice in the profile
          5. Storing the image choice in the profile
          6. Storing the background color in the profile
          7. Testing the profile properties
       4. Using Profiles with Authenticated Users
          1. Viewing the list of profiles
       5. Maintaining the Profiles Database
          1. Deleting inactive profiles
          2. Deleting a specific profile
       6. Using a Custom Profile Provider
          1. Obtaining the Access provider
          2. Building the Access provider
             1. Installing the starter kit
             2. Creating the Visual C# project
             3. Compiling the Dynamic Link Library (DLL)
             4. Configuring the Web for the Access provider
             5. Creating a test page for the Access provider
    3. 3. Site Navigation
       1. Understanding Site Navigation
       2. Using a Web.sitemap File
          1. Creating the Web.sitemap file
          2. Adding data to the sitemap file
          3. Using the SiteMapDataSource control
       3. Using the TreeView Control
          1. Creating a TreeView in Design view
             1. Adding nodes in Design view
             2. Setting TreeView styles in Design view
          2. Creating a TreeView programmatically
             1. Creating a TreeNode
             2. Defining the TreeView
             3. Defining the Root node
             4. Defining the child nodes of the Root node
             5. Adding individual Leaf nodes
             6. Adding styles to nodes
          3. Creating a TreeView from a sitemap
       4. Using the Menu Control
          1. Creating a Menu in Design view
             1. Adding items in Design view
             2. Setting Menu styles in Design view
          2. Creating a Menu programmatically
             1. Creating Menu items
             2. Building the base Menu
             3. Building the static items
             4. Adding child items
             5. Configuring item styles
          3. Creating a Menu from a sitemap
       5. Using the SiteMapPath Control
          1. Creating a SiteMapPath in Design view
          2. Creating a SiteMapPath control programmatically
             1. Building the SiteMapPath
             2. Adding style to the SiteMapPath
          3. Using an image as a path separator
    4. 4. Working with Themes
       1. Understanding Site Themes
       2. Creating an Opening Theme
          1. Adding the App_Themes folder
          2. Adding a .skin file
          3. Creating rough skin
          4. Refining the skin properties
          5. Testing the skin
       3. Letting Users Choose a Theme
          1. The Normal theme
          2. The Accountant theme
          3. A theme for lawyers
       4. Applying a Theme Programmatically
       5. Storing the Theme in a Profile
       6. Dos and Don’ts for Themes
       7. Shifting Definitions to Styles
       8. Overriding Themes and Who’s the Boss
          1. Theme vs StyleSheetTheme
          2. Implementing a global theme
          3. Exempting a page from theming
          4. Exempting a control from theming
       9. Where to Get Themes
    5. 5. Building Portals with Web Parts
       1. Understanding Portals
       2. An Example Web Portal
          1. Security for your custom page
          2. Personalization of your page
          3. Choice of language
          4. Choice of content
          5. Custom layout
          6. Show and hide content
          7. Themes
       3. Understanding the Parts of Web Parts
          1. Web parts infrastructure elements
          2. Personalization, logins, and Web parts
       4. Creating a Simple Web Part
          1. Faking a login for development purposes
          2. Create a page and Web-part zones
          3. Add some Web-part content
          4. Test the Web-part page
          5. Oops, I closed the Web part and it’s gone!
       5. Letting the User Move Web Parts Around
          1. Adding code to support Web-part Design mode
          2. Playing with Web-part Design mode
       6. Connecting Web Parts Together
          1. Creating a data consumer Web part
          2. Creating a data provider Web part
          3. Creating a connectable data provider
          4. Creating a data exchange interface
          5. Getting Web parts on the same page
             1. Setting up the page
             2. Adding Web-part zones to the page
             3. Adding Web parts to the zones
             4. Adding a static connection
             5. Adding visual appeal to the Web part
             6. Testing the connection
       7. Connecting Web Parts Dynamically
          1. Web parts à la mode
          2. Creating a mode selector
          3. Adding a ConnectionsZone interface
          4. Making connections
          5. Breaking connections
       8. Using the Editor Controls
          1. Adding EditorZone and AppearanceEditorPart controls
          2. Changing a Web part’s appearance
          3. Using other editor parts
       9. Letting Users Select Their Web Parts
          1. Adding CatalogZone and DeclarativeCatalogPart controls
          2. Selecting a part from the catalog
    6. 6. Creating and Consuming Web Services
       1. Understanding Web Services
          1. A supercomputer scenario
          2. A super solution
          3. The black box
          4. Exposing an API
          5. Not just HTTP
          6. Expanding demands
          7. It can be done
       2. Creating a Web Service
          1. Add a Web service to your project
          2. Analyze this!
          3. Replace the default namespace
          4. Add the RomanNumerals function
          5. A quick test of the Web service
          6. Other valuable information
          7. Providing information to clients
       3. Consuming a Web Service
          1. Using the service in a Web page and project
             1. Setting up the Web page
             2. Adding the Web reference
             3. Connecting the Web reference to the page
             4. Trying the Web service from the page
          2. Using the service from Windows Forms
          3. Using the service from VBScript
          4. Pick a platform
       4. Serving a Larger Helping of Data
          1. Preparing the RockHits Web service
             1. Creating some data
             2. Making a Web service
             3. Consuming the DataSet
       5. Securing a Web Service
14. ASP.NET 2.0 All-in-One Desk Reference For Dummies®
    1. Standard Controls
    2. Page Directives
    3. Master Page Controls
    4. Validation Controls
    5. Data Source Controls
    6. Data Controls
    7. Navigation Controls
    8. Login Controls