ATL Developer's Guide

WC will not go away overnight; in fact, you can use WC with the ATL but existing WC features probably will merge with ATL over time. Microsoft developed the new ATL framework primarily for one reason: a new application development architecture called the Component Object Model (COM).

COM is Microsoft's system-level, object-oriented technology that is used extensively within its products and tools. COM provides several features that software developers need. COM provides language independence, which enables developers to reuse their C++ modules in Visual Basic, Delphi, or virtually any other development environment. COM also provides location transparency, which enables a software module to execute anywhere in a distributed network environment. In addition, COM provides the standard object-oriented characteristics of encapsulation, polymorphism, and inheritance. COM is the future of all Microsoft-based development, and ATL is one of the most important tools that developers can use to take advantage of this shift in technology.

The primary focus of ATL is to enable the creation of small COM-based software modules. Then these modules are assembled to create larger applications. As developers move to this new component-based development model, they will use ATL. Microsoft also is committed to delivering COM on non-Windows platforms such as UNIX, Sun's Solaris, and Digital's VMS - ATL is one approach to providing a cross-platform COM development tool.

The history of ATL began in the fall of 1996 when Microsoft released version 1.0 as a freely downloadable add-on for Visual C++ (Version 4.2 at the time); version 1.1 followed shortly thereafter. ATL version 2.1, which added a significant amount of new functionality, was released as part of Visual C++ 5.0. The latest version, 3.0 included with Visual C++ 6.0, again significantly upgrades the functionality provided by ATL. Future versions eventually will provide nearly all of the functionality provided today by WC.

The purpose of this book is to help you understand and adopt one of the most important developments in Windows-based development: the move to COM-based application development. ATL is a powerful tool in this new environment, and this book provides in-depth coverage of what you need to know.

Chapter Organization

I suggest you read the chapters in succession, although you can skim the first two chapters if you are familiar with C++ templates and COM. Chapter 1 covers C++ template-based development. Chapter 2 provides an in-depth introduction to the Component Object Model (COM) and introduces the examples that I use throughout the book.

With the exception of Chapters 1, 7, and 13, each chapter is divided into two primary sections. The first section provides a conceptual, code-based discussion of the topic, while the second section walks you through developing one or more sample applications that demonstrate the techniques described. This enables you to read the book for the concepts; when you actually need to use them in your projects, you can go back and read the explicit implementation section.

Here are brief introductions to each chapter:

Chapter 1, Developing with C++ Templates:
ATL uses templates throughout its implementation. Chapter 1 provides an introduction to this new approach to building reusable C++ classes.

Chapter 2, Introducing the Component Object Model:
A general overview and detailed discussion of COM. The example is a simple C++ (COM) COM client and server. In later chapters, I reimplement and enhance this example using ATL with various COM techniques.

Chapter 3, The Active Template Library:
ATL is about building COM-based applications. This chapter introduces ATL with a discussion of its template-based implementation and its wizards. The chapter also includes coverage of ATL's classes and idioms.

Chapter 4, Interfaces, IDL, and Marshaling:
Chapter 4 goes a bit deeper into the various interface mechanisms provided by COM. In particular, I cover the Interface Definition Language (IDL) and something called marshaling. After that, I cover some miscellaneous COM details such as error handling, memory management, and basic data types. Of course, all topics are discussed in the context of ATL.

Chapter 5, Containment and Aggregation:
One important feature of COM is its support for software module reuse at a binary level. In this chapter, I look at COM's binary reuse techniques: containment and aggregation. After a quick introduction to the two techniques, I examine how ATL provides support for developing components that support and/or use containment and aggregation.

Chapter 6, Automation:
Automation is the COM-based technology that almost all Windows developers are familiar with, at least from a user's perspective. Visual Basic uses automation extensively and ActiveX controls expose their functionality through automation. This chapter covers automation in detail, including a discussion of early and late binding, dual interfaces, and how ATL handles support for automation.

Chapter 7, Events and Connection Points:
Chapter 7 covers two very important topics for those developers using COM in their development projects: events and connection points. Today, COM interface calls are synchronous by nature. However, by using various techniques, COM components can provide pseudo-asynchronous behavior through support for interface callbacks and connection points. This chapter covers these techniques along with the ATL implementation.

Chapter 8, ActiveX Controls:
ActiveX controls play a major role in Microsoft's component-based future. ActiveX controls are COM-based components that implement a number of standard, Microsoft-defined interfaces. It actually is quite hard to articulate what an ActiveX control is, primarily because the definition bas changed frequently over the years. But in this chapter, I cover what is called a full control. A full control is one that works in the popular development environments (such as Visual Basic), and implements at least 20 different COM interfaces.

Chapter 9, COM Enumerators and Collections:
Managing a list of related items is a common aspect of software development. COM provides a standard technique for inserting and iterating a list of items through its concept of an enumerator object. Certain languages and tools, such as Visual Basic, expand this idea to include the concept of a collection, which exposes an enumerator object in a standard way. This chapter covers both of these techniques.

Chapter 10, COM Threading:
COM threading is one of the most misunderstood (and feared) COM topics. There's no doubt that multithreading is a difficult topic in itself, by introducing COM into the equation, it becomes even more difficult. This chapter first covers the basics of COM threading and then moves into a discussion of ATL's support for the various COM threading models. The chapter ends with an example of a multithreaded math component that supports asynchronous method calls.

Chapter 11, OLE DB and ATL:
One of the more powerful Microsoft technologies supported by the latest version of ATL is OLE DB. With the overwhelming success of Web-based e-commerce applications, OLE DB (with the help of ADO) has become the standard on which Microsoft developers have based their data access future. The latest version of ATL provides a plethora of new classes that enable developers to implement a generalized data access method to a proprietary data source based on OLE DB. This chapter covers all the gory details.

Chapter 12, Dialog Boxes and Windows:
Initially, the ATL framework focused mostly on providing non-GUI support for building COM components. If, as a developer, you were interested in building an application that required extensive windowing support, you most likely would use the Microsoft Foundation Class (MFQ library or Visual Basic. However, with each new version of ATL, Microsoft continues to add MFC-like GUI functionality. In this chapter, I briefly discuss the window and dialog box support provided by ATL.

Chapter 13, COM+ Fundamentals:
COM was created long ago as a workstation level comportment technology. Then came a distributed version call DCOM in Windows NT 4. The technology was expanded again with Microsoft Transaction Server (MTS) to provide server-side component services and to fix many of the deficiencies of DCOM. COM+ was developed, and integrated into Windows 2000, to unify COM, DCOM, and MTS into a coherent, enterprise-worthy component technology. This chapter provides; you with an overview of these new technologies.