book

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

Name: Visual Studio® 2008 ALL-IN-ONE DESK REFERENCE FOR DUMMIES®
ISBN: 9780470191088

by Vanessa L. Williams, Rick Leinecker

April 2008

Beginner

816 pages

16h 15m

English

For Dummies

Read now

Unlock full access

Copyright
About the Authors
Introduction
Who Should Read This Book?About This BookFoolish AssumptionsConventions Used in This BookStuff you typeMenu commandsDisplay messagesHow This Book Is OrganizedBook I: Visual Studio 2008 OverviewBook II: Getting StartedBook III: Building ApplicationsBook IV: Getting Acquainted with Data AccessBook V: CodingBook VI: Going the Extra MileBook VII: Extending Visual StudioAbout the Companion Web SiteIcons Used in This Book
I. Visual Studio 2008 Overview
I.1. What Is Visual Studio?
I.1.1. The Role of the Integrated Development EnvironmentI.1.1.1. Tools beyond the basic threeI.1.1.2. Enter Visual StudioI.1.2. Visual Studio as the HubI.1.3. The Keeper of .NETI.1.4. New Features in Visual Studio 2008
I.2. Exploring .NET
I.2.1. Following the Evolution of .NETI.2.2. Getting Acquainted with the .NET ComponentsI.2.2.1. .NET freebiesI.2.2.2. No free lunchI.2.3. Peering into the Future of .NETI.2.4. Using the New Features in .NET
I.3. Modern Software Development
I.3.1. Software Engineering in ActionI.3.1.1. Have process, will repeatI.3.1.2. Practicing what you preachI.3.1.3. Building a developer's toolboxI.3.1.4. Working with your partners in developmentI.3.2. Components Defeat MonolithsI.3.2.1. Architecture evolutionI.3.2.2. Component management in .NETI.3.3. Managed Code ExecutionI.3.4. Taking Out the GarbageI.3.4.1. Allocating memoryI.3.4.2. Releasing memory
I.4. The Languages of .NET
I.4.1. Looking at the Languages of .NETI.4.1.1. Visual BasicI.4.1.2. Visual C#I.4.1.3. Visual C++I.4.1.4. J#I.4.2. Choosing the Right Language for the JobI.4.3. Becoming a Good ProgrammerI.4.3.1. Learn the syntaxI.4.3.2. Write your own codeI.4.3.3. Spend some time in other language studies
I.5. The Many Editions of Visual Studio 2008
I.5.1. Making Sense of the Visual Studio EditionsI.5.1.1. Visual Studio Express EditionsI.5.1.2. Visual Studio Tools for OfficeI.5.1.3. Visual Studio ProfessionalI.5.1.4. Visual Studio Team SystemI.5.2. Choosing the Right EditionI.5.2.1. Subscribing to the Microsoft Developer NetworkI.5.2.2. Weighing your optionsI.5.3. Developing When It's a Team EffortI.5.3.1. Managing projects with Team SystemI.5.3.2. Architecting softwareI.5.3.3. Developing software with Team SystemI.5.3.4. Testing with toolsI.5.3.5. Collaborating with Visual Studio Team FoundationI.5.4. Taking a Visual Look Ahead

