Visual Studio® 2008 ALL-IN-ONE DESK REFERENCE FOR DUMMIES®

Visual Studio® 2008 ALL-IN-ONE DESK REFERENCE FOR DUMMIES®

by
Released April 2008
Publisher(s): For Dummies
ISBN: 9780470191088

Explore a preview version of Visual Studio® 2008 ALL-IN-ONE DESK REFERENCE FOR DUMMIES® right now.

O’Reilly members get unlimited access to live online training experiences, plus books, videos, and digital content from 200+ publishers.

Start your free trial

Book description

Visual Studio 2008 is packed with features that help you create better software and do it with less repetition and drudgery. Visual Studio 2008 All-In-One Desk Reference For Dummies shows you how to make the most of this cool suite of tools! It’s all here!

This comprehensive, seven-books-in-one guide gets you up and running with Visual Studio 2008 in no time. You’ll discover Microsoft’s vision for Visual Studio, get familiar with the .Net environment and languages, and learn how to install, browse, and make connections with Visual Studio. Soon, you’ll be building applications for Vista, Office 2007, and mobile devices; using AJAX and LINQ; and testing and debugging your programs. Discover how to:

  • Understand Visual Studio’s role in software development

  • Work with .Net languages

  • Develop applications for Vista

  • Build smart client interfaces

  • Use the visual data designer

  • Use Ajax controls

  • Streamline application deployment

  • Debug your applications

  • Explore ASP. NET services

  • Work with strongly typed data sets

  • Access data with Visual Studio

  • Program with Visual Studio 2008

  • Build professional reports with Crystal Reports

Fully updated with new information on Vista and .NET Framework 3.0 development, MS Office application development, and more, Visual Studio 2008 All-In-One Desk Reference For Dummies also features a companion Web site packed with sample projects, supplemental podcasts, and a support forum. You’ll never find a smarter way to get up to speed with Visual Studio 2008!

