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