You are previewing Visual Studio® 2010 All-in-One For Dummies®.
O'Reilly logo
Visual Studio® 2010 All-in-One For Dummies®

Book Description

A comprehensive, easy-to-understand guide to Visual Studio 2010

Visual Studio is Microsoft's comprehensive development environment that encompasses the .NET Framework, various programming languages, and ASP.NET. Programmers love it for developing applications for mobile devices and the Web.

Because Visual Studio can be complex, the All-in-One For Dummies format makes it easy for beginners to grasp its different parts and get up to speed.

  • Visual Studio is a development environment used with various programming languages to create a variety of applications, including those for the Web and mobile devices

  • The updated Visual Studio 2010 features new emphasis on development for Windows 7, cloud computing, and enhanced Web and Silverlight

  • Visual Studio 2010 All-in-One For Dummies shows how to build applications using the enhanced productivity features of Visual Studio 2010

  • Minibooks cover a Visual Studio overview, getting started, building Windows 7 and cloud applications, data access, coding, and other IDE details

  • Ideal for new programmers or Java programmers who want to become proficient with Visual Studio

Visual Studio 2010 All-in-One For Dummies provides both a great instruction book for new programmers and a valuable reference for the more experienced.

Table of Contents

  1. Copyright
  2. About the Author
  3. Publisher's Acknowledgments
  4. Introduction
    1. Who Should Read This Book?
    2. About This Book
    3. Foolish Assumptions
    4. Conventions Used in This Book
      1. Stuff you type
      2. Menu commands
      3. Display messages
    5. How This Book Is Organized
      1. Book I: Visual Studio 2010 Overview
      2. Book II: Getting Started with Visual Studio
      3. Book III: Coding
      4. Book IV: Basics of Building Applications with Visual Studio 2010
      5. Book V: Getting Acquainted with Data Access
      6. Book VI: Going the Extra Mile
      7. Book VII: Extending the Family
    6. About the Companion Web Site
    7. Icons Used in This Book
  5. I. Visual Studio 2010 Overview
    1. 1. What Is Visual Studio?
      1. 1.1. From Source Code to Application: How Software Is Written
      2. 1.2. The Role of the Integrated Development Environment
        1. 1.2.1. Tools beyond the basic three
        2. 1.2.2. Enter Visual Studio
      3. 1.3. Visual Studio as the Hub
      4. 1.4. The Keeper of .NET
    2. 2. Exploring .NET
      1. 2.1. Following the Evolution of .NET
      2. 2.2. Getting Acquainted with the .NET Components
        1. 2.2.1. .NET freebies
        2. 2.2.2. No free lunch
      3. 2.3. Peering into the Future of .NET
    3. 3. Modern Software Development
      1. 3.1. Examining the Software Development Process
      2. 3.2. Looking at Software Engineering in Action
        1. 3.2.1. Have process, will repeat
        2. 3.2.2. Practicing what you preach
        3. 3.2.3. Building a developer's toolbox
        4. 3.2.4. Working with your partners in development
      3. 3.3. Components Defeat Monoliths
        1. 3.3.1. Architecture evolution
        2. 3.3.2. Component management in .NET
      4. 3.4. Managed Code Execution
      5. 3.5. Taking Out the Garbage
        1. 3.5.1. Allocating memory
        2. 3.5.2. Releasing memory
    4. 4. The Languages of .NET
      1. 4.1. More than Just a Pretty Face: A Windows Application
      2. 4.2. Looking at the Languages of .NET
        1. 4.2.1. Visual Basic
        2. 4.2.2. Visual C#
        3. 4.2.3. Visual C++
        4. 4.2.4. F#
      3. 4.3. Choosing the Right Language for the Job
      4. 4.4. Becoming a Good Programmer
        1. 4.4.1. Learn the syntax
        2. 4.4.2. Write your own code
    5. 5. The Many Editions of Visual Studio 2010
      1. 5.1. Making Sense of the Visual Studio Editions
        1. 5.1.1. Visual Studio Express Editions
        2. 5.1.2. Visual Studio Professional
        3. 5.1.3. Visual Studio Team System
      2. 5.2. Choosing the Right Edition
        1. 5.2.1. Subscribing to the Microsoft Developer Network
        2. 5.2.2. Weighing your options
      3. 5.3. Developing When It's a Team Effort
        1. 5.3.1. Managing projects with Team System
        2. 5.3.2. Architecting software
        3. 5.3.3. Developing software with Team System
        4. 5.3.4. Testing with tools
        5. 5.3.5. Collaborating with Visual Studio Team Foundation
    6. 6. New to Visual Studio 2010
      1. 6.1. Exploring Additional Programming Paradigms
        1. 6.1.1. Parallel programming
        2. 6.1.2. Cloud computing
      2. 6.2. Reaping the Benefits for Development Teams
        1. 6.2.1. Enhanced user interface
        2. 6.2.2. Better development lifecycle management
        3. 6.2.3. Better programming productivity
        4. 6.2.4. Better Web development tools
      3. 6.3. Gaining Databases Support
  6. II. Getting Started with Visual Studio
    1. 1. Installing Visual Studio Professional
      1. 1.1. Installing Versions Side by Side
        1. 1.1.1. Taking a look at all the .NETs
        2. 1.1.2. Getting help from Visual Studio 2010
      2. 1.2. Meeting System Requirements
      3. 1.3. Stepping through the Installation
      4. 1.4. Launching Visual Studio for the First Time
    2. 2. Browsing Visual Studio
      1. 2.1. Making Your Way around Visual Studio
      2. 2.2. Dealing with Windows Galore
        1. 2.2.1. Docking windows
        2. 2.2.2. Working with tabbed documents
        3. 2.2.3. Managing windows
      3. 2.3. Building Solutions with Visual Studio 2010
        1. 2.3.1. Using the Solution Explorer to manage solutions and projects
        2. 2.3.2. Working with solution and project menus
      4. 2.4. Using the Properties Window
      5. 2.5. Browsing Servers
      6. 2.6. Writing Code with the Code Editor
      7. 2.7. Using the Forms Designer
      8. 2.8. Taking a Look at Other Designers
    3. 3. Making Connections with Visual Studio
      1. 3.1. Getting Help
        1. 3.1.1. Opening and navigating the help documentation
        2. 3.1.2. Searching and filtering search results
        3. 3.1.3. Customizing the start page
      2. 3.2. Staying in Touch with the .NET Community
        1. 3.2.1. Pursuing certification
        2. 3.2.2. Viewing Webcasts
    4. 4. Upgrading .NET
      1. 4.1. Making the Business Case for Upgrading
        1. 4.1.1. What happens to Visual Studio code in an upgrade?
        2. 4.1.2. What are alternatives to upgrading?
        3. 4.1.3. How do you upgrade from pre-.NET languages?
      2. 4.2. Considering Your Conversion Strategies
        1. 4.2.1. Converting Windows applications and class libraries
        2. 4.2.2. Converting Web applications
        3. 4.2.3. Running Web applications side-by-side
      3. 4.3. Using Visual Studio 2010 with .NET 2.0
  7. III. Coding
    1. 1. Programming with Visual Studio 2010
      1. 1.1. Using the Code Editor
        1. 1.1.1. Simplifying your common tasks
          1. 1.1.1.1. Managing indents
          2. 1.1.1.2. Accessing formatting commands
          3. 1.1.1.3. Searching with Find and Replace
          4. 1.1.1.4. Getting on task
          5. 1.1.1.5. Collapsing code
          6. 1.1.1.6. Using IntelliSense
        2. 1.1.2. Using visual cues
        3. 1.1.3. Browsing and navigating code
      2. 1.2. Exploring Visual Basic and C#
        1. 1.2.1. Organizing programs
        2. 1.2.2. Getting started
          1. 1.2.2.1. Beginning at the beginning: The Main procedure
          2. 1.2.2.2. Declaring variables and assignment
          3. 1.2.2.3. Creating classes and working with objects
          4. 1.2.2.4. Creating executable code
          5. 1.2.2.5. Members and procedures
          6. 1.2.2.6. My Visual Basic
    2. 2. Understanding Data Types
      1. 2.1. The Rules of Data Types
      2. 2.2. Making a Declaration
      3. 2.3. The .NET Framework's Common Type System
        1. 2.3.1. Understanding the type hierarchy
        2. 2.3.2. Throwing it on the stack or the heap
        3. 2.3.3. Completing your assignments
        4. 2.3.4. Popular value types
        5. 2.3.5. Popular reference types
      4. 2.4. Creating Your Own Types
      5. 2.5. When There's More than One
        1. 2.5.1. Using arrays
        2. 2.5.2. Using System.Collections
        3. 2.5.3. Iterating through arrays and collections
        4. 2.5.4. Collections in the real world
      6. 2.6. Converting Types
      7. 2.7. Meet the Nullable Types
      8. 2.8. Browsing Types
        1. 2.8.1. Setting the scope
        2. 2.8.2. Setting the view
        3. 2.8.3. Viewing data types
        4. 2.8.4. Viewing source code
      9. 2.9. Accessing Types in Your Source Code
    3. 3. Get Some Class
      1. 3.1. Bringing Programs to Life the Object-Oriented Way
      2. 3.2. What's with Objects?
        1. 3.2.1. Modeling data with classes
          1. 3.2.1.1. Create objects to store data
      3. 3.3. Anatomy of a Class in .NET
        1. 3.3.1. Inheriting the services of System.Object
        2. 3.3.2. Using classes in your code
      4. 3.4. Using Class Designer
        1. 3.4.1. Exploring Class Designer
        2. 3.4.2. Designing classes
          1. 3.4.2.1. Creating a new class
          2. 3.4.2.2. Adding members to a class
          3. 3.4.2.3. Adding a new constructor method
          4. 3.4.2.4. Creating members using the class diagram
          5. 3.4.2.5. Creating associations
          6. 3.4.2.6. Generating code
        3. 3.4.3. Viewing existing classes
    4. 4. Wiring Up Events in the User Interface
      1. 4.1. Handling Events
        1. 4.1.1. Discovering events
          1. 4.1.1.1. Adding a component
          2. 4.1.1.2. Viewing a list of events
          3. 4.1.1.3. Looking up event information
        2. 4.1.2. Wiring up events and event handlers
          1. 4.1.2.1. Default events
          2. 4.1.2.2. Nondefault events
      2. 4.2. Getting a Life Cycle
        1. 4.2.1. Understanding life cycles in Windows applications
          1. 4.2.1.1. Startup events
          2. 4.2.1.2. Shutdown events
          3. 4.2.1.3. Visual Basic application events
          4. 4.2.1.4. Handling other events
        2. 4.2.2. Understanding Web page life cycles
          1. 4.2.2.1. Maintaining state in ASP.NET
          2. 4.2.2.2. Handling page requests
          3. 4.2.2.3. Handling postback events
          4. 4.2.2.4. Handling application events
    5. 5. Getting Productive with Visual Studio 2010
      1. 5.1. Sending Your Code to Boot Camp
        1. 5.1.1. Attending the naming convention
        2. 5.1.2. Calling all cars! FxCop to the rescue!
          1. 5.1.2.1. Downloading FxCop with Vista
          2. 5.1.2.2. Analyzing an assembly
          3. 5.1.2.3. Dealing with errors
        3. 5.1.3. Setting up FxCop as an external tool
      2. 5.2. It's Not Your Father's IntelliSense Any More
        1. 5.2.1. Using code snippets
        2. 5.2.2. Stub it out with method stubs
        3. 5.2.3. Adding using statements
        4. 5.2.4. Objectifying your code
          1. 5.2.4.1. Implementing abstract classes
          2. 5.2.4.2. Implementing interfaces
          3. 5.2.4.3. Overriding members
      3. 5.3. Creating XML Documentation
      4. 5.4. Factoring in the Refactoring
        1. 5.4.1. Refactoring with Class Designer
        2. 5.4.2. Refactoring C#
    6. 6. Exploring Web Services
      1. 6.1. Defining a Web Service
      2. 6.2. Saying Hello to Web Services
        1. 6.2.1. Understanding ASP.NET Web services
        2. 6.2.2. Adding a method
        3. 6.2.3. Testing Web services
          1. 6.2.3.1. Sending a GET request
          2. 6.2.3.2. Sending a POST request
          3. 6.2.3.3. Testing with SOAP
      3. 6.3. Consuming a Web Service
        1. 6.3.1. Communicating with a Web service
        2. 6.3.2. Finding Web services
        3. 6.3.3. Using a Web service in your application
          1. 6.3.3.1. Adding a Web reference
          2. 6.3.3.2. Binding with BindingSource
          3. 6.3.3.3. Putting your Web service in a Web application
          4. 6.3.3.4. Getting on the client side
    7. 7. Handling Exceptions and Debugging
      1. 7.1. Structured Exception Handling to the Rescue
        1. 7.1.1. Handling exceptions
          1. 7.1.1.1. Catching exceptions
          2. 7.1.1.2. Throwing exceptions
        2. 7.1.2. Using Visual Studio to manage exceptions
      2. 7.2. Understanding Debugging
        1. 7.2.1. Enabling debugging
        2. 7.2.2. Firing up the Debugger
          1. 7.2.2.1. Controlling execution
          2. 7.2.2.2. Breaking execution
          3. 7.2.2.3. Stepping through code
          4. 7.2.2.4. Viewing data with the Debugger
        3. 7.2.3. Exception handling in native C++ applications
        4. 7.2.4. Debugging for those special circumstances
        5. 7.2.5. Debugging generated code
    8. 8. Testing Code with Visual Studio
      1. 8.1. Defining Unit Testing
      2. 8.2. Unit Testing in Visual Studio
        1. 8.2.1. Creating unit tests
        2. 8.2.2. Running a battery of tests
      3. 8.3. Approaches to Unit Testing
        1. 8.3.1. Letting stubs do the tough testing
        2. 8.3.2. Simplifying testing with mocking objects
        3. 8.3.3. Stubs versus mocks
      4. 8.4. Automating Tests with Testing Frameworks
  8. IV. Basics of Building Applications with Visual Studio 2010
    1. 1. Getting Smart about Smart Clients
      1. 1.1. Switching from Fat Clients to Smart Clients
      2. 1.2. Designing Windows Forms
        1. 1.2.1. Creating your first smart client project
        2. 1.2.2. Saying, "Hello world!"
      3. 1.3. Taking Command from Control Central
        1. 1.3.1. Introducing the control toolbox
        2. 1.3.2. Customizing the toolbox
        3. 1.3.3. Adding controls to your form
      4. 1.4. Manipulating Controls
        1. 1.4.1. Formatting controls
        2. 1.4.2. Seeing the snaplines
        3. 1.4.3. Locking controls
        4. 1.4.4. Setting the tab order
        5. 1.4.5. Access a control's tasks with smart tags
      5. 1.5. Using the Properties Window
        1. 1.5.1. Setting properties
        2. 1.5.2. Responding to events
    2. 2. Building Smart Client User Interfaces
      1. 2.1. Building the Windows Container
        1. 2.1.1. Setting common form properties
        2. 2.1.2. Creating dialog boxes
        3. 2.1.3. Adding menus and toolbars
          1. 2.1.3.1. Using a ToolStripContainer
          2. 2.1.3.2. Controlling styles
        4. 2.1.4. Creating a Multiple Document Interface
          1. 2.1.4.1. Taking advantage of visual inheritance
      2. 2.2. Laying Out Your Controls
        1. 2.2.1. Grouping controls
        2. 2.2.2. Setting layout properties
          1. 2.2.2.1. Anchoring and docking
          2. 2.2.2.2. Using automatic sizing
          3. 2.2.2.3. Setting margins and padding
    3. 3. Building Visual C++ Applications
      1. 3.1. Getting to Know Visual C++
      2. 3.2. Introducing Visual C++ Templates and Wizards
      3. 3.3. Saying "Hello, Visual C++"
        1. 3.3.1. Creating managed applications
        2. 3.3.2. Creating unmanaged applications
          1. 3.3.2.1. Using a wizard to create an unmanaged application
          2. 3.3.2.2. Managing resources
          3. 3.3.2.3. External dependencies
          4. 3.3.2.4. Adding new external dependencies
          5. 3.3.2.5. Linking with external libraries
    4. 4. Building Web Applications
      1. 4.1. Exploring Microsoft's Web Design and Development Tools
      2. 4.2. Getting to Know the Visual Web Developer
        1. 4.2.1. Building better Web applications with ASP.NET
        2. 4.2.2. Understanding how ASP.NET pages are served
        3. 4.2.3. Creating Web sites
      3. 4.3. Saying "Hello, World Wide Web"
        1. 4.3.1. Viewing ASP.NET syntax
        2. 4.3.2. Adding content
      4. 4.4. Working with Web Sites
        1. 4.4.1. Adding new pages
        2. 4.4.2. Benefitting from the battle of the server controls
          1. 4.4.2.1. The syntax
          2. 4.4.2.2. Web server controls versus HTML server controls
          3. 4.4.2.3. User controls and custom controls
        3. 4.4.3. Changing your view
          1. 4.4.3.1. Straight to the Source (view)
          2. 4.4.3.2. Code editing
        4. 4.4.4. Running your Web site
      5. 4.5. Using Starter Kits
    5. 5. Using AJAX for Rich Web Pages
      1. 5.1. AJAX Explained: What It Does and Why You Should Consider Using It
        1. 5.1.1. ASP.NET postback architecture
        2. 5.1.2. Partial page updates
          1. 5.1.2.1. How JavaScript interacts in HTML documents
          2. 5.1.2.2. Using the JavaScript HttpRequest mechanism
          3. 5.1.2.3. Using the XML Data that is returned
      2. 5.2. Using AJAX Extensions
        1. 5.2.1. Creating your first AJAX Web application
        2. 5.2.2. Adding traditional ASP.NET controls to the form
        3. 5.2.3. Using AJAX to implement a partial page update pattern
        4. 5.2.4. Updating controls outside UpdatePanel
      3. 5.3. Using the AJAX Controls
        1. 5.3.1. Adding the AJAX Control Toolkit to the Visual Studio toolbox
        2. 5.3.2. Using AJAX controls from the Toolkit
    6. 6. Laying Out Your Web Site
      1. 6.1. Keeping Track of Input with Validation Controls
        1. 6.1.1. Adding a validation control
        2. 6.1.2. Testing a validation control
        3. 6.1.3. Handling multiple validation controls
      2. 6.2. Mapping Out Your Site Navigation
        1. 6.2.1. Adding a site map
        2. 6.2.2. Adding navigation controls
      3. 6.3. Managing Your Site's Appearance with Themes and Master Pages
        1. 6.3.1. Using themes and skins
          1. 6.3.1.1. Adding a theme to an existing site
          2. 6.3.1.2. Adding a theme as a style sheet
          3. 6.3.1.3. Defining skins
        2. 6.3.2. Mastering master pages
          1. 6.3.2.1. Adding content to your master page
          2. 6.3.2.2. Adding new content pages
          3. 6.3.2.3. Accessing the master page
      4. 6.4. Laying Out Web Pages with CSS
        1. 6.4.1. Introducing CSS basics
        2. 6.4.2. Adding and creating CSS styles
          1. 6.4.2.1. Adding a style
          2. 6.4.2.2. Building a style
        3. 6.4.3. Creating a page template with CSS
        4. 6.4.4. Applying styles to controls
    7. 7. Exploring ASP.NET Services
      1. 7.1. What a Wonderful Provider!
      2. 7.2. Managing State
        1. 7.2.1. Understanding view state
        2. 7.2.2. Using session state
      3. 7.3. Providing the Perks of Membership
        1. 7.3.1. Configuring the default database
        2. 7.3.2. Running a site on IIS
        3. 7.3.3. Securing membership content
        4. 7.3.4. Setting up a login page
      4. 7.4. Getting Personal
        1. 7.4.1. Saving visitor settings with profiles
        2. 7.4.2. Letting users customize with Web parts
    8. 8. Using Threads and Timers
      1. 8.1. Dividing Up Your Work with Threads and Thread Pools
      2. 8.2. Adding Threads to Your Application
      3. 8.3. Queuing Your Work Using the .NET Framework Thread Pool
        1. 8.3.1. Delegating responsibility using delegates
        2. 8.3.2. Returning data from delegates
      4. 8.4. Keeping Things on Schedule with Timers
    9. 9. Writing Network Applications
      1. 9.1. Creating an Application to Access Content on the Web
      2. 9.2. Creating a Simple Chat Application
        1. 9.2.1. The Chat Server Application
        2. 9.2.2. The Chat Client application
    10. 10. Parallel Programming
      1. 10.1. Introducing the .NET Task Parallel Library
        1. 10.1.1. Examining data parallelism in the TPL
        2. 10.1.2. Examining task parallelism in the TPL
          1. 10.1.2.1. Issuing requests without waiting for a response
          2. 10.1.2.2. Nesting complex tasks
      2. 10.2. Exploring Unmanaged C++ Parallel Programming with the Parallel Patterns Library (PPL)
      3. 10.3. Creating Parallel Queries with Parallel Language Integrated Query (PLINQ)
    11. 11. Writing Silverlight Applications
      1. 11.1. Getting Started with Silverlight
        1. 11.1.1. Creating a Silverlight application
        2. 11.1.2. Adding controls to your application
      2. 11.2. Creating Content for Web Applications
        1. 11.2.1. Adding style to your clock
        2. 11.2.2. Jazzing up your clock's text
        3. 11.2.3. Displaying the current time
        4. 11.2.4. Centering the clock's text
      3. 11.3. Adding Interactive Content to Enhance the Web Experience
    12. 12. Programming for the Cloud
      1. 12.1. Reaping the Benefits of Cloud Computing
      2. 12.2. Programming for the Cloud with Visual Studio
      3. 12.3. Deploying ASP.Net Web Services on the Cloud
      4. 12.4. Choosing a Web Role
      5. 12.5. Adding Content to Your Application
      6. 12.6. Deploying Your Applications on the Cloud
  9. V. Getting Acquainted with Data Access
    1. 1. Accessing Data with Visual Studio
      1. 1.1. Accessing Data with Visual Studio and .NET
        1. 1.1.1. Meeting ADO.NET
          1. 1.1.1.1. Starting at the data source
          2. 1.1.1.2. Retrieving data from data sources
          3. 1.1.1.3. Displaying data
          4. 1.1.1.4. Updating data
        2. 1.1.2. Exploring the Visual Studio data toolbox
      2. 1.2. Understanding Databases
        1. 1.2.1. Introducing relational databases
        2. 1.2.2. Understanding SQL
      3. 1.3. Dragging and Dropping Data
        1. 1.3.1. Preparing your computer to work with data
        2. 1.3.2. Adding data to Windows applications
        3. 1.3.3. Adding data to Web Forms
    2. 2. Show Me the Data
      1. 2.1. Adding Data Access in Windows Applications
        1. 2.1.1. Working with the Data Sources pane
        2. 2.1.2. Viewing data source objects
        3. 2.1.3. Adding data sources
        4. 2.1.4. Connecting to databases
        5. 2.1.5. Adding controls from the Data Sources pane
      2. 2.2. Getting Your Data in a Bind
        1. 2.2.1. Using BindingSource to connect to other data
        2. 2.2.2. Using BindingNavigator
        3. 2.2.3. Binding by using the Binding property
      3. 2.3. Creating Web Forms That Access Data
        1. 2.3.1. Meet the controls
          1. 2.3.1.1. Going to the source
          2. 2.3.1.2. Using databound Web server controls
        2. 2.3.2. Customizing layout with templates
        3. 2.3.3. Working with tasks and properties
          1. 2.3.3.1. Staying on the same page
          2. 2.3.3.2. AutoFormatting
        4. 2.3.4. Updating data with the DataSet Designer
        5. 2.3.5. Getting the view right with the GridView control
          1. 2.3.5.1. Sorting and paging
          2. 2.3.5.2. Editing and deleting
        6. 2.3.6. Binding to expressions
    3. 3. Working with Strongly Typed DataSets
      1. 3.1. Understanding the DataSet
        1. 3.1.1. Discerning typed versus untyped DataSets
        2. 3.1.2. Working with untyped DataSets
        3. 3.1.3. Flexing your strongly typed DataSets
        4. 3.1.4. DataSets and XML, together at last
      2. 3.2. Creating Typed DataSets
        1. 3.2.1. Creating a DataSet in a class library
        2. 3.2.2. Adding typed DataSets to existing projects
      3. 3.3. Exploring the DataSet Designer
        1. 3.3.1. Meet the players
        2. 3.3.2. Building a DataSet of your own
        3. 3.3.3. Adding database objects
        4. 3.3.4. Going beyond database tables
      4. 3.4. Shepherding Data
        1. 3.4.1. Using the TableAdapter Configuration Wizard
          1. 3.4.1.1. Generating stored procedures
          2. 3.4.1.2. Binding to existing stored procedures
        2. 3.4.2. Using the TableAdapter Query Configuration Wizard
      5. 3.5. Looking under the Hood of a Strongly Typed DataSet
        1. 3.5.1. Viewing code
        2. 3.5.2. Using partial classes
        3. 3.5.3. Viewing the source
      6. 3.6. Using a Typed DataSet
    4. 4. Working with XML
      1. 4.1. Exploring XML
      2. 4.2. Storing Data the XML Way
      3. 4.3. Creating a New XML File
      4. 4.4. Describing Data in an XML Document
      5. 4.5. Creating an XML Schema
        1. 4.5.1. Building an XML Schema
        2. 4.5.2. Using XML snippets
      6. 4.6. Transforming XML with Extensible Stylesheet Language Transformations
        1. 4.6.1. Writing an XSLT style sheet
        2. 4.6.2. Linking an XSLT file to another document
        3. 4.6.3. Staying on the path with XPath
      7. 4.7. XML and .NET
    5. 5. Under the Hood with ADO.NET
      1. 5.1. Meet the Players
      2. 5.2. Picking a Provider
        1. 5.2.1. Accessing providers
        2. 5.2.2. Objectifying the providers
      3. 5.3. Making Connections
        1. 5.3.1. Connecting to a database
        2. 5.3.2. Closing your connection
        3. 5.3.3. Stringing up connections
        4. 5.3.4. Building connection strings
          1. 5.3.4.1. Adding connection strings to Windows projects
          2. 5.3.4.2. Adding connection strings to Web projects
          3. 5.3.4.3. Building connection strings manually
          4. 5.3.4.4. Using the ADO.NET connection string builders
      4. 5.4. Using Commands
      5. 5.5. Reading Data with DataReaders
        1. 5.5.1. Stepping through data
        2. 5.5.2. Retrieving data with the Get accessors
        3. 5.5.3. Retrieving schema info
      6. 5.6. Caching Data with DataSets
        1. 5.6.1. Filling a DataSet
        2. 5.6.2. Updating data with the Update method
        3. 5.6.3. Using TableAdapters
        4. 5.6.4. Using transactions
      7. 5.7. Supporting XML with ADO.NET
      8. 5.8. Using ADO.NET in Your Applications
    6. 6. Using Visual Studio with SQL Server
      1. 6.1. Getting Acquainted with SQL Server 2008
        1. 6.1.1. Installing SQL Server Express Edition
        2. 6.1.2. Working with the SQL Server tools
        3. 6.1.3. Using the Adventure Works sample
      2. 6.2. Creating Database Projects
        1. 6.2.1. Managing scripts with database projects
          1. 6.2.1.1. Referencing databases
          2. 6.2.1.2. Creating scripts
          3. 6.2.1.3. Using the script editor
          4. 6.2.1.4. Executing scripts
        2. 6.2.2. Handling data with SQL Server projects
          1. 6.2.2.1. Enabling integration with SQL Server 2008
          2. 6.2.2.2. Saying, "Hello, SQL Server"
          3. 6.2.2.3. Executing CLR routines
          4. 6.2.2.4. Debugging SQL Server projects
      3. 6.3. Managing Your Database with Visual Database Tools
        1. 6.3.1. Using a local database
        2. 6.3.2. Adding tables with Table Designer
        3. 6.3.3. Adding queries and views
    7. 7. LINQ
      1. 7.1. Using LINQ to Query Integers
      2. 7.2. Finding Active Processes
      3. 7.3. Creating New Objects in the Query
  10. VI. Going the Extra Mile
    1. 1. Building Solutions and Projects
      1. 1.1. Understanding Solutions and Projects
        1. 1.1.1. The anatomy of a build
        2. 1.1.2. Using the Build menu
        3. 1.1.3. Selecting the active build and platform
        4. 1.1.4. Dealing with compiler errors and output
        5. 1.1.5. Using Configuration Manager
        6. 1.1.6. Setting project configurations
          1. 1.1.6.1. Using Project Designer
          2. 1.1.6.2. Using property pages
      2. 1.2. Managing Your Builds
        1. 1.2.1. Handling Lone Ranger builds
        2. 1.2.2. Creating master builds
        3. 1.2.3. Automating builds
    2. 2. Deployment Options
      1. 2.1. Understanding Deployment Basics
      2. 2.2. Deploying Smart Client Applications
        1. 2.2.1. From No Touch to ClickOnce
          1. 2.2.1.1. Accessing the published application
          2. 2.2.1.2. Checking out your publishing options
          3. 2.2.1.3. Signing your code
          4. 2.2.1.4. Updating your applications
        2. 2.2.2. Making a Windows Installer
          1. 2.2.2.1. Creating a setup project for an existing application
          2. 2.2.2.2. Putting the installer to work
          3. 2.2.2.3. Sharing assemblies
      3. 2.3. Deploying Web Applications
        1. 2.3.1. Using the Publish Web Site utility
        2. 2.3.2. Handling web.config files for testing and production
    3. 3. Checking Out Source Control
      1. 3.1. Using Source Code Control with Visual Studio
        1. 3.1.1. How source code control works
        2. 3.1.2. Getting ready for source control
      2. 3.2. Binding to a Source Control Provider
        1. 3.2.1. Adding a blank solution
        2. 3.2.2. Adding an existing solution
        3. 3.2.3. Adding a project to an existing solution
        4. 3.2.4. Breaking a binding
      3. 3.3. Performing Common Source Control Tasks
        1. 3.3.1. Retrieving files from source control
        2. 3.3.2. Editing source-controlled files
        3. 3.3.3. Checking files into source control
        4. 3.3.4. Retrieving a solution or project from source control
      4. 3.4. Source Code Control in the Real World
      5. 3.5. Going Beyond Integration
    4. 4. Writing Custom Facebook Applications
      1. 4.1. Creating and Registering Your Application with Facebook
      2. 4.2. Creating Your Application with Visual Studio 2010
        1. 4.2.1. Writing your application code
        2. 4.2.2. Connecting your application to Facebook
        3. 4.2.3. Laying out your application
      3. 4.3. Querying Data from Facebook
        1. 4.3.1. Finding out about your friends
        2. 4.3.2. Accessing weather data for your friend's location
      4. 4.4. Executing Your Application on Facebook
  11. VII. Extending the Family
    1. 1. Exploring Visual Studio Extensions
      1. 1.1. Extending Visual Studio
        1. 1.1.1. Adding administration and troubleshooting tools
        2. 1.1.2. Downloading new programming tools for Vista and Office
        3. 1.1.3. Trying out development resources and new server products
        4. 1.1.4. Keeping up with developer blogs and other news sources
      2. 1.2. Exploring AJAX and the Atlas Library
      3. 1.3. Looking Ahead to the Next Visual Studio
    2. 2. Being a Team Player with Visual Studio Team System
      1. 2.1. Introducing the Visual Studio Team System
        1. 2.1.1. Implementing VSTS
        2. 2.1.2. Discovering more about VSTS
      2. 2.2. Exploring the New Role-Based Features of Visual Studio 2010 Ultimate
        1. 2.2.1. Visual Studio Ultimate for software architects
        2. 2.2.2. Visual Studio 2010 Ultimate for software developers
        3. 2.2.3. Visual Studio 2010 Ultimate for software testers
        4. 2.2.4. Visual Studio 2010 Ultimate for database professionals
      3. 2.3. Getting to Know Team Foundation Server
        1. 2.3.1. Accessing Team Foundation Server
        2. 2.3.2. Creating a new team project
        3. 2.3.3. Browsing with the Team Explorer
        4. 2.3.4. Creating work items with Excel