With over 20 years of experience developing software for Microsoft platforms, Heege is well versed in the subject of this book: using the Common Language Infrastructure (CLI) of the .NET framework, along with Visual C++ programming. The book develops nicely over 12 properly sequenced chapters, starting with the motivation for using C++/CLI and ending with application startup issues: assembly startup and runtime initialization.
The book starts with salient features of C++/CLI. The road is laid toward mingling native C++ with .NET. This chapter addresses mostly managed and unmanaged code. It starts with a simple “Hello World” application, and then discusses concepts such as object file, entry points, and compilation models.
Chapter 2 introduces the Common Type System (CTS) and System::Object--the basis of all .NET types. The discussion takes the reader through the important concepts of managed memory and managed array. System::String, objects, instances, and their indirect accessing are also covered.
The development of a simple .NET application is taken up next, but at the introductory level. Features like compile-time and run-time libraries, assemblies, and .NET metadata are neatly presented. Other topics covered include: command-line arguments, stream-based input/output (I/O), managed exception handling, and debugging; most of these belong to the Framework Class Library (FCL). There is an ongoing discussion of how metadata is defined and consumed, how assemblies are loaded, and how service attributes are defined and used. The source code provided in this chapter is very apt for its topics.
Mapping of source files to assemblies is discussed in the next chapter. Heege thoroughly discusses managed types and their definitions, type visibility, methods, fields, inheritance, overriding interface members, components, and custom events, with lots of code segments. Relationship with the help of CTS features is also covered. Next, the book covers member functions and resource management. C++/CLI allows the developer to implement constructors and destructors. Heege did a very good job in this chapter. Classes, virtual functions, and vtables are very lucidly described. Automatic variables and access to destructed objects are included, and in the right place. Also, special member functions and managed types are implemented.
Chapters 7 and 8 are devoted to project building using native C++, C++/CLI, and managed code. The starting point is the Windows Presentation Foundation (WPF) of .NET Framework 3.0. Different compilation models are explained. Managed and unmanaged boundaries are discussed. The control of services by CLR 2.0 at runtime is also discussed in detail. Heege presents up-front considerations for project development and step-by-step instructions. Issues regarding interoperability during migration are also included.
The author discusses managed-unmanaged transitions. The focus of chapter 9 is on interoperability. Managed code calling native functions, and native code calling managed functions are nicely presented. The calling conventions are tabulated. Calls across boundaries are schematically explained in an easy-to-read manner. Wrapping of C++ classes is discussed with appropriate code examples. Patterns of .NET are recalled; implementation of FCL is reviewed.
Resource management, being crucial to any project, is presented very well and in an easy-to-understand manner. Some of the resource issues presented are: timing, garbage cleaning, prioritizing, and exception handling. The book ends with the discussion of assembly startup and runtime initialization’s important issues for application startup. The entry points in terms of dynamic link libraries (DLLs) and executable (EXE) files are explained. Useful points on customization of startup and load-time deadlocks are provided.
I recommend this book as a great addition to any student or developer’s library. The provided code segments are a real asset. The book is easy to read, and the concepts are clearly presented.
