Microsoft Visual C++ 6.0分布式应用程序开发

About This Book

Intended Audience

Prerequisites

course Overview

Getting Started

Using This Book to Prepare for Certification

Microsoft Certified Professional Program

Technical Support

About the authors

Chapter 1 Designing the Application

Lesson 1: Architecture-First Design

Architecture-First Design

Application Design Principles

Lesson Summary

Lesson 2: Distributed Application Design

Multilayer Design

User Interface

User Service Layer

Business Service Layer

Data Service Layer

Lesson Summary

Review

Chapter 2 Development Environment

Lesson 1: Production Channel

Details of the Production Channel

Lesson Summary

Lesson 2: Change Control

Change-Control Process

Version Control Systens

Visual SourceSafe

Exploring Features of VSS

Lesson Summary

Lesson 3: Tools

Integrated Development Environment

Visual Data Modeing

Visual Modeler

Dcomcnfg.exe

OLEView

Using OLEView to View Installed COM Objects

Lesson Summary

Lab 2: Installing Visual C++

Review

Chapter 3: C++ Development Essentials

Lesson 1: C++ Libraries

Overview of MFC

MFC Architecture

MFC Library Files

Using ATL

Using STL

Lesson Summary

Lesson 2: Thread Management

Threading Models

Apartments

In-Process Threads

Lesson Summary

Lesson 3: Memory Management and System Services

Some Basic Concepts

Memory Allocation and Management

Memory Allocation/Deallocation Examples

Resizable Memory Blocks

Memory Management Problems and Issues

Lesson Summary

Chapter 4 Developing User Services

Lesson 1: Creating Help Systems

Help System Considerations

WinHelp Files

HTML Help

Implementing Help Systems

Lesson Summary

Lesson 2: User Interface Navigation

Creating Menus with the Menu Editor

Creating and Using Toolbars

Rebars

Implementing Status Bars

Lesson Summary

Lesson 3: User Interface Forms and Dialog Boxes

Dialog Boxes

Property Sheets

Using the CFormView Class

Processing and Validating User Input

Lesson Sunnary

Lesson 4: Creating and Using ActiveX Xontrols

Using ActiveX Controls

Using Event Handlers with Command Messages

Creating ActiveX Controls with ATL

Creating ActiveX Controls with the Platform SDK

Creating ActiveX Controls with MFC

Signing an ActiveX Control

Downloading an ActiveX Control to the User Interface

Lesson Summary

Lab 4: Creating a User Interface

Exercise 1: Creating a Dymanic Menu

Exercise 2: Adding a Modeless Dialog Box

Exercise 3: Building an ActiveX Control

Review

Chapter 5 Building Basic Business Objects

Lesson 1: COM Basics

The Challenges of Component-Based Applications

Coclasses

COM Objects

COM Components

COM Identifiers

COM Interfaces

COM Security

COM Registration

COM Support in Distributed Environments

Lesson Summary

Lesson 2: Visual C++ Classes

Implementation Inheritance

Allocating and Deallocating Memory in the DLL

Interface Inheritance

Advantages of Using Interfaces

Lesson Summary

Lesson 3: Building a COM Component Using the Platform SDK

Defining Interfaces with IDL

Implementing IUnknown

Creating Class Factories

COM DLL Entry Points

Lesson Summary

Lesson 4: B uilding a COM Component using ATL or MFC

Active Template Library

Microsoft Foundation Classes

Lesson Summary

Lab 5: Dissecting ATL

Review

Chapter 6 Building Advanced Business Objects

Lisson 1: Creating Distributed COM Components

Configuring DCOM

Creating an ATL Out-Of-Process Component

Using DCOM Security

Registering a DCOM Component

Lesson Sunnary

Lesson 2: Creating Multithreaded Components

Using Multithreaded Components

Creating a Multithreaded Component Using ATL

Lesson Summary

Lesson 3: Creating Services

Creating a Windows NT Service

Communicating with Serveces

Managing Services

Lesson Summary

Lesson 4: Extending Existing COM Components

Aggregation

Comtainment

Scriptlets

Lesson Summary

Lesson 5: Creating and Using Active Documents

Active Document Containers and Servers

Lesson Summary

Lesson 6: Using MFC to Create an ISAPI DLL

Extending Web Server Capabilities

MFC Regular DLLs vs.MFC Extension DLLs

Dynamic User Interfaces

Lesson Summary

Lab 6: Creating an Out-of-Process COM Component

Exercise 1: Creating a COM Server

Exercise 2: Creating a COM Client

Review

Chapter 7 Using Microsoft Transaction Services

Lesson 1: Transactions and MTS

Transactions

Coordinating Transactions

Transactions and COM

What Is MTS

Benefits of Using MTS

MTS Structrres

Lesson Sunnary

Lesson 2: Comfiguring MTS

Installation

Configuring Your MTS Server with MTS Explorer

Administering Your MTS Server Programmatically

Lesson Summary

Lesson 3: MTS Objects

Designing Objects for MTS

Developing Objects for MTS

Packaging Objects for MTS

Deploying MTS-Based Objects

Lesson Summary

Lesson 4: Advanced MTS Techniques

Role-Based Security

Load Balancing

Lesson Summary

Lesson 5: Creatin MTS-Based Applications

Controlling the Folw of Transactions

Designing with MTS

Scaling Applications with MTS

Lesson Summary

Lab 7: Understanding MTS Activities and Transactions

Exercise 1: Putting Everything in Place

