Softcover

ISBN 10: 0130848743 ISBN 13: 9780130848741

Publisher: Prentice Hall, 1999

Walks you step-by-step through building and deploying robust multi-tier systems, presenting in-depth code examples proven in the classroom and in production environments. Softcover. CD-ROM included. DLC: Electronic data processing--Distributed processing.

From the Inside Flap:

Preface

I have often said that C++ is a programmer's programming language. That is, the language is ideal for professionals who spend most of their time programming. The language is rich and succinct, truly object-oriented, and can be used to create efficient and elegant programs. To the uninitiated, however, the features that make C++ the language of choice for professional programmers are the same features that make the language seem cryptic and unreadable. It can take many years to master the C++ language, and additional practice with the language is required to master Windows and COM development. Add to this the fact that the model of choice for today's software development is multi-tier architecture, and you can see that there is quite a learning curve to traverse.

Although I chose to center my first book on the VB programming language, given the choice, I'd much rather program in C++. When I use C++, I feel more in control and have greater confidence that the application I develop will be more efficient and will make better use of the machine's resources. However, the skills required to design, develop, and maintain a multi-tier application developed in C++ are not universal, which is the reason that most of my clients insist that the code I deliver be developed in VB. On Microsoft platforms, it seems that there is far more development in VB than there is in C++, at least for corporate, rather than commercial, software development. Is it a mistake to develop large corporate applications in VB? Shouldn't these developers learn how to program in C++? Wouldn't the performance of corporate applications improve significantly if they were written in C++ instead of VB? With nearly 20 years of experience as an independent software consultant, I know the answers to all these questions — it depends.

In an apples-to-apples comparison, C++ programs run faster than do VB programs — sometimes significantly faster, but certainly never slower. However, believe it or not, it can be a challenge to develop a large, scalable multi-tier application in C++ that performs as well or better than one developed in VB. Multi-tier applications, by definition, spend a lot of time accessing databases and generating network I/O, resulting in a lot of calls to database and system APIs. Since the advent of COM, Distributed Component Object Model (DCOM), and Microsoft Transaction Server (MTS), all languages for Microsoft operating systems share a common set of objects and interfaces for database access and distributed application communication. Because VB and Visual C++ share these objects and interfaces, opportunities for improving performance are found only between method invocations on these interfaces. In other words, the key to better performance must start with a proper design and a proper approach to multi-tier development. A poorly designed C++ application will not perform better than a properly designed VB application, whether it is distributed or not. I know this for a fact, having converted multi-tier applications from Visual C++ to VB. One is not automatically and unconditionally assured of superior performance simply because one chooses C++ over VB. However, all things equal — a good design and a good approach — there is no way that VB can outperform C++.About this Book

This is a book for serious developers of distributed applications. Although it is, strictly speaking, an intermediate-level book, I expect the reader to be an experienced C++ and Windows programmer. Ideally, the reader will also have some experience with ATL (the Active Template Library) or will have at least read an introductory-level book on ATL. Perhaps you've seen and tried some simple hello, world demonstrations of ATL, understand some of the basic concepts of ATL and COM, and are now faced with applying these concepts to develop a distributed application. If this description applies to you, then you will find this book extremely useful, primarily because the good news is that there are only a few simple concepts of ATL that one must understand to develop efficient, multi-tier applications in Visual C++. This is the main theme of this book — to get you started with the development of distributed applications using Visual C++ in the quickest way possible.

Probably the most unusual thing about this book is that I start with a chapter on deploying multi-tiered distributed applications. This approach has worked well in the classroom when I teach my courseware, and I expect the same results in this book. Because many of the demos used in later chapters depend on the sample applications being installed, it is essential that you read the first chapter and go through the installation procedures.

In Chapter 2, I discuss the use of COM objects from a Visual C++ application, using the sample Video Store objects provided with this book. Even if you are familiar with using COM objects in C++ application, you should read this chapter. The chapter may seem like a "show-and-tell" for an existing application, but it provides good examples of object design and documentation.

Chapter 3 provides an in-depth overview of OLE database (OLE DB), the COM-oriented interface to database access. The chapter will clear up any confusion you may have as to the difference between OLE DB and ActiveX Data Objects (ADO), and will provide several hard-to-find examples of complete applications that access databases via OLE DB interfaces. Although most multi-tier applications should use ADO rather than the low-level OLE DB interfaces to perform database access, you should read this chapter carefully because it provides a solid background for OLE DB fundamentals.

As an essential and fundamental introduction into developing the middle tiers of a distributed application, Chapter 4 is required reading. This chapter introduces ADO and provides several examples of database access, including many that are taken from the completed multi-tier sample application provided on the CD-ROM that accompanies this book.

In Chapter 5, I explain how to design and implement an object model, a client-side component that acts as an object-oriented wrapper around the stateless objects that are deployed server-side under MTS. Objects in an object model, also known as the client-side persistence layer, are an elegant abstraction of your business objects. An object model contains client-side logic exclusive of the user interface — having an object model makes it easier to develop and deploy a suite of client-side applications, especially Win32 dialog-based applications.

A fundamental and hands-on introduction to DCOM is presented in Chapter 6. Reading this chapter and performing the walkthroughs will give you a solid introduction to DCOM, as well as an appreciation for the features provided by MTS. The serious distributed application developer will want to read and understand this chapter.

Based on my experience, I am quite certain that many of you purchased this book for the topic covered in Chapters 7 and 8 — using MTS. For a few years now, I have often entertained myself by seeing the reaction of students when I ask, "How many of you are interested in learning about MTS?" Even people who haven't raised their hands in public since the third grade eagerly raise one, if not both, arms, often adding a vigorous circular motion. It goes without saying that you'll want to read both of these chapters.Entire books have been written on the topic covered in Chapter 9 — creating Internet interfaces using Active Server Pages (ASP). The chapter goes a bit beyond getting you started, and I would consider it to be required reading, if only because, chances are, the existing Web applications you now have were implemented as ASP pages.

From the Back Cover:

• Master COM, DCOM, MTS, ADO, and OLE DB!
• Practical techniques for building scalable, distributed business applications
• Effective design: Maximizing performance and avoiding bottlenecks
• Complete DCOM server-side and client-side walkthroughs - including troubleshooting
• Detailed example applications: database access via OLE DB interfaces and ADO
• Powerful Web interfaces with Active Server Pages (ASP)

Design, develop, and deploy multi-tier applications with Visual C++ 6.0 - start to finish!

If you're an experienced Visual C++/MFC programmer who's serious about multi-tier development, you've come to the right place. In this book, expert developer and instructor Jim Maloney helps you master every key technology you'll need to know, including COM/DCOM, MTS, ADO, OLE DB, and more.

Maloney walks you step-by-step through building and deploying robust multi-tier systems, presenting in-depth code examples proven in the classroom and in production environments. Master design techniques that lead to more robust, high-performing distributed applications; create and implement object models, and build client-side persistence layers that elegantly abstract your business objects.

Gain an in-depth understanding of OLE DB and ADO, through detailed hands-on applications demonstrating database access via OLE DB interfaces and ADO middle-tier code. Then, learn all you need to know to work with MTS: creating packages; installing components, the MTS API, stateful and stateless objects, debugging, shared properties, security, implementing the data services layer, and more.

About the CD-ROM

CD-ROM contains all source code, including a complete, robust multi-tier application.