What Does this Book Cover?

This book addresses the topic of Managed C++ in two fashions.

The first six chapters cover the basics and background information that make up the Managed C++ and .NET worlds. I recommend that you read these chapters first, as they provide information that you'll need to understand the remainder of the book. I also recommend that you read the chapters in sequential order because they build on one another.

The remaining chapters of the book are stand-alone and cover specific topics. Here, you can pick and choose the chapters that interest you the most (hopefully every chapter) and read them in any order.

Chapter 1: Overview of the .NET Framework

In this chapter you address the basics of the .NET architecture. You're bombarded with many new .NET terms such as "assemblies," "common language runtime (CLR)," "Common Language Specification (CLS)," "common type system (CTS)," "just-in-time (JIT) compilation," "Microsoft intermediate language (MSIL or IL)," and "manifests." This chapter tries to soften the blow of your first foray into the .NET world.

Chapter 2: Managed C++ Basics

This chapter should be a refresher course on the basics of C++, but be careful when you read it because there have been a few changes, some of them subtle. This chapter covers the core syntax of C++. Old-time C++ programmers should pay attention to this new feature: built-in value and reference types.

Chapter 3: Object-Oriented Managed C++

Now with the basics covered, you delve into object-oriented development (OOD). This chapter covers topics that old-time C++ programmers will take for granted, such as inheritance, encapsulation, polymorphism, classes, methods, and operator overloading. But be careful with this chapter, as .NET makes some significant changes—in particular, properties, constructors, and destructors.

Chapter 4: Advanced Managed C++

In this chapter I start to discuss things that should make even seasoned C++ programmers sit up and take notice, because most of the topics I cover are new to C++. This chapter's topics include multifile programming, exception handling, and delegates.

Chapter 5: The .NET Framework Class Library

In this chapter, you start to work with .NET as you make your first strides into the .NET Framework class library. This chapter is just an overview and takes a cursory look at many of the Framework's base classes. I focus on helping you learn how to find the classes that you need. In later chapters, I go into some of these base classes in much more detail.

Chapter 6: Visual Studio .NET Development

Visual Studio isn't new to most of you. On the other hand, Visual Studio .NET will be. You'll find that software development is much easier with Visual Studio .NET, and this tutorial-style chapter shows you all the new tools and time-savers.

Chapter 7: Collections

Working with collections should be nearly second nature to the average software developer. Because collections are so commonplace, most programmers expect powerful and feature-rich ways of handling them, and .NET doesn't disappoint. This chapter covers the six common collections provided by .NET and then touches on a few less common ones.

Chapter 8: Input, Output, and Serialization

Many programs that you'll write in your career will involve moving, copying, deleting, renaming, reading, and/or writing files. More recently, with object-oriented programming, many of the file's I/O activity in a program involves serialization. With this in mind, you'll explore the System::IO and System::Runtime::Serialization namespaces.

Chapter 9: Basic Windows Forms Applications

Almost all Windows developers, sometime in their career, will create a Windows application. This chapter shows you how to do it ".NET style." You'll explore how Visual Studio .NET simplifies your development experience. You'll also cover the basic controls found in the System::Windows::Forms namespace in some detail.

Chapter 10: Advanced Windows Forms Applications

Having a handle on the basics is all well and good, but as a .NET developer I'm sure you will want to add more elaborate controls to your Windows applications. This chapter takes what you learned in Chapter 9 and expands on it by exploring some of the more advanced controls available to you in the System::Windows::Forms namespace.

Chapter 11: Graphics using GDI+

If you're like me, you like a little pizzazz in the form of graphics to spice up a boring Windows application. This chapter shows you how .NET has made adding images and graphics a whole lot easier with the System::Drawing namespace.

Chapter 12: ADO.NET and Database Development

What is software development without databases? In most cases, the answer would be "Not much." Microsoft is well aware of this and has gone to great lengths to make database programming easier. Their solution is ADO.NET. In this chapter, you'll explore the many features of ADO.NET that you can find in the System::Data namespace.

Chapter 13: XML

XML is the new world order when it comes to data storage. Microsoft has embraced XML in a big way. This chapter shows the many ways that you can now access XML data in the .NET environment.

Chapter 14: Web Applications

Managed C++ was not meant for Web application development, and there are no tools available to help in the process, but it is possible. This chapter shows you how to develop Web applications using Managed C++. You'll briefly cover HTML and ASP.NET. You'll then learn about the System::Web namespace in some detail.

Chapter 15: Web Services

The concept of Web services is not unique. In this chapter you'll explore Web services within the .NET Framework. You'll examine how to design and create them by walking through the process yourself, creating a simple Web service and three different clients (console, Windows application, and Web application) to interact with the service.

Chapter 16: Multithreaded Programming

Being able to run multiple threads at the same time allows for better CPU usage and is a powerful feature. This chapter explores how the .NET Framework makes working with multiple threads concurrently a snap as you cover the .NET Framework's built-in multithreading capabilities.

Chapter 17: Assembly Programming

In traditional C++, application and library developers had few choices regarding what went into .exes and .dlls. With .NET assemblies this has changed, and you now have plenty of choices. This chapter explores those choices by looking at how you can augment your assemblies with resources, localization, attributes, and reflection.