Organization of Topics

This book is broken into five sections of chapters, described further below. In addition to that, there is a single Appendix, which describes the full set of Common Intermediate Language (CIL) instructions.

Part I: CLR Fundamentals

The goal of this section is to learn about the role the CLR plays in the execution managed code. In one sense, we're starting from the bottom and working up. Some people might prefer to skip to Section II first, to understand the libraries before the runtime fundamentals. We'll cover topics such as what abstractions the Common Type System (CTS) offers for your programs, how the CLR runs managed code on a physical machine, and the services—such as garbage collection and just-in-time (JIT) compilation, for example—that it uses to execute your code.

Chapter 1: Introduction

Chapter 1 introduces the .NET Framework technology and describes the key improvements in version 2.0.

Chapter 2: Common Type System

In Chapter 2, we take a tour of what the Common Type System (CTS) has to offer. In particular, we'll see how types and their components are structured, the differences between value and reference types, and some cross-cutting features of the type system, such as generics and verification. You'll understand what features the CLR's type system has to offer, and how languages like C# and VB take advantage of said features.

Chapter 3: Inside the CLR

Here, we'll spend a lot of time on the internal details of how the CLR gets its job done. At a conceptual level, it will provide you with an idea of why your managed code works the way it does. We'll look at the Intermediate Language (IL) that C#, Visual Basic (VB), and any other managed languages compile down to, the exceptions subsystem, and how memory is managed by the runtime. We conclude with acoverage of the CLR's JIT compiler.

Chapter 4: Assemblies, Loading, and Deployment

In this chapter, you'll see the CLR's units of deployment and assemblies, what they contain, and how they are manufactured by compilers and loaded by the runtime. We'll also see some of the options you have for deployment, for example for shared libraries, private libraries, and ClickOnce.

Part II: Base Framework Libraries

After seeing how the runtime itself functions in Part I, the next section of the book discusses specific portions of the Base Class Libraries (BCL). Remember, these are the Windows APIs you will work with when writing managed code. We'll constrain the discussion to some of the most common and important libraries to your managed programs, leaving some of the more advanced libraries to later sections of the book.

Chapter 5: Fundamental Types

We'll take a look at the lowest-level base types that the Framework has to offer. This includes the primitives built into the languages and runtime themselves, in addition to some similarly common types that you'll use in nearly all of your programs. This includes scalars, strings, dates and times, math, common utilities, and common exception types.

Chapter 6: Arrays and Collections

Nearly all programs work with collections of data. The System.Collections.Generic APIs provide a rich way in which to do this, exploiting the full power of generics. We'll see all they have to offer in addition to some more primitive collections, such as the ordinary System.Collections types and arrays.

Chapter 7: I/O, Files, and Networking

At this point, you should be fairly comfortable creating and consuming native CLR data. But programs that operate only on primitives, strings, dates, and so forth, are very rare. This chapter will walk through how to interact with the outside world through the use of I/O, including working with the file system and communication through the Network Class Libraries (NCL).

Chapter 8: Internationalization

A topic that is of rising importance in today's globalized world is internationalization (i18n), the process of making your applications culture- and language-friendly. The backbone of i18n on the .NET Framework is cultures and resources, the primary topics of this chapter. We'll also discuss some of the nontechnical and technical challenges that face international applications.

Part III: Advanced CLR Services

Section III will introduce you to some of the more advanced services the CLR has to offer. This includes the secure programming model, forms of isolation and concurrency, and the various interoperability features the CLR has to offer. While many of the topics here are labeled features of the CLR, nearly all of them are surfaced to the programmer through libraries.

Chapter 9: Security

The CLR offers a secure infrastructure to authorize privileged operations based on both user and code identity. Code access security (CAS) permits you to restrict what programs can do based on the source, for example whether the code came from the Internet, an intranet, or the local machine, among other interesting criteria useful in determining security rights.

Chapter 10: Threads, AppDomains, and Processes

In this chapter, you'll see the various granularities of isolation and execution the CLR has to offer. We'll also take a look at concurrent programming models in the Framework, for example how to create, synchronize, and control parallel operations. We also look at the various techniques using which to control AppDomains and processes.

Chapter 11: Unmanaged Interoperability

Not all code on the planet is managed. In fact, a wealth of Windows code has been written in C, C++, and COM, and probably will be for some time to come. The CLR provides ways to bridge the type system and binary formats of managed code and these technologies. Furthermore, when interoperating with unmanaged code, it requires stepping outside of the bounds of simple memory management. As such, additional techniques are required to ensure resources are released in a reliable fashion.

Part IV: Advanced Framework Libraries

In Section IV, we turn back to a look at some more advanced Framework APIs. While not as commonly used as those in Section II, they are frequently used in managed code.

Chapter 12: Tracing and Diagnostics

The CLR and associated tools, such as the Visual Studio integrated development environment (IDE), provide great debugging capabilities. But beyond that, instrumenting your programs and libraries with tracing code can help during testing and failure analysis. Beyond that, tracing also enables you to diagnose more subtle problems in your code, such as causality, performance, and scalability problems. This chapter takes a broad look at the tracing infrastructure in the Framework.

Chapter 13: Regular Expressions

This chapter takes a look at regular expressions in general—the features, syntax, and capabilities—in addition to the .NET Framework APIs in the System.Text.RegularExpressions namespace. At the end of this chapter, you'll be ready to integrate regular expressions deeply into your applications.

Chapter 14: Dynamic Programming

In Section II, you saw how the CLR and .NET Framework are powered by metadata. Chapter 14 examines how to hook into this metadata for dynamic programming scenarios. This means functionality that is driven based on the metadata present in programs combined with runtime information, rather than simply information known at compile time. This involves using the Reflection subsystem. In addition to that, we take a look at how to generate metadata using the System.Reflection.Emit namespace.

Chapter 15: Transactions

With version 2.0 of the Framework, a new unified transactional API has been added. This integrates ADO.NET, messaging, and Enterprise Services (COM+) transactions under a single cohesive umbrella. System.Transactions offers a very simple set of types, and supports both local and distributed transactions.

Appendix

The appendix lists the entire set of IL instructions in the CIL and MSIL instruction sets.