Table of contents

  1. Copyright
  2. About the Authors
  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 2008 Overview
      2. Book II: Getting Started
      3. Book III: Building Applications
      4. Book IV: Getting Acquainted with Data Access
      5. Book V: Coding
      6. Book VI: Going the Extra Mile
      7. Book VII: Extending Visual Studio
    6. About the Companion Web Site
    7. Icons Used in This Book
  5. I. Visual Studio 2008 Overview
    1. I.1. What Is Visual Studio?
      1. I.1.1. The Role of the Integrated Development Environment
        1. I.1.1.1. Tools beyond the basic three
        2. I.1.1.2. Enter Visual Studio
      2. I.1.2. Visual Studio as the Hub
      3. I.1.3. The Keeper of .NET
      4. I.1.4. New Features in Visual Studio 2008
    2. I.2. Exploring .NET
      1. I.2.1. Following the Evolution of .NET
      2. I.2.2. Getting Acquainted with the .NET Components
        1. I.2.2.1. .NET freebies
        2. I.2.2.2. No free lunch
      3. I.2.3. Peering into the Future of .NET
      4. I.2.4. Using the New Features in .NET
    3. I.3. Modern Software Development
      1. I.3.1. Software Engineering in Action
        1. I.3.1.1. Have process, will repeat
        2. I.3.1.2. Practicing what you preach
        3. I.3.1.3. Building a developer's toolbox
        4. I.3.1.4. Working with your partners in development
      2. I.3.2. Components Defeat Monoliths
        1. I.3.2.1. Architecture evolution
        2. I.3.2.2. Component management in .NET
      3. I.3.3. Managed Code Execution
      4. I.3.4. Taking Out the Garbage
        1. I.3.4.1. Allocating memory
        2. I.3.4.2. Releasing memory
    4. I.4. The Languages of .NET
      1. I.4.1. Looking at the Languages of .NET
        1. I.4.1.1. Visual Basic
        2. I.4.1.2. Visual C#
        3. I.4.1.3. Visual C++
        4. I.4.1.4. J#
      2. I.4.2. Choosing the Right Language for the Job
      3. I.4.3. Becoming a Good Programmer
        1. I.4.3.1. Learn the syntax
        2. I.4.3.2. Write your own code
        3. I.4.3.3. Spend some time in other language studies
    5. I.5. The Many Editions of Visual Studio 2008
      1. I.5.1. Making Sense of the Visual Studio Editions
        1. I.5.1.1. Visual Studio Express Editions
        2. I.5.1.2. Visual Studio Tools for Office
        3. I.5.1.3. Visual Studio Professional
        4. I.5.1.4. Visual Studio Team System
      2. I.5.2. Choosing the Right Edition
        1. I.5.2.1. Subscribing to the Microsoft Developer Network
        2. I.5.2.2. Weighing your options
      3. I.5.3. Developing When It's a Team Effort
        1. I.5.3.1. Managing projects with Team System
        2. I.5.3.2. Architecting software
        3. I.5.3.3. Developing software with Team System
        4. I.5.3.4. Testing with tools
        5. I.5.3.5. Collaborating with Visual Studio Team Foundation
      4. I.5.4. Taking a Visual Look Ahead
  6. II. Getting Started
    1. II.1. Installing Visual Studio Professional
      1. II.1.1. Installing Versions Side by Side
        1. II.1.1.1. Taking a look at all the .NETs
        2. II.1.1.2. Getting help from Visual Studio 2008
      2. II.1.2. Meeting System Requirements
      3. II.1.3. Stepping through the Installation
      4. II.1.4. Launching Visual Studio for the First Time
    2. II.2. Browsing Visual Studio
      1. II.2.1. Making Your Way around Visual Studio
      2. II.2.2. Dealing with Windows Galore
        1. II.2.2.1. Docking windows
        2. II.2.2.2. Working with tabbed documents
        3. II.2.2.3. Working with multiple documents
        4. II.2.2.4. Managing windows
      3. II.2.3. Building Solutions with Visual Studio 2008
        1. II.2.3.1. Using the Solution Explorer to manage solutions and projects
        2. II.2.3.2. Working with solution and project menus
      4. II.2.4. Using the Properties Window
      5. II.2.5. Browsing Servers
      6. II.2.6. Writing Code with the Code Editor
      7. II.2.7. Using the Forms Designer
      8. II.2.8. Taking a Look at Other Designers
    3. II.3. Making Connections with Visual Studio
      1. II.3.1. Getting Help
        1. II.3.1.1. Setting help viewing options
        2. II.3.1.2. Opening and navigating the help documentation
        3. II.3.1.3. Searching and filtering search results
        4. II.3.1.4. Customizing Document Explorer search and home pages
        5. II.3.1.5. Customizing the start page
      2. II.3.2. Staying in Touch with the .NET Community
        1. II.3.2.1. Pursuing certification
        2. II.3.2.2. Viewing Webcasts
    4. II.4. Upgrading .NET
      1. II.4.1. Making the Case for an Upgrade
        1. II.4.1.1. What happens to Visual Studio code in an upgrade?
        2. II.4.1.2. What are alternatives to upgrading?
        3. II.4.1.3. How do you upgrade from pre-.NET languages?
      2. II.4.2. Considering Your Conversion Strategies
        1. II.4.2.1. Converting Windows applications and class libraries
        2. II.4.2.2. Converting Web applications
        3. II.4.2.3. Running Web applications side by side
        4. II.4.2.4. Using Copy and Paste to control conversions
        5. II.4.2.5. Using the Visual Studio converters
      3. II.4.3. Using Visual Studio 2008 with .NET 2.0
  7. III. Building Applications
    1. III.1. Getting Smart about Smart Clients
      1. III.1.1. Switching from Fat Clients to Smart Clients
      2. III.1.2. Designing Windows Forms
        1. III.1.2.1. Creating your first smart client project
        2. III.1.2.2. Saying, "Hello world!"
      3. III.1.3. Taking Command from Control Central
        1. III.1.3.1. Introducing the control toolbox
        2. III.1.3.2. Customizing the toolbox
        3. III.1.3.3. Adding controls to your form
      4. III.1.4. Manipulating Controls
        1. III.1.4.1. Formatting controls
        2. III.1.4.2. Seeing the snaplines
        3. III.1.4.3. Locking controls
        4. III.1.4.4. Setting the tab order
        5. III.1.4.5. Access a control's tasks with smart tags
      5. III.1.5. Using the Properties Window
        1. III.1.5.1. Setting properties
        2. III.1.5.2. Responding to events
    2. III.2. Building Smart Client User Interfaces
      1. III.2.1. Building the Windows Container
        1. III.2.1.1. Setting common form properties
        2. III.2.1.2. Creating dialog boxes
        3. III.2.1.3. Adding menus and toolbars
          1. III.2.1.3.1. Using a ToolStripContainer
          2. III.2.1.3.2. Controlling styles
        4. III.2.1.4. Creating a Multiple Document Interface
        5. III.2.1.5. Taking advantage of visual inheritance
      2. III.2.2. Laying Out Your Controls
        1. III.2.2.1. Grouping controls
        2. III.2.2.2. Setting layout properties
          1. III.2.2.2.1. Anchoring and docking
          2. III.2.2.2.2. Using automatic sizing
          3. III.2.2.2.3. Setting margins and padding
    3. III.3. Building Visual C++ Applications
      1. III.3.1. Getting to Know Visual C++
      2. III.3.2. Introducing Visual C++ Templates and Wizards
      3. III.3.3. Saying "Hello, Visual C++"
        1. III.3.3.1. Creating managed applications
        2. III.3.3.2. Creating unmanaged applications
          1. III.3.3.2.1. Using a wizard to create an unmanaged application
          2. III.3.3.2.2. Managing resources
    4. III.4. Building Web Applications
      1. III.4.1. Getting to Know the Visual Web Developer
        1. III.4.1.1. Building better Web applications with ASP.NET
        2. III.4.1.2. Understanding how ASP.NET pages are served
        3. III.4.1.3. Creating Web sites
      2. III.4.2. Saying "Hello, World Wide Web"
        1. III.4.2.1. Viewing ASP.NET syntax
        2. III.4.2.2. Adding content
      3. III.4.3. Working with Web Sites
        1. III.4.3.1. Adding new pages
        2. III.4.3.2. Benefiting from the battle of the server controls
          1. III.4.3.2.1. The syntax
          2. III.4.3.2.2. Web server controls versus HTML server controls
          3. III.4.3.2.3. User controls and custom controls
        3. III.4.3.3. Changing your view
          1. III.4.3.3.1. Straight to the Source (view)
          2. III.4.3.3.2. Code editing
        4. III.4.3.4. Running your Web site
      4. III.4.4. Using Starter Kits
    5. III.5. Using AJAX For Rich Web Pages
      1. III.5.1. AJAX Explained: What It Does and Why You Should Consider Using It
        1. III.5.1.1. ASP.NET postback architecture
        2. III.5.1.2. Partial page updates
          1. III.5.1.2.1. How JavaScript interacts in HTML documents
          2. III.5.1.2.2. Using the JavaScript HttpRequest mechanism
          3. III.5.1.2.3. Using the XML Data that is returned
      2. III.5.2. Using AJAX Extensions
        1. III.5.2.1. Creating your first AJAX Web application
        2. III.5.2.2. Adding traditional ASP.NET controls to the form
        3. III.5.2.3. Using AJAX to implement a partial page update pattern
        4. III.5.2.4. Updating controls outside UpdatePanel
      3. III.5.3. Using the AJAX Controls
        1. III.5.3.1. Adding the AJAX Control Toolkit to the Visual Studio toolbox
        2. III.5.3.2. Using AJAX controls from the Toolkit
    6. III.6. Laying Out Your Site
      1. III.6.1. Keeping Track of Input with Validation Controls
        1. III.6.1.1. Adding a validation control
        2. III.6.1.2. Testing a validation control
        3. III.6.1.3. Handling multiple validation controls
      2. III.6.2. Mapping Out Your Site Navigation
        1. III.6.2.1. Adding a site map
        2. III.6.2.2. Adding navigation controls
      3. III.6.3. Managing Your Site's Appearance with Themes and Master Pages
        1. III.6.3.1. Using themes and skins
          1. III.6.3.1.1. Adding a theme to an existing site
          2. III.6.3.1.2. Adding a theme as a style sheet
          3. III.6.3.1.3. Defining skins
        2. III.6.3.2. Mastering master pages
          1. III.6.3.2.1. Adding content to your master page
          2. III.6.3.2.2. Adding new content pages
          3. III.6.3.2.3. Accessing the master page
      4. III.6.4. Laying Out Web Pages with CSS
        1. III.6.4.1. Introducing CSS basics
        2. III.6.4.2. Adding and creating CSS styles
        3. III.6.4.3. Creating a page template with CSS
        4. III.6.4.4. Applying styles to controls
    7. III.7. Exploring ASP.NET Services
      1. III.7.1. What a Wonderful Provider!
      2. III.7.2. Managing State
        1. III.7.2.1. Understanding view state
        2. III.7.2.2. Using session state
      3. III.7.3. Providing the Perks of Membership
        1. III.7.3.1. Configuring the default database
        2. III.7.3.2. Running a site on IIS
        3. III.7.3.3. Securing membership content
        4. III.7.3.4. Setting up a login page
      4. III.7.4. Getting Personal
        1. III.7.4.1. Saving visitor settings with profiles
        2. III.7.4.2. Letting users customize with Web parts
    8. III.8. Building a Mobile Application
      1. III.8.1. Developing Applications for Smart Devices
        1. III.8.1.1. Mobile everything
        2. III.8.1.2. Decisions, decisions
          1. III.8.1.2.1. Pick your platform
          2. III.8.1.2.2. Know that the natives are restless
          3. III.8.1.2.3. Go server-side
          4. III.8.1.2.4. Access the data
        3. III.8.1.3. Differences in smart-device development
      2. III.8.2. Saying, "Hello, Smartphone!"
        1. III.8.2.1. Getting your machine ready
        2. III.8.2.2. Creating a smart-device application
        3. III.8.2.3. Changing the application's target platform
        4. III.8.2.4. Setting up a C++ smart-device application
      3. III.8.3. Building Mobile Web Applications
        1. III.8.3.1. Setting up the mobile Web site
        2. III.8.3.2. Exploring device emulators
        3. III.8.3.3. Automating your connection
      4. III.8.4. Accommodating Special Considerations for Smart-Device Applications
  8. IV. Getting Acquainted with Data Access
    1. IV.1. Accessing Data with Visual Studio
      1. IV.1.1. Accessing Data with Visual Studio and .NET
        1. IV.1.1.1. Meeting ADO.NET
          1. IV.1.1.1.1. Starting at the data source
          2. IV.1.1.1.2. Retrieving data from data sources
          3. IV.1.1.1.3. Displaying data
          4. IV.1.1.1.4. Updating data
        2. IV.1.1.2. Exploring the Visual Studio data toolbox
      2. IV.1.2. Understanding Databases
        1. IV.1.2.1. Introducing relational databases
        2. IV.1.2.2. Understanding SQL
      3. IV.1.3. Dragging and Dropping Data
        1. IV.1.3.1. Preparing your computer to work with data
        2. IV.1.3.2. Adding data to Windows applications
        3. IV.1.3.3. Adding data to Web Forms
    2. IV.2. Show Me the Data
      1. IV.2.1. Adding Data Access in Windows Applications
        1. IV.2.1.1. Working with the Data Sources pane
        2. IV.2.1.2. Viewing data source objects
        3. IV.2.1.3. Adding data sources
        4. IV.2.1.4. Connecting to databases
        5. IV.2.1.5. Adding controls from the Data Sources pane
      2. IV.2.2. Getting Your Data in a Bind
        1. IV.2.2.1. Using BindingSource to connect to other data
        2. IV.2.2.2. Using BindingNavigator
        3. IV.2.2.3. Binding by using the Binding property
      3. IV.2.3. Creating Web Forms That Access Data
        1. IV.2.3.1. Meet the controls
          1. IV.2.3.1.1. Going to the source
          2. IV.2.3.1.2. Using databound Web server controls
        2. IV.2.3.2. Customizing layout with templates
        3. IV.2.3.3. Working with tasks and properties
          1. IV.2.3.3.1. Staying on the same page
          2. IV.2.3.3.2. AutoFormatting
        4. IV.2.3.4. Updating data with the DataSet Designer
        5. IV.2.3.5. Getting the view right with the GridView control
          1. IV.2.3.5.1. Sorting and paging
          2. IV.2.3.5.2. Editing and deleting
        6. IV.2.3.6. Binding to expressions
    3. IV.3. Working with Strongly Typed DataSets
      1. IV.3.1. Understanding the DataSet
        1. IV.3.1.1. Discerning typed versus untyped DataSets
        2. IV.3.1.2. Working with untyped DataSets
        3. IV.3.1.3. Flexing your strongly typed DataSets
        4. IV.3.1.4. DataSets and XML, together at last
      2. IV.3.2. Creating Typed DataSets
        1. IV.3.2.1. Creating a DataSet in a class library
        2. IV.3.2.2. Adding typed DataSets to existing projects
      3. IV.3.3. Exploring the DataSet Designer
        1. IV.3.3.1. Meet the players
        2. IV.3.3.2. Building a DataSet of your own
        3. IV.3.3.3. Adding database objects
        4. IV.3.3.4. Going beyond database tables
      4. IV.3.4. Shepherding Data
        1. IV.3.4.1. Using the TableAdapter Configuration Wizard
          1. IV.3.4.1.1. Generating stored procedures
          2. IV.3.4.1.2. Binding to existing stored procedures
        2. IV.3.4.2. Using the TableAdapter Query Configuration Wizard
      5. IV.3.5. Looking under the Hood of a Strongly Typed DataSet
        1. IV.3.5.1. Viewing code
        2. IV.3.5.2. Using partial classes
        3. IV.3.5.3. Viewing the source
      6. IV.3.6. Using a Typed DataSet
    4. IV.4. Working with XML
      1. IV.4.1. Storing Data the XML Way
        1. IV.4.1.1. Creating a new XML file
        2. IV.4.1.2. Describing data in an XML document
      2. IV.4.2. Creating an XML Schema
        1. IV.4.2.1. Building an XML Schema
        2. IV.4.2.2. Using XML snippets
      3. IV.4.3. Transforming XML with Extensible Stylesheet Language Transformations
        1. IV.4.3.1. Writing an XSLT style sheet
        2. IV.4.3.2. Linking an XSLT file to another document
        3. IV.4.3.3. Staying on the path with XPath
      4. IV.4.4. XML and .NET
    5. IV.5. Under the Hood with ADO.NET
      1. IV.5.1. Meet the Players
      2. IV.5.2. Picking a Provider
        1. IV.5.2.1. Accessing providers
        2. IV.5.2.2. Objectifying the providers
      3. IV.5.3. Making Connections
        1. IV.5.3.1. Connecting to a database
        2. IV.5.3.2. Closing your connection
        3. IV.5.3.3. Stringing up connections
        4. IV.5.3.4. Building connection strings
          1. IV.5.3.4.1. Adding connection strings to Windows projects
          2. IV.5.3.4.2. Adding connection strings to Web projects
          3. IV.5.3.4.3. Building connection strings manually
          4. IV.5.3.4.4. Using the ADO.NET connection string builders
      4. IV.5.4. Using Commands
      5. IV.5.5. Reading Data with DataReaders
        1. IV.5.5.1. Stepping through data
        2. IV.5.5.2. Retrieving data with the Get accessors
        3. IV.5.5.3. Retrieving schema info
      6. IV.5.6. Caching Data with DataSets
        1. IV.5.6.1. Filling a DataSet
        2. IV.5.6.2. Updating data with the Update method
        3. IV.5.6.3. Using TableAdapters
        4. IV.5.6.4. Using transactions
      7. IV.5.7. Supporting XML with ADO.NET
      8. IV.5.8. Using ADO.NET in Your Applications
    6. IV.6. Using Visual Studio with SQL Server
      1. IV.6.1. Getting Acquainted with SQL Server 2005
        1. IV.6.1.1. Installing SQL Server Developer Edition
        2. IV.6.1.2. Working with the SQL Server tools
        3. IV.6.1.3. Using the Adventure Works sample
      2. IV.6.2. Creating Database Projects
        1. IV.6.2.1. Managing scripts with database projects
          1. IV.6.2.1.1. Referencing databases
          2. IV.6.2.1.2. Creating scripts
          3. IV.6.2.1.3. Using the script editor
          4. IV.6.2.1.4. Executing scripts
        2. IV.6.2.2. Handling data with SQL Server projects
          1. IV.6.2.2.1. Enabling integration with SQL Server 2005
          2. IV.6.2.2.2. Saying, "Hello, SQL Server"
          3. IV.6.2.2.3. Executing CLR routines
          4. IV.6.2.2.4. Debugging SQL Server projects
      3. IV.6.3. Managing Your Database with Visual Database Tools
        1. IV.6.3.1. Using a local database
        2. IV.6.3.2. Adding tables with Table Designer
        3. IV.6.3.3. Adding queries and views
    7. IV.7. LINQ
      1. IV.7.1. Using LINQ to Query Integers
      2. IV.7.2. Finding Active Processes
      3. IV.7.3. Creating New Objects in the Query
  9. V. Coding
    1. V.1. Programming with Visual Studio 2008
      1. V.1.1. Using the Code Editor
        1. V.1.1.1. Simplifying your common tasks
          1. V.1.1.1.1. Managing indents
          2. V.1.1.1.2. Accessing formatting commands
          3. V.1.1.1.3. Searching with Find and Replace
          4. V.1.1.1.4. Getting on task
          5. V.1.1.1.5. Collapsing code
          6. V.1.1.1.6. Using IntelliSense
        2. V.1.1.2. Using visual cues
        3. V.1.1.3. Browsing and navigating code
      2. V.1.2. Exploring Visual Basic and C#
        1. V.1.2.1. Organizing programs
        2. V.1.2.2. Getting started
          1. V.1.2.2.1. Beginning at the beginning: The Main procedure
          2. V.1.2.2.2. Declaring variables and assignment
          3. V.1.2.2.3. Creating classes and working with objects
          4. V.1.2.2.4. Creating executable code
          5. V.1.2.2.5. Members and procedures
          6. V.1.2.2.6. My Visual Basic
    2. V.2. Understanding Data Types
      1. V.2.1. The Rules of Data Types
      2. V.2.2. Making a Declaration
      3. V.2.3. The .NET Framework's Common Type System
        1. V.2.3.1. Understanding the type hierarchy
        2. V.2.3.2. Throwing it on the stack or the heap
        3. V.2.3.3. Completing your assignments
        4. V.2.3.4. Popular value types
        5. V.2.3.5. Popular reference types
      4. V.2.4. Creating Your Own Types
      5. V.2.5. When There's More than One
        1. V.2.5.1. Using arrays
        2. V.2.5.2. Using System.Collections
        3. V.2.5.3. Iterating through arrays and collections
        4. V.2.5.4. Collections in the real world
      6. V.2.6. Converting Types
      7. V.2.7. Meet the Nullable Types
      8. V.2.8. Browsing Types
        1. V.2.8.1. Setting the scope
        2. V.2.8.2. Setting the view
        3. V.2.8.3. Viewing data types
        4. V.2.8.4. Viewing source code
      9. V.2.9. Accessing Types in Your Source Code
    3. V.3. Get Some Class
      1. V.3.1. Bringing Programs to Life the Object-Oriented Way
      2. V.3.2. What's with Objects?
      3. V.3.3. Anatomy of a Class in .NET
        1. V.3.3.1. Inheriting the services of System.Object
        2. V.3.3.2. Using classes in your code
      4. V.3.4. Using Class Designer
        1. V.3.4.1. Exploring Class Designer
        2. V.3.4.2. Designing classes
          1. V.3.4.2.1. Creating a new class
          2. V.3.4.2.2. Adding members to a class
          3. V.3.4.2.3. Creating associations
          4. V.3.4.2.4. Generating code
        3. V.3.4.3. Viewing existing classes
        4. V.3.4.4. Working with objects
    4. V.4. Wiring Up Events in the User Interface
      1. V.4.1. Handling Events
        1. V.4.1.1. Discovering events
        2. V.4.1.2. Wiring up events and event handlers
      2. V.4.2. Getting a Life Cycle
        1. V.4.2.1. Understanding life cycles in Windows applications
        2. V.4.2.2. Understanding Web page life cycles
          1. V.4.2.2.1. Handling postback events
          2. V.4.2.2.2. Handling application events
    5. V.5. Getting Productive with Visual Studio 2008
      1. V.5.1. Sending Your Code to Boot Camp
        1. V.5.1.1. Attending the naming convention
        2. V.5.1.2. Calling all cars! FxCop to the rescue!
        3. V.5.1.3. Setting up FxCop as an external tool
      2. V.5.2. It's Not Your Father's IntelliSense Anymore
        1. V.5.2.1. Using code snippets
        2. V.5.2.2. Stub it out with method stubs
        3. V.5.2.3. Adding using statements
        4. V.5.2.4. Objectifying your code
          1. V.5.2.4.1. Implementing abstract classes
          2. V.5.2.4.2. Implementing interfaces
          3. V.5.2.4.3. Overriding members
      3. V.5.3. Creating XML Documentation
      4. V.5.4. Factoring in the Refactoring
        1. V.5.4.1. Refactoring with Class Designer
        2. V.5.4.2. Refactoring C#
    6. V.6. Exploring Web Services
      1. V.6.1. Saying Hello to Web Services
        1. V.6.1.1. Understanding ASP.NET Web services
        2. V.6.1.2. Adding a method
        3. V.6.1.3. Testing Web services
          1. V.6.1.3.1. Sending a GET request
          2. V.6.1.3.2. Sending a POST request
          3. V.6.1.3.3. Testing with SOAP
      2. V.6.2. Consuming a Web Service
        1. V.6.2.1. Communicating with a Web service
        2. V.6.2.2. Finding Web services
        3. V.6.2.3. Using a Web service in your application
          1. V.6.2.3.1. Adding a Web reference
          2. V.6.2.3.2. Binding with BindingSource
          3. V.6.2.3.3. Putting your Web service in a Web application
          4. V.6.2.3.4. Getting on the client side
    7. V.7. Handling Exceptions and Debugging
      1. V.7.1. Structured Exception Handling to the Rescue
        1. V.7.1.1. Handling exceptions
          1. V.7.1.1.1. Catching exceptions
          2. V.7.1.1.2. Throwing exceptions
        2. V.7.1.2. Using Visual Studio to manage exceptions
      2. V.7.2. Understanding Debugging
        1. V.7.2.1. Enabling debugging
        2. V.7.2.2. Firing up the Debugger
          1. V.7.2.2.1. Controlling execution
          2. V.7.2.2.2. Breaking execution
          3. V.7.2.2.3. Stepping through code
          4. V.7.2.2.4. Viewing data with the Debugger
        3. V.7.2.3. Debugging for those special circumstances
        4. V.7.2.4. Debugging generated code
    8. V.8. Testing Code with Visual Studio
      1. V.8.1. Defining Unit Testing
      2. V.8.2. Unit Testing in Visual Studio
        1. V.8.2.1. Creating unit tests
        2. V.8.2.2. Running a battery of tests
        3. V.8.2.3. Writing better code
      3. V.8.3. Approaches to Unit Testing
        1. V.8.3.1. Letting stubs do the tough testing
        2. V.8.3.2. Simplifying testing with mocking objects
        3. V.8.3.3. The stubbies versus the mockers
      4. V.8.4. Using the Object Test Bench
      5. V.8.5. Automating Tests with Testing Frameworks
  10. VI. Going the Extra Mile
    1. VI.1. Building Solutions and Projects
      1. VI.1.1. Understanding Solutions and Projects
        1. VI.1.1.1. The anatomy of a build
        2. VI.1.1.2. Using the Build menu
        3. VI.1.1.3. Selecting the active build and platform
        4. VI.1.1.4. Dealing with compiler errors and output
        5. VI.1.1.5. Using Configuration Manager
        6. VI.1.1.6. Setting project configurations
          1. VI.1.1.6.1. Using Project Designer
          2. VI.1.1.6.2. Using property pages
      2. VI.1.2. Managing Your Builds
        1. VI.1.2.1. Handling Lone Ranger builds
        2. VI.1.2.2. Creating master builds
        3. VI.1.2.3. Automating builds
    2. VI.2. Deployment Options
      1. VI.2.1. Understanding Deployment Basics
      2. VI.2.2. Deploying Smart Client Applications
        1. VI.2.2.1. From No Touch to ClickOnce
          1. VI.2.2.1.1. Accessing the published application
          2. VI.2.2.1.2. Checking out your publishing options
          3. VI.2.2.1.3. Signing your code
          4. VI.2.2.1.4. Updating your applications
        2. VI.2.2.2. Making a Windows Installer
          1. VI.2.2.2.1. Creating a setup project for an existing application
          2. VI.2.2.2.2. Putting the installer to work
          3. VI.2.2.2.3. Sharing assemblies
      3. VI.2.3. Deploying Web Applications
        1. VI.2.3.1. Using the Publish Web Site utility
        2. VI.2.3.2. Handling web.config files for testing and production
    3. VI.3. Checking Out Source Control
      1. VI.3.1. Using Source Code Control with Visual Studio
        1. VI.3.1.1. How source code control works
        2. VI.3.1.2. Getting ready for source control
      2. VI.3.2. Binding to a Source Control Provider
        1. VI.3.2.1. Adding a blank solution
        2. VI.3.2.2. Adding an existing solution
        3. VI.3.2.3. Adding a project to an existing solution
        4. VI.3.2.4. Breaking a binding
      3. VI.3.3. Performing Common Source Control Tasks
        1. VI.3.3.1. Retrieving files from source control
        2. VI.3.3.2. Editing source-controlled files
        3. VI.3.3.3. Checking files into source control
        4. VI.3.3.4. Retrieving a solution or project from source control
      4. VI.3.4. Source Code Control in the Real World
      5. VI.3.5. Going Beyond Integration
    4. VI.4. Building Professional Reports with Crystal Reports
      1. VI.4.1. Choosing the Right Crystal Edition
      2. VI.4.2. Creating Reports with Crystal Reports
      3. VI.4.3. Connecting to Data Sources
        1. VI.4.3.1. Getting to know your databases
        2. VI.4.3.2. Using Database Expert
      4. VI.4.4. Using the Crystal Reports Report Designer
        1. VI.4.4.1. Adding content to a report
          1. VI.4.4.1.1. Exploring Field Explorer
          2. VI.4.4.1.2. Accessing commands with toolbars
          3. VI.4.4.1.3. Formatting objects
  11. VII. Extending Visual Studio
    1. VII.1. Exploring Visual Studio Extensions
      1. VII.1.1. Extending Visual Studio
        1. VII.1.1.1. Adding administration and troubleshooting tools
        2. VII.1.1.2. Downloading new programming tools for Vista and Office
        3. VII.1.1.3. Trying out development resources and new server products
        4. VII.1.1.4. Keeping up with developer blogs and other news sources
      2. VII.1.2. Exploring AJAX and the Atlas Library
      3. VII.1.3. Looking Ahead to the Next Visual Studio
    2. VII.2. Being a Team Player with Visual Studio Team System
      1. VII.2.1. Introducing the Visual Studio Team System
      2. VII.2.2. Exploring the New Role-Based Editions
        1. VII.2.2.1. Visual Studio Team System for Software Architects
        2. VII.2.2.2. Visual Studio Team System for Software Developers
        3. VII.2.2.3. Visual Studio Team System for Software Testers
        4. VII.2.2.4. Visual Studio Team System for Database Professionals
      3. VII.2.3. Getting to Know Team Foundation Server
        1. VII.2.3.1. Accessing Team Foundation Server
        2. VII.2.3.2. Creating a new team project
        3. VII.2.3.3. Browsing with the Team Explorer
        4. VII.2.3.4. Creating work items with Excel
    3. VII.3. Using Visual Studio with Vista and Office 2007
      1. VII.3.1. Exploring Vista
      2. VII.3.2. Getting Started with Vista
        1. VII.3.2.1. Creating Vista applications
          1. VII.3.2.1.1. SDK samples
          2. VII.3.2.1.2. Windows Presentation Foundation
          3. VII.3.2.1.3. Extensible Application Markup Language
        2. VII.3.2.2. Creating workflow applications
      3. VII.3.3. Getting Ready for Office 2007
      4. VII.3.4. Going Virtual

Product information

  • Title: Visual Studio® 2008 ALL-IN-ONE DESK REFERENCE FOR DUMMIES®
  • Author(s):
  • Release date: April 2008
  • Publisher(s): For Dummies
  • ISBN: 9780470191088