Table of contents for Professional Visual studio team system / Jean-Luc David ... [et al.].

Bibliographic record and links to related information available from the Library of Congress catalog.

Note: Contents data are machine generated based on pre-publication provided by the publisher. Contents may have variations from the printed book or be incomplete or contain other coding.


Counter
Contents
Professional Visual Studio 2005 Team System 
Table of Contents
Chapter 1: Introducing the Visual Designers
Why Design Visually?
Microsoft's Modeling Strategy
Model Driven Development
Domain Specific Languages
Software Factories
From Objects to Services
Objects and Compile-time Reuse
Components and Deploy-time Reuse
Distributed Components and Run-time Reuse
Distributed Services and the Service Oriented Architecture
Team Architect Visual Designers
Application Designer
Logical Datacenter Designer
System Designer and Deployment Designer
Class Designer
Code Synchronization
Introducing the StockBroker Case Study
Designer Relationships and Team System Integration
Process Flow (Roles and Activities)
Object Flow (Artifacts)
Settings and Constraints
Source Control and Item Tracking
Introducing the System Definition Model
Meta Models
SDM and the Team System Meta Model
What about UML?
How can I capitalize on my investment in UML skills?
How can I capitalize on my investment in UML artifacts?
What if I really want a fully integrated UML capability?
A Retained Role for Visio for Enterprise Architects
Summary
Chapter 2: Application Modeling Using Application Designer
Application Designer Toolbox and Prototypes
General Designer
Endpoints
Applications
Designing the Distributed System
The Design Scenario
Design Characteristics and UML Comparison
Reproducing the Design using Application Designer
Specifying Database Connection Properties
Specifying Endpoint Details
Defining Your Own Endpoint Prototype
Representing an Existing Service
Implementing the Applications
A Note about SDM Files
The MarketMaker Implementation
Modifications to DealingService.cs
Test-run of the MarketMaker Application
The StockBroker Implementation
StockQuoteService.vb
DealingService.vb
Test-run of the StockBroker Application
The StockQuoteApp Implementation
Default.aspx
Default.aspx.cs
Test-run of the StockQuoteApp Web Application
The DealingApp Implementation
DealingForm.vb code
Test-run of the DealingApp Windows Application
Application Designer Additional Features
Model-Code Synchronization
Reverse Engineering Existing Solutions
Settings and Constraints Editor
Printing and Copying Diagrams
Application Designer Limitations and Workarounds
Modeling .NET Remoting and DCOM Applications
Modeling Windows Service and Console Application
Dynamic Modeling
Summary
Chapter 3: Logical Infrastructure Modeling using Logical Datacenter Designer
Logical Datacenter Designer Toolbox and Prototypes
General
Endpoints
Logical Servers
Sample Logical Datacenter
Datacenter Zones
DMZ1
DMZ2
IntranetZone
Endpoint Styles
The UML Deployment Diagram: Similar, but not the same
Defining a Logical Datacenter for the StockBroker Applications
The MarketMaker Zone
The StockMarket Zone
The StockBroker Zone
The Client Zone
Settings and Constraints
Constraints versus Settings
GenericServer Settings and Constraints
IISWebServer Settings and Constraints
WebSiteEndpoint Settings and Constraints
ZoneEndpoint Settings and Constraints
Custom Settings and User Defined Constraints
Custom Settings
User Defined Constraints
Import IIS Settings Wizard
Defining your own Reusable Prototypes
StockBrokerZone Prototype
Team Working with Prototypes
Summary
Chapter 4: Defining Systems and Evaluating Deployments using System Designer and Deployment Designer
Introducing System Designer and Deployment Designer
Introducing System Designer
Introducing Deployment Designer
Toolbox and System View
Defining a Default Deployment from Application Designer
The System View
Binding Applications to Servers
Prohibited Bindings
Validating the Deployment
Differences between Default Deployments and System Deployments
Defining and Deploying Systems
System Definition for the Full Application Design
System Definition for a Subset of the Application Design
Define Deployment
Nested Systems
Creating System Diagrams from Scratch
System Settings and Constraints
Deployment Reports
Human-readable Deployment Reports
Machine-readable Deployment Reports and Automated Deployment
The UML Deployment Diagram: Similar, but Not the Same
Summary
Chapter 5: Class Modeling using Class Designer
Class Designer Toolbox and Types
From Code to Class Diagrams
StockBroker Revisited - From Code to Class Diagrams
DealingApp Class Diagram
StockDeal Classes: Code and Class Diagram
Visualizing Members
From Class Diagrams to Code
Designing the StockDeal Classes using Class Designer
Adding Inheritance Relationships
Adding Members
Adding Association Relationships
One-to-Many Associations
Working with Methods
Working with Other Types
StockQuote Structure
DealStatus Enum
DealingNotificationDelegate Delegate
DealingUtilities Module
Working with Interfaces
Reproducing Class Diagrams in Hardcopy
Advanced Topics
Code Synchronization
.NET Framework Classes on Class Diagrams
Patterns
Building your own Pattern Library
Dynamic Modeling
Simulating Statechart Diagrams using The State Pattern
Simulating Collaboration Diagrams using Comments
Comparison with UML Class Diagrams
Chapter Summary
Chapter 6: DSL Tools
Domain Specific Languages
Creating a Designer
Creating the Project
Creating the Navigation Language
Creating the Graphical Language
Defining the Shapes
Defining the Connectors
Defining the Toolbox
Providing a Shape Map
Providing a Connector Map
Using the Designer
Using the Domain model
Generating Code
Designers and VSTS
Summary
Chapter 7: Dynamic Systems Initiative and the System Definition Model
Dynamic Systems Initiative
System Definition Model
SDM Architecture
Design-time Validation
SDM in Visual Studio 2005 Team Edition for Software Architects
Deployment
Modeling Layers of a System
SDM Types
SDM Schema Structure
Definition Complex type
ObjectObjectDefinition Complex Type
RelationshipDefinition Complex Type
Member Complex Type
Settings
Setting Values
Custom Settings
Constraints
ConstraintDefinition Complex Type
ConstraintMember Complex Type
FlowMember Complex Type
ManagerDeclaration Complex Type
SDM Documents
Prototypes and the Distributed System Designers
The SDM SDK
The SDM Command line Compiler
WalkThrough: SDM Sample
SystemDefinitions
Settings
Endpoints
Application Layer
Settings
Application Host Layer
Communication and Delegation
Containment
Hosting
Flows
Constraints
RelationshipConstraints
Constraints
Creating Your Own Constraints
SdmG
Enforcing your constraint
SdmC
ProtoGen
The Registry
Visual Studio
Summary
Chapter 8: Managed Code Analysis
The Need for Analysis Tools
Using Managed Code Analysis
Built-In Managed Code Analysis Rules
Enabling Managed Code Analysis
Executing Static Code Analysis
Working with Rule Violations
Correcting Problems
Suppressing Messages
Advanced Code Analysis Settings
Using the Command-Line Analysis Tool
FxCopCmd Options
FxCopCmd Project Files
Build Process Code Analysis Integration
Creating Code Analysis Rules
Reflection and Introspection
Creating a New Rule
Creating a Base Rule
Implementing the Rule
Deploying the Rule
Learning from Existing Rules
Summary
Chapter 9: Code Analysis for C/C++
Understanding Static Code Analysis
How the C/C++ Code Analyzer Works
Visual Studio 2005 Integration
Enabling and Disabling C/C++ Code Analysis
Setting Warning Levels in Visual Studio 2005
Viewing Code Analysis Warnings and Errors
Command-line Support
Annotation Support
Working with Annotations in C++
Working with Annotations in C
#pragma Support
Integrating with Team Foundation Server
Creating Checkin Policies Using C/C++ Code Analysis
Setting Checkin Notes For Your C/C++ Code
Creating Work Items From Code Analysis Warnings
Team Foundation Build Issues
Identifying and Minimizing Noise
Tool Limitations
Summary
Chapter 10: Application Verifier
Setup and Configuration
Troubleshooting Heaps
Troubleshooting Handles
Troubleshooting Locks
AppVerifier End-To-End
Programming AppVerifier
Summary
Chapter 11: Refactoring and Code Snippets
Refactoring from Class Diagrams
Extract Interface
Implement Abstract Class
Refactoring in Code
Rename
Encapsulate Field
Extract Method
Promote Local Variable to Parameter
Reorder Parameters
Remove Parameters
Generate Method Stub
Improving Code Quality with Code Snippets
Using Code Snippets in Visual Basic
Using Code Snippets in Visual C#
Code Snippets Manager
Summary
Chapter 12: Profiling and Performance
Introduction to Performance Analysis
Types of Profilers
Team System Profiling
Using the Team Developer Profiler
Creating a Sample Application
Creating a Performance Session
Using the Performance Wizard
Adding a Blank Performance Session
Creating a Performance Session from a Unit Test
Performance Explorer
Setting General Session Properties
Configuring Session Targets
Configuring a Sampling Session
Configuring an Instrumentation Session
Executing a Performance Session
Managing Session Reports
Reading and Interpreting Session Reports
Report Statistic Types
Summary View
Functions View
Caller/Callee View
Call Tree View
Allocation View
Objects Lifetime View
Command-Line Execution
Configuring Instrumentation
Setting Environment Variables
Instrumentation
Sampling
Profiling a Windows Service or ASP.NET Application
Clearing Environment Settings
Executing a Profiling Session
Generating Reports
Modifying Instrumentation Programmatically
Common Profiling Issues
Debugging Symbols
Instrumentation and Code Coverage
Virtual Machines
ASP.NET Profiling
Summary
Chapter 13: Test Case Management
Test Projects
Creating a Test Project
Setting Test Project Options
Managing Test Cases
Test Manager
Working with Tests in Test Manager
Test Lists
Choosing Columns to Display
Sorting, Grouping, and Filtering Tests
Test View
Working with Test Results
Test Results Window
Sorting, Grouping, and Filtering Tests Results
Exporting Test Results
Using Test Results XML (TRX) Files
Publishing Results
Using Ordered Tests
Creating an Ordered Test
Ordered Test Properties
Executing and Analyzing Ordered Tests
Summary
Chapter 14: Unit Testing with the Unit Test Framework
Unit Testing Concepts
Benefits of Unit Testing
Writing Effective Unit Tests
Test-Driven Development
Third-Party Tools
Team System Unit Testing
Creating Your First Unit Test
Identifying Unit Test Classes
Identifying Unit Tests
Unit Test Success and Failure
Managing and Running Unit Tests
Test View
Test Manager
Test Run Configuration
Test Results
Debugging Unit Tests
Programming with the Unit Test Framework
Initialization and Cleanup of Unit Tests
TestInitialize and TestCleanup Attributes
ClassInitialize and ClassCleanup Attributes
AssemblyInitialize and AssemblyCleanup Attributes
Using the Assert Methods
Assert.AreEqual and Assert.AreNotEqual
Assert.AreSame and Assert.AreNotSame
Assert.IsTrue and Assert.IsFalse
Assert.IsNull and Assert.IsNotNull
Assert.IsInstanceOfType and Assert.IsNotInstanceOfType
Assert.Fail and Assert.Inconclusive
Using the CollectionAssert Class
Using the StringAssert Class
Expecting Exceptions
Defining Custom Unit Test Properties
TestContext Class
Creating Data-Driven Unit Tests
Accessing Non-Public Members from Tests
Using PrivateObject to Access Non-Public Instance Members
Using PrivateType to Access Non-Public Static Members
Code Generation
Generating Tests from Code
Generating Code from Tests
Unit Testing ASP.NET Applications
ASP.NET Unit Test Attributes
Creating ASP.NET Unit Tests
Code Coverage
Enabling Code Coverage
Viewing Code Coverage Results
Summary
Chapter 15: Web and Load Testing
Web Tests
Creating a Sample Web Application
Creating Users for the Site
Configuring the Sample Application for Testing
Creating and Configuring Web Tests
Recording a Web Test
Configuring Web Test Run Settings
Parameterizing the Web Server
Web Test Run Settings
Running a Web Test
Observing Test Execution and Results
Editing a Web Test
Extraction Rules and Context Parameters
Validation Rules
Data-Driven Web Tests
Configuring a Data Source
Binding to a Source
Coded Web Tests
Load Tests
Creating and Configuring Load Tests
Using the New Load Test Wizard
Test Mix
Performance Counter Sets
Run Settings
Editing Load Tests
Adding Scenarios
Run Settings
SQL Tracing
Goal Based Load Profiles
Storing Load Test Run Data
Executing Load Tests
Viewing and Interpreting Load Test Results
Graph View
Tables View
Command-Line Test Execution
Executing Tests
Executing Test Lists
Other Test Options
Distributed Load Tests
Installing Controllers and Agents
Configuring Controllers
Configuring Agents
Weighting
IP Switching
Attributes
Test Run Configuration
Running a Distributed Load Test
Viewing a Distributed Load Test
Summary
Chapter 16: Manual Testing
Test Automation versus Manual Testing
Test Automation
Manual Testing
Test Cases
Planning Your Manual Tests
Manual Testing in Team System
Creating Manual Tests
Configuring Manual Test Options
Manual Test Templates
Creating Custom Manual Test Templates
Creating a Visual Studio 2005 Test Template
Integrating your Custom Manual Test Template into Visual Studio 2005
Opening Test Templates using the Open With Wizard
Microsoft Word Format Template
Text Format Template
Manual Test Structure
Managing Manual Tests
Using the Test Manager
Logging Your Manual Test as a Bug Work Item
Publishing The Test Results on Team Foundation Server
Summary
Chapter 17: Generic Testing
Creating and Running a Generic Test
Creating a Generic Test
Exit Codes - ErrorLevels
Running the Generic Test
Creating an External Testing Tool
Script Host Example
Managed Code Example
Extended Return Results
Summary Report XML Schema
Example Summary Report XML File
Wiring to Existing Test Systems
Creating a Wire to NUnit
Flow of Operation
Setup and Run
JScript Conversion Code
Summary
Chapter 18: Team Foundation Server Introduction
Goals for this Chapter
Non-Goals
What is Team Foundation Server
Team Processes
Microsoft Solutions Framework (MSF) Source 4.0
Project Management Guidance
Team Foundation Features
Source Code Control
Tightly Integrated
Integrated Check In
Comparison with Visual SourceSafe
Branching and Merging
History
Shelving
Proxy Support
Check-in Policies
Migrating from VSS to Team Foundation Source Control
Work Item Tracking
Project Web Site
Team Build
Reporting
Integration Services
Team Explorer (Client)
Team Edition Test Load Agent
Team Foundation Architecture
Clients of Team Foundation
Team Foundation Logical Architecture
Team Build Process Flow
Reporting Warehouse Architecture
Configuration
Simple Project Scenario
Iteration One: Planning and Setup
Connect to Team Foundation Server
Customize Process Template
Using the Team Explorer
MSF Agile Project Creation
Team Project Organization
Work Items
Source Control Node
Work Items and Microsoft Project and Microsoft Excel
Documents
Source Control
Public Builds
Reports
Customizing the Process
Creating a workspace
Checking in the Files
Creating a New Work Item Type
Customizing a new Work Item
Starting a New Project with the Custom Template
Reviewing the Customized Project
Another version of the MSF Project Template
3rd Party Diff Tools
Import new Process
The Project Setup
Creating a New User Group
Setting the Group Authorization
Windows Sharepoint Services Permissions
Setting the Check-In Policy
Setting the Exit Criteria
Scenarios and Quality of Service Requirements
Iteration 2, Prototyping the Application
Developing the Project
Creating the Simple Interest Calculator Web Page
Creating the CalcInterest Class
Implementing the UI logic
Checking In the Source
Unit Testing
Generating the Unit Test
Implementing the Unit Test
Configure Static Analysis
Enabling Code Coverage
Running the Unit Test
Fixing the problem
Code Coverage
Profiling
Checking in Changes to Source Control
Publishing Data to the Reports Warehouse
Associating Unit Tests with the Build
Deleting Team Build configurations
Publishing Test Results
Summary
Chapter 19: Project Management Tools
Creating a Software Project
Why Software Development Projects Fail
Using the Project Creation Wizard
Managing the Project Details
Using the Team Explorer
Configuring the Project Properties
Managing Project Security
Configuring the Source Control Options
Setting Up the Project Architecture
Working with a Project Portal
Work Item Tracking
Anatomy of a Work Item
Creating Work Items using Visual Studio
Creating and Running Work Item Queries
Creating and Assigning Work Items Using Microsoft Office
Microsoft Excel
Microsoft Project
Creating and Customizing Work Item Types
Team Reporting
Default Reports
Viewing the Reports Using Visual Studio
Viewing Reports using the Project Portal
Analyzing Trends
Creating Reports using SQL Server Reporting Services
Creating Custom Reports
Viewing your Custom Reports
Summary
Chapter 20: Team Foundation Source Control
Team Foundation Source Control versus Visual SourceSafe 2005
Configuration
Plug-in Selection
Environment
File Extensions
Using the Source Code Explorer
Workspaces
Adding a Project into the Source Repository
Checkin and Checkout
Checking in an Item
Checking out an Item
Creating and Administering Checkin Policies
Branching and Merging
Branching
Merging
Shelving
Source Code Migration Tools
Summary
Chapter 21: Team Foundation Core Services
Team System SDK
Team Foundation Object Model (OM)
Connecting to Team Foundation Server
Authenticating with Team Foundation Server
Connecting to Team Foundation Core Services
Linking Service
Anatomy of an Artifact
The Linking Pattern
Programmatically Encoding and Decoding Artifacts
Artifact Providers
Type and Link Registration
IToolClientLinking
IToolServerLinking
Artifact Triggered Events and URI Modifications
Artifact Consumers
Externally Accessing Artifacts
Basic Artifact Security
Registration Services
Notification and Eventing Service
Security Service
Group Service
Authorization Service
Common Structure Service
Classification Service
Classification API
Summary
Chapter 22: Microsoft Solutions Framework
Understanding MSF Agile
Overview
About Agile Development
Agile Process Template Components
MSF Metamodel
MSF Agile Concepts
Iterative Process
Cycles
Activities
Work Streams
Personas
Governance
Work Item Types
Bug
Quality of Service (QOS) Requirement
Scenario
Risk
Task
Team Model
Advocacy
Mindsets
Roles
Business Analyst
Project Manager
Architect
Developer
Tester
Release Manager
Tracks
Envision
Plan an Iteration
Capture Project Vision
Plan
Guide Project
Build
Create a Quality of Service Requirement and a Scenario
Plan and Guide an Iteration
Create Solution Architecture
Build a Product, Fix a Bug & Implement a Developer Task
Test a Scenario and a Quality of Service Requirement
Stabilize
Deploy
Continuous
MSF for CMMI Process Improvement
Capability Level Three
Business Analysts, Project & Release Managers
Developers, Testers and Architects
CMMI Level 3 vs MSF for CMMI Process Improvement
Summary
Chapter 23: Process Templates
Understanding the Project Creation Wizard
Customization Tools
XML/XSL Editors
Microsoft InfoPath 2003
MSF Build
Customizing Process Guidance
Enabling Edit and Compiled Mode
Edit Mode
Compiled Mode
Anatomy of Process Guidance (ProcessGuidance.xml)
Creating Workstreams and Activities
Creating New Workstreams
Assigning Roles to Workstreams
Entry and Exit Criteria in Workstreams
Referencing Work Products
Creating New Activities
Adding Steps to Activities
Associating Activities to Workstreams
Assigning Roles to Activities
Creating Work Item Documentation
Customizing Work Item Elements
Linking to Workstreams and Activities
Creating Custom Roles
Cross References
Viewing your Custom Guidance
Customizing Process Templates
Exporting a Process Template to your Desktop
Navigating a Process Template
Modifying Template Definitions
Customizing your MetaData (MetaData.xml)
MethodologyTemplate.xml
Team Foundation Source Control
Work Items
Windows SharePoint Services Team Portal
SQL Reporting Services
Classification Structure Services
Group Security Services
Importing Process Templates in Team Foundation Server
Deleting Process Templates
Testing your Custom Process Template
Summary
Chapter 24: Team Foundation Build
Setting up Team Foundation Build
Planning a Build Strategy
Setting Up Your Build Lab
Team System Integration
Setting up Build Security
Using Team Foundation Build
Creating Build Types
Team Foundation Build Type Creation Wizard
Editing an Existing Build Type
Deleting a Build Type
Email Notifications
Executing a Build
Getting the Build Status
Command-Line Interface
Starting a Build
Deleting a Build
Aborting a Build
Build Command
Listbuilds Command
Setting Up A Nightly Build
Continuous Integration (CI)
Team Foundation Build Reporting
Programming Team Foundation Build
Build Customization and Extensibility
Creating MSBuild Tasks
Modifying Team Foundation Build Target Files
Microsoft.TeamBuild.targets
CustomActions.targets
Team Foundation Build Web Services
BuildInformation
BuildController
Summary
Chapter 25: Installing and Deploying Team System
Installing Team Foundation Server
System Requirements
Deployment Scenarios
Single Server Setup
Dual Server Setup
Microsoft Virtual Server 2005 Setup
Client Tier Setup
Unsupported Deployment Scenarios
Installing Visual Studio Team Suite
Visual Studio 2005 System Requirements
Installing Visual Studio 2005
Installing Microsoft SQL Server 2005
Backup and Restore Strategies
NTBackup
SQLBackup
Third Party Tools
Deploying on Microsoft Virtual Server
Setting up your Project Team
Summary

Library of Congress Subject Headings for this publication:

Microsoft Visual studio.
Web site development -- Computer programs.
Application software -- Development -- Computer programs.