Exercise 2: Observe How Activities Are Managed

Exercise 3: Observe How Transactions Are Managed

Review

Chaper 8 Microsoft Message Queuing Services

Lesson 1: Installing and Configuring MSMQ

MSMQ A rchitecture

Installing MSMQ

Lesson Summary

Lesson 2: Creating and Using Queues

COM Objects

Creating a Queue

Locating a Queue

Opening a Queue

Sending Messages

Receiving Messages

Deleting a Queue

Lesson Summary

Lesson 3: Transactional Queues

Transactional Messaging

Creating a Transactional Queue

Sending an Receiving Message Within a Transaction

Lesson Summary

Lab 8: Sending and Receiving Persistent Objects In Messages

Exercise 1: Creating a Persistable Object

Exercise 2: Sending Messages

Exercise 3: Receiving Messages

Review

Chapter 9 Using Data Access Services

Lesson 1: Structured Query Language

Basic Concepts

Retrieving Data

Modifying Data

Deleting Data

Querying Multiple Tables

Summarizing Data

Lesson 2: SQL Server

Basic Concepts

Installing SQL Server

Configuring SQL Server

Implementing a SQL Server Database

Data Integrity

Creating and Maintaining Indexes

Lesson 3: Data Access Strategies

Data Access

UDA Technology

Fundamental Terms of Data Access

Microsoft Data Access Components

Using CSocket

Choosing the Right Data Access Technology

Choosing a Data Access Strategy

Lesson Summary

Lesson 4: Using ADO

Basics of ADO

ADO Architecture

Guidelines for Choosing ADO as Your Data Access Technology

Working with ADO Objects

Executing Parameterized Queries with ADO

Lesson Summary

Lesson 5: Using ODBC

ODBC Architecture

MFC ODBC Classes

Working with ODBC Recordsets

Debugging and Error Handling in ODBC Applications

Lesson Summary

Lesson 6: Using OLE DB

Basics of OLE DB

OLE DB Architecure

OLE DB Physical Architecture

OLE DB Consumer Templates

Using the CDynamicAccessor Class

Creating Parameterized Queries Using CDynamicParaneterAccessor

Lesson Summary

Lab 9: Creating ADO Application

review

Chapter 10 Exception handling

Lesson 1: Exceptions

Anticipating Program Errors

Structured Exception Handling

C++ Exception Handling

Benign Exceptions

Visual C++ Exception handling Support

Lesson Summary

Lesson 2: Handling Exceptions and Errors

Exceptions and MFC

COM Errors

Exceptions and Distributed Applications

Lesson Summary

Lesson 3: Error-Handling Strategies

Working with Error Logs

Working with MTS

Working with MSMQ

Working with ADO

Handling Exceptions in an ADO Application

Lesson Summary

Lab 10: Exception Handling in Duwamish Books

Exercise 1: Adding Exception handlers

Exercise 2: Rebuilding the D4Cache Project

Review

Chapter 11 Debugging and Testing

Lesson 1: Introduction to Debugging

What Is a Debugger

Debug vs.Release

MFC Debug Macros

Lesson Summary

Lesson 2: Using the Integrated Debugger

Breakpoints

Setting Breakpoints

Running the Debugger

Debugger Windows

Stepping Through Code

Edit and Comtinue

Lesson 3: Debugging COM Objects

Debugging Local Objects

Debugging Remote Objects

Troubleshooting COM Objects

Lesson Summary

Lesson 4: Dependency Walker

What Is a Dependency

Dependency Information

Lesson Sunnary

Lesson 5: Spy++

Spy++ Views

Viewing Window Messages in Spy++

Lesson Summary

Lesson 6: Testing a Distributed Application

Glossary of Testing Terms

Creating a Test Plan

Creation a Test Harness

Lesson Summary

Lab 11: Debugging a COM Object

Exercise 1: Debugging a Local Object

Exercise 2: Debugging a Remote Object

Exercise 3: Debugging an MTS Object

Review

Chapter 12 Deploying Distributed Applications

Lesson 1: Setup Programs

Writing a Setup Program

Guidelines for Writing a Setup Program

Uninstall Program

Adding and Removing Registry Information

Cabinet Files

Registry Files

Adding a Command to the Programs Menu

Lesson Summary

Lesson 2: Using InstallShield

Installing InstallShield

Running the InstallShield Tutorial

Including and Removing Program Files

Creating the Setup.exe Program

Lesson Summary

Lesson 3: Packaging COM Components

Determining Remote Server Names

MTS Components

Using MSMQ

Load Balancing

Lesson Summary

Lesson 4: Installing COM Components

Self-Registering Components

Adding Self-Registering Components to an InstallShield Project

Registering Remote COM Servers

Lesson Summary

Lesson 5: Deployment Methods

Media-Based Deployment

Network-Based Deployment

Web-Based Deployment

Deployment Checklist

Lesson Summary

Lesson 6: Zero Administration for Windows

Features of ZAW

Windows Installer

Systems Management Server

Zero Administration Kit

Lesson Summary

Lab 12: Packaging and Deploying a Distributed Appliction

Exercise 1: Building Release Versions of Client2 and Beeper

Exercise 2: Creating a Package File for the Beeper Component

Exercise 3: Creating the InstallShield Project

Exercise 4: Modifying the InstallShield Project

Exercise 5: Building the Setup Program

Exercise 6: Deploying and Testing the Setup Program

Review

Appendix A Application Design Concepts

Appendix B Review Questions and Answers

Glossary

Index