INTRODUCTION
Chapter 12: LINQ to Objects
This chapter will begin your examination of Language Integrated Query (LINQ). LINQ allows you to
build strongly typed query expressions that can be applied to a number of LINQ targets to manipulate
data in the broadest sense of the word. Here, you will learn about LINQ to Objects, which allows you to
apply LINQ expressions to containers of data (e.g., arrays, collections, and custom types). This
information will serve you well as you encounter a number of additional LINQ APIs throughout the
remainder of this book (e.g., LINQ to XML, LINQ to DataSet, PLINQ, and LINQ to Entities).
Chapter 13: Understanding Object Lifetime
The final chapter of this section examines how the CLR manages memory using the .NET garbage
collector. Here you will come to understand the role of application roots, object generations, and the
System.GC type. Once you understand the basics, you will examine the topics of disposable objects (using
the IDisposable interface) and the finalization process (using the System.Object.Finalize() method).
This chapter will also investigate the Lazy class, which allows you to define data that will not be
allocated until requested by a caller. As you will see, this feature can be very helpful when you want to
ensure you do not clutter the heap with objects that are not actually required by your programs.
Part V: Programming with .NET Assemblies
Part 5 dives into the details of the .NET assembly format. Not only will you learn how to deploy and
configure .NET code libraries, but you will also come to understand the internal composition of a .NET
binary image. This part also explains the role of .NET attributes and the role of resolving type
information at runtime. This section will also explain the role of the Dynamic Language Runtime (DLR)
and the C# dynamic keyword. Later chapters will examine some fairly advanced topics regarding
assemblies, such as application domains, the syntax of CIL, and the construction of in-memory
assemblies.
Chapter 14: Building and Configuring Class Libraries
At a very high level, assembly is the term used to describe a *.dll or *.exe binary file created with a .NET
compiler. However, the true story of .NET assemblies is far richer than that. Here, you will learn the
distinction between single-file and multifile assemblies, as well as how to build and deploy each entity.
You’ll also examine how you can configure private and shared assemblies using XML-based *.config
files and publisher policy assemblies. Along the way, you will investigate the internal structure of the
global assembly cache (GAC).
Chapter 15: Type Reflection, Late Binding, and Attribute-Based Programming
Chapter 15 continues your examination of .NET assemblies by checking out the process of runtime type
discovery using the System.Reflection namespace. Using the types of this namespace, you can build
applications that can read an assembly’s metadata on the fly. You will also learn how to load and create
types at runtime dynamically using late binding. The final topic of this chapter will explore the role of
lx