II. Getting Started
II.1. Installing Visual Studio Professional
II.1.1. Installing Versions Side by SideII.1.1.1. Taking a look at all the .NETsII.1.1.2. Getting help from Visual Studio 2008II.1.2. Meeting System RequirementsII.1.3. Stepping through the InstallationII.1.4. Launching Visual Studio for the First Time
II.2. Browsing Visual Studio
II.2.1. Making Your Way around Visual StudioII.2.2. Dealing with Windows GaloreII.2.2.1. Docking windowsII.2.2.2. Working with tabbed documentsII.2.2.3. Working with multiple documentsII.2.2.4. Managing windowsII.2.3. Building Solutions with Visual Studio 2008II.2.3.1. Using the Solution Explorer to manage solutions and projectsII.2.3.2. Working with solution and project menusII.2.4. Using the Properties WindowII.2.5. Browsing ServersII.2.6. Writing Code with the Code EditorII.2.7. Using the Forms DesignerII.2.8. Taking a Look at Other Designers
II.3. Making Connections with Visual Studio
II.3.1. Getting HelpII.3.1.1. Setting help viewing optionsII.3.1.2. Opening and navigating the help documentationII.3.1.3. Searching and filtering search resultsII.3.1.4. Customizing Document Explorer search and home pagesII.3.1.5. Customizing the start pageII.3.2. Staying in Touch with the .NET CommunityII.3.2.1. Pursuing certificationII.3.2.2. Viewing Webcasts
II.4. Upgrading .NET
II.4.1. Making the Case for an UpgradeII.4.1.1. What happens to Visual Studio code in an upgrade?II.4.1.2. What are alternatives to upgrading?II.4.1.3. How do you upgrade from pre-.NET languages?II.4.2. Considering Your Conversion StrategiesII.4.2.1. Converting Windows applications and class librariesII.4.2.2. Converting Web applicationsII.4.2.3. Running Web applications side by sideII.4.2.4. Using Copy and Paste to control conversionsII.4.2.5. Using the Visual Studio convertersII.4.3. Using Visual Studio 2008 with .NET 2.0
III. Building Applications
III.1. Getting Smart about Smart Clients
III.1.1. Switching from Fat Clients to Smart ClientsIII.1.2. Designing Windows FormsIII.1.2.1. Creating your first smart client projectIII.1.2.2. Saying, "Hello world!"III.1.3. Taking Command from Control CentralIII.1.3.1. Introducing the control toolboxIII.1.3.2. Customizing the toolboxIII.1.3.3. Adding controls to your formIII.1.4. Manipulating ControlsIII.1.4.1. Formatting controlsIII.1.4.2. Seeing the snaplinesIII.1.4.3. Locking controlsIII.1.4.4. Setting the tab orderIII.1.4.5. Access a control's tasks with smart tagsIII.1.5. Using the Properties WindowIII.1.5.1. Setting propertiesIII.1.5.2. Responding to events
III.2. Building Smart Client User Interfaces
III.2.1. Building the Windows ContainerIII.2.1.1. Setting common form propertiesIII.2.1.2. Creating dialog boxesIII.2.1.3. Adding menus and toolbarsIII.2.1.3.1. Using a ToolStripContainerIII.2.1.3.2. Controlling stylesIII.2.1.4. Creating a Multiple Document InterfaceIII.2.1.5. Taking advantage of visual inheritanceIII.2.2. Laying Out Your ControlsIII.2.2.1. Grouping controlsIII.2.2.2. Setting layout propertiesIII.2.2.2.1. Anchoring and dockingIII.2.2.2.2. Using automatic sizingIII.2.2.2.3. Setting margins and padding
III.3. Building Visual C++ Applications
III.3.1. Getting to Know Visual C++III.3.2. Introducing Visual C++ Templates and WizardsIII.3.3. Saying "Hello, Visual C++"III.3.3.1. Creating managed applicationsIII.3.3.2. Creating unmanaged applicationsIII.3.3.2.1. Using a wizard to create an unmanaged applicationIII.3.3.2.2. Managing resources
III.4. Building Web Applications
III.4.1. Getting to Know the Visual Web DeveloperIII.4.1.1. Building better Web applications with ASP.NETIII.4.1.2. Understanding how ASP.NET pages are servedIII.4.1.3. Creating Web sitesIII.4.2. Saying "Hello, World Wide Web"III.4.2.1. Viewing ASP.NET syntaxIII.4.2.2. Adding contentIII.4.3. Working with Web SitesIII.4.3.1. Adding new pagesIII.4.3.2. Benefiting from the battle of the server controlsIII.4.3.2.1. The syntaxIII.4.3.2.2. Web server controls versus HTML server controlsIII.4.3.2.3. User controls and custom controlsIII.4.3.3. Changing your viewIII.4.3.3.1. Straight to the Source (view)III.4.3.3.2. Code editingIII.4.3.4. Running your Web siteIII.4.4. Using Starter Kits
III.5. Using AJAX For Rich Web Pages
III.5.1. AJAX Explained: What It Does and Why You Should Consider Using ItIII.5.1.1. ASP.NET postback architectureIII.5.1.2. Partial page updatesIII.5.1.2.1. How JavaScript interacts in HTML documentsIII.5.1.2.2. Using the JavaScript HttpRequest mechanismIII.5.1.2.3. Using the XML Data that is returnedIII.5.2. Using AJAX ExtensionsIII.5.2.1. Creating your first AJAX Web applicationIII.5.2.2. Adding traditional ASP.NET controls to the formIII.5.2.3. Using AJAX to implement a partial page update patternIII.5.2.4. Updating controls outside UpdatePanelIII.5.3. Using the AJAX ControlsIII.5.3.1. Adding the AJAX Control Toolkit to the Visual Studio toolboxIII.5.3.2. Using AJAX controls from the Toolkit
III.6. Laying Out Your Site
III.6.1. Keeping Track of Input with Validation ControlsIII.6.1.1. Adding a validation controlIII.6.1.2. Testing a validation controlIII.6.1.3. Handling multiple validation controlsIII.6.2. Mapping Out Your Site NavigationIII.6.2.1. Adding a site mapIII.6.2.2. Adding navigation controlsIII.6.3. Managing Your Site's Appearance with Themes and Master PagesIII.6.3.1. Using themes and skinsIII.6.3.1.1. Adding a theme to an existing siteIII.6.3.1.2. Adding a theme as a style sheetIII.6.3.1.3. Defining skinsIII.6.3.2. Mastering master pagesIII.6.3.2.1. Adding content to your master pageIII.6.3.2.2. Adding new content pagesIII.6.3.2.3. Accessing the master pageIII.6.4. Laying Out Web Pages with CSSIII.6.4.1. Introducing CSS basicsIII.6.4.2. Adding and creating CSS stylesIII.6.4.3. Creating a page template with CSSIII.6.4.4. Applying styles to controls
III.7. Exploring ASP.NET Services
III.7.1. What a Wonderful Provider!III.7.2. Managing StateIII.7.2.1. Understanding view stateIII.7.2.2. Using session stateIII.7.3. Providing the Perks of MembershipIII.7.3.1. Configuring the default databaseIII.7.3.2. Running a site on IISIII.7.3.3. Securing membership contentIII.7.3.4. Setting up a login pageIII.7.4. Getting PersonalIII.7.4.1. Saving visitor settings with profilesIII.7.4.2. Letting users customize with Web parts
III.8. Building a Mobile Application
III.8.1. Developing Applications for Smart DevicesIII.8.1.1. Mobile everythingIII.8.1.2. Decisions, decisionsIII.8.1.2.1. Pick your platformIII.8.1.2.2. Know that the natives are restlessIII.8.1.2.3. Go server-sideIII.8.1.2.4. Access the dataIII.8.1.3. Differences in smart-device developmentIII.8.2. Saying, "Hello, Smartphone!"III.8.2.1. Getting your machine readyIII.8.2.2. Creating a smart-device applicationIII.8.2.3. Changing the application's target platformIII.8.2.4. Setting up a C++ smart-device applicationIII.8.3. Building Mobile Web ApplicationsIII.8.3.1. Setting up the mobile Web siteIII.8.3.2. Exploring device emulatorsIII.8.3.3. Automating your connectionIII.8.4. Accommodating Special Considerations for Smart-Device Applications
IV. Getting Acquainted with Data Access
IV.1. Accessing Data with Visual Studio
IV.1.1. Accessing Data with Visual Studio and .NETIV.1.1.1. Meeting ADO.NETIV.1.1.1.1. Starting at the data sourceIV.1.1.1.2. Retrieving data from data sourcesIV.1.1.1.3. Displaying dataIV.1.1.1.4. Updating dataIV.1.1.2. Exploring the Visual Studio data toolboxIV.1.2. Understanding DatabasesIV.1.2.1. Introducing relational databasesIV.1.2.2. Understanding SQLIV.1.3. Dragging and Dropping DataIV.1.3.1. Preparing your computer to work with dataIV.1.3.2. Adding data to Windows applicationsIV.1.3.3. Adding data to Web Forms
IV.2. Show Me the Data
IV.2.1. Adding Data Access in Windows ApplicationsIV.2.1.1. Working with the Data Sources paneIV.2.1.2. Viewing data source objectsIV.2.1.3. Adding data sourcesIV.2.1.4. Connecting to databasesIV.2.1.5. Adding controls from the Data Sources paneIV.2.2. Getting Your Data in a BindIV.2.2.1. Using BindingSource to connect to other dataIV.2.2.2. Using BindingNavigatorIV.2.2.3. Binding by using the Binding propertyIV.2.3. Creating Web Forms That Access DataIV.2.3.1. Meet the controlsIV.2.3.1.1. Going to the sourceIV.2.3.1.2. Using databound Web server controlsIV.2.3.2. Customizing layout with templatesIV.2.3.3. Working with tasks and propertiesIV.2.3.3.1. Staying on the same pageIV.2.3.3.2. AutoFormattingIV.2.3.4. Updating data with the DataSet DesignerIV.2.3.5. Getting the view right with the GridView controlIV.2.3.5.1. Sorting and pagingIV.2.3.5.2. Editing and deletingIV.2.3.6. Binding to expressions
IV.3. Working with Strongly Typed DataSets
IV.3.1. Understanding the DataSetIV.3.1.1. Discerning typed versus untyped DataSetsIV.3.1.2. Working with untyped DataSetsIV.3.1.3. Flexing your strongly typed DataSetsIV.3.1.4. DataSets and XML, together at lastIV.3.2. Creating Typed DataSetsIV.3.2.1. Creating a DataSet in a class libraryIV.3.2.2. Adding typed DataSets to existing projectsIV.3.3. Exploring the DataSet DesignerIV.3.3.1. Meet the playersIV.3.3.2. Building a DataSet of your ownIV.3.3.3. Adding database objectsIV.3.3.4. Going beyond database tablesIV.3.4. Shepherding DataIV.3.4.1. Using the TableAdapter Configuration WizardIV.3.4.1.1. Generating stored proceduresIV.3.4.1.2. Binding to existing stored proceduresIV.3.4.2. Using the TableAdapter Query Configuration WizardIV.3.5. Looking under the Hood of a Strongly Typed DataSetIV.3.5.1. Viewing codeIV.3.5.2. Using partial classesIV.3.5.3. Viewing the sourceIV.3.6. Using a Typed DataSet
IV.4. Working with XML
IV.4.1. Storing Data the XML WayIV.4.1.1. Creating a new XML fileIV.4.1.2. Describing data in an XML documentIV.4.2. Creating an XML SchemaIV.4.2.1. Building an XML SchemaIV.4.2.2. Using XML snippetsIV.4.3. Transforming XML with Extensible Stylesheet Language TransformationsIV.4.3.1. Writing an XSLT style sheetIV.4.3.2. Linking an XSLT file to another documentIV.4.3.3. Staying on the path with XPathIV.4.4. XML and .NET
IV.5. Under the Hood with ADO.NET
IV.5.1. Meet the PlayersIV.5.2. Picking a ProviderIV.5.2.1. Accessing providersIV.5.2.2. Objectifying the providersIV.5.3. Making ConnectionsIV.5.3.1. Connecting to a databaseIV.5.3.2. Closing your connectionIV.5.3.3. Stringing up connectionsIV.5.3.4. Building connection stringsIV.5.3.4.1. Adding connection strings to Windows projectsIV.5.3.4.2. Adding connection strings to Web projectsIV.5.3.4.3. Building connection strings manuallyIV.5.3.4.4. Using the ADO.NET connection string buildersIV.5.4. Using CommandsIV.5.5. Reading Data with DataReadersIV.5.5.1. Stepping through dataIV.5.5.2. Retrieving data with the Get accessorsIV.5.5.3. Retrieving schema infoIV.5.6. Caching Data with DataSetsIV.5.6.1. Filling a DataSetIV.5.6.2. Updating data with the Update methodIV.5.6.3. Using TableAdaptersIV.5.6.4. Using transactionsIV.5.7. Supporting XML with ADO.NETIV.5.8. Using ADO.NET in Your Applications
IV.6. Using Visual Studio with SQL Server
IV.6.1. Getting Acquainted with SQL Server 2005IV.6.1.1. Installing SQL Server Developer EditionIV.6.1.2. Working with the SQL Server toolsIV.6.1.3. Using the Adventure Works sampleIV.6.2. Creating Database ProjectsIV.6.2.1. Managing scripts with database projectsIV.6.2.1.1. Referencing databasesIV.6.2.1.2. Creating scriptsIV.6.2.1.3. Using the script editorIV.6.2.1.4. Executing scriptsIV.6.2.2. Handling data with SQL Server projectsIV.6.2.2.1. Enabling integration with SQL Server 2005IV.6.2.2.2. Saying, "Hello, SQL Server"IV.6.2.2.3. Executing CLR routinesIV.6.2.2.4. Debugging SQL Server projectsIV.6.3. Managing Your Database with Visual Database ToolsIV.6.3.1. Using a local databaseIV.6.3.2. Adding tables with Table DesignerIV.6.3.3. Adding queries and views
IV.7. LINQ
IV.7.1. Using LINQ to Query IntegersIV.7.2. Finding Active ProcessesIV.7.3. Creating New Objects in the Query
V. Coding
V.1. Programming with Visual Studio 2008
V.1.1. Using the Code EditorV.1.1.1. Simplifying your common tasksV.1.1.1.1. Managing indentsV.1.1.1.2. Accessing formatting commandsV.1.1.1.3. Searching with Find and ReplaceV.1.1.1.4. Getting on taskV.1.1.1.5. Collapsing codeV.1.1.1.6. Using IntelliSenseV.1.1.2. Using visual cuesV.1.1.3. Browsing and navigating codeV.1.2. Exploring Visual Basic and C#V.1.2.1. Organizing programsV.1.2.2. Getting startedV.1.2.2.1. Beginning at the beginning: The Main procedureV.1.2.2.2. Declaring variables and assignmentV.1.2.2.3. Creating classes and working with objectsV.1.2.2.4. Creating executable codeV.1.2.2.5. Members and proceduresV.1.2.2.6. My Visual Basic
V.2. Understanding Data Types
V.2.1. The Rules of Data TypesV.2.2. Making a DeclarationV.2.3. The .NET Framework's Common Type SystemV.2.3.1. Understanding the type hierarchyV.2.3.2. Throwing it on the stack or the heapV.2.3.3. Completing your assignmentsV.2.3.4. Popular value typesV.2.3.5. Popular reference typesV.2.4. Creating Your Own TypesV.2.5. When There's More than OneV.2.5.1. Using arraysV.2.5.2. Using System.CollectionsV.2.5.3. Iterating through arrays and collectionsV.2.5.4. Collections in the real worldV.2.6. Converting TypesV.2.7. Meet the Nullable TypesV.2.8. Browsing TypesV.2.8.1. Setting the scopeV.2.8.2. Setting the viewV.2.8.3. Viewing data typesV.2.8.4. Viewing source codeV.2.9. Accessing Types in Your Source Code
V.3. Get Some Class
V.3.1. Bringing Programs to Life the Object-Oriented WayV.3.2. What's with Objects?V.3.3. Anatomy of a Class in .NETV.3.3.1. Inheriting the services of System.ObjectV.3.3.2. Using classes in your codeV.3.4. Using Class DesignerV.3.4.1. Exploring Class DesignerV.3.4.2. Designing classesV.3.4.2.1. Creating a new classV.3.4.2.2. Adding members to a classV.3.4.2.3. Creating associationsV.3.4.2.4. Generating codeV.3.4.3. Viewing existing classesV.3.4.4. Working with objects
V.4. Wiring Up Events in the User Interface
V.4.1. Handling EventsV.4.1.1. Discovering eventsV.4.1.2. Wiring up events and event handlersV.4.2. Getting a Life CycleV.4.2.1. Understanding life cycles in Windows applicationsV.4.2.2. Understanding Web page life cyclesV.4.2.2.1. Handling postback eventsV.4.2.2.2. Handling application events
V.5. Getting Productive with Visual Studio 2008
V.5.1. Sending Your Code to Boot CampV.5.1.1. Attending the naming conventionV.5.1.2. Calling all cars! FxCop to the rescue!V.5.1.3. Setting up FxCop as an external toolV.5.2. It's Not Your Father's IntelliSense AnymoreV.5.2.1. Using code snippetsV.5.2.2. Stub it out with method stubsV.5.2.3. Adding using statementsV.5.2.4. Objectifying your codeV.5.2.4.1. Implementing abstract classesV.5.2.4.2. Implementing interfacesV.5.2.4.3. Overriding membersV.5.3. Creating XML DocumentationV.5.4. Factoring in the RefactoringV.5.4.1. Refactoring with Class DesignerV.5.4.2. Refactoring C#
V.6. Exploring Web Services
V.6.1. Saying Hello to Web ServicesV.6.1.1. Understanding ASP.NET Web servicesV.6.1.2. Adding a methodV.6.1.3. Testing Web servicesV.6.1.3.1. Sending a GET requestV.6.1.3.2. Sending a POST requestV.6.1.3.3. Testing with SOAPV.6.2. Consuming a Web ServiceV.6.2.1. Communicating with a Web serviceV.6.2.2. Finding Web servicesV.6.2.3. Using a Web service in your applicationV.6.2.3.1. Adding a Web referenceV.6.2.3.2. Binding with BindingSourceV.6.2.3.3. Putting your Web service in a Web applicationV.6.2.3.4. Getting on the client side
V.7. Handling Exceptions and Debugging
V.7.1. Structured Exception Handling to the RescueV.7.1.1. Handling exceptionsV.7.1.1.1. Catching exceptionsV.7.1.1.2. Throwing exceptionsV.7.1.2. Using Visual Studio to manage exceptionsV.7.2. Understanding DebuggingV.7.2.1. Enabling debuggingV.7.2.2. Firing up the DebuggerV.7.2.2.1. Controlling executionV.7.2.2.2. Breaking executionV.7.2.2.3. Stepping through codeV.7.2.2.4. Viewing data with the DebuggerV.7.2.3. Debugging for those special circumstancesV.7.2.4. Debugging generated code
V.8. Testing Code with Visual Studio
V.8.1. Defining Unit TestingV.8.2. Unit Testing in Visual StudioV.8.2.1. Creating unit testsV.8.2.2. Running a battery of testsV.8.2.3. Writing better codeV.8.3. Approaches to Unit TestingV.8.3.1. Letting stubs do the tough testingV.8.3.2. Simplifying testing with mocking objectsV.8.3.3. The stubbies versus the mockersV.8.4. Using the Object Test BenchV.8.5. Automating Tests with Testing Frameworks
VI. Going the Extra Mile
VI.1. Building Solutions and Projects
VI.1.1. Understanding Solutions and ProjectsVI.1.1.1. The anatomy of a buildVI.1.1.2. Using the Build menuVI.1.1.3. Selecting the active build and platformVI.1.1.4. Dealing with compiler errors and outputVI.1.1.5. Using Configuration ManagerVI.1.1.6. Setting project configurationsVI.1.1.6.1. Using Project DesignerVI.1.1.6.2. Using property pagesVI.1.2. Managing Your BuildsVI.1.2.1. Handling Lone Ranger buildsVI.1.2.2. Creating master buildsVI.1.2.3. Automating builds
VI.2. Deployment Options
VI.2.1. Understanding Deployment BasicsVI.2.2. Deploying Smart Client ApplicationsVI.2.2.1. From No Touch to ClickOnceVI.2.2.1.1. Accessing the published applicationVI.2.2.1.2. Checking out your publishing optionsVI.2.2.1.3. Signing your codeVI.2.2.1.4. Updating your applicationsVI.2.2.2. Making a Windows InstallerVI.2.2.2.1. Creating a setup project for an existing applicationVI.2.2.2.2. Putting the installer to workVI.2.2.2.3. Sharing assembliesVI.2.3. Deploying Web ApplicationsVI.2.3.1. Using the Publish Web Site utilityVI.2.3.2. Handling web.config files for testing and production
VI.3. Checking Out Source Control
VI.3.1. Using Source Code Control with Visual StudioVI.3.1.1. How source code control worksVI.3.1.2. Getting ready for source controlVI.3.2. Binding to a Source Control ProviderVI.3.2.1. Adding a blank solutionVI.3.2.2. Adding an existing solutionVI.3.2.3. Adding a project to an existing solutionVI.3.2.4. Breaking a bindingVI.3.3. Performing Common Source Control TasksVI.3.3.1. Retrieving files from source controlVI.3.3.2. Editing source-controlled filesVI.3.3.3. Checking files into source controlVI.3.3.4. Retrieving a solution or project from source controlVI.3.4. Source Code Control in the Real WorldVI.3.5. Going Beyond Integration
VI.4. Building Professional Reports with Crystal Reports
VI.4.1. Choosing the Right Crystal EditionVI.4.2. Creating Reports with Crystal ReportsVI.4.3. Connecting to Data SourcesVI.4.3.1. Getting to know your databasesVI.4.3.2. Using Database ExpertVI.4.4. Using the Crystal Reports Report DesignerVI.4.4.1. Adding content to a reportVI.4.4.1.1. Exploring Field ExplorerVI.4.4.1.2. Accessing commands with toolbarsVI.4.4.1.3. Formatting objects
VII. Extending Visual Studio
VII.1. Exploring Visual Studio Extensions
VII.1.1. Extending Visual StudioVII.1.1.1. Adding administration and troubleshooting toolsVII.1.1.2. Downloading new programming tools for Vista and OfficeVII.1.1.3. Trying out development resources and new server productsVII.1.1.4. Keeping up with developer blogs and other news sourcesVII.1.2. Exploring AJAX and the Atlas LibraryVII.1.3. Looking Ahead to the Next Visual Studio
VII.2. Being a Team Player with Visual Studio Team System
VII.2.1. Introducing the Visual Studio Team SystemVII.2.2. Exploring the New Role-Based EditionsVII.2.2.1. Visual Studio Team System for Software ArchitectsVII.2.2.2. Visual Studio Team System for Software DevelopersVII.2.2.3. Visual Studio Team System for Software TestersVII.2.2.4. Visual Studio Team System for Database ProfessionalsVII.2.3. Getting to Know Team Foundation ServerVII.2.3.1. Accessing Team Foundation ServerVII.2.3.2. Creating a new team projectVII.2.3.3. Browsing with the Team ExplorerVII.2.3.4. Creating work items with Excel
VII.3. Using Visual Studio with Vista and Office 2007
VII.3.1. Exploring VistaVII.3.2. Getting Started with VistaVII.3.2.1. Creating Vista applicationsVII.3.2.1.1. SDK samplesVII.3.2.1.2. Windows Presentation FoundationVII.3.2.1.3. Extensible Application Markup LanguageVII.3.2.2. Creating workflow applicationsVII.3.3. Getting Ready for Office 2007VII.3.4. Going Virtual

Overview

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!

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Visual Studio® 2010 All-in-One For Dummies®

Publisher Resources

ISBN: 9780470191088Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills