Before you roll your eyes and mumble under your breath, "Not another chapter on assemblies," read the chapter title again. This chapter is about programming an assembly and not about the assembly. By now I'm assuming you know what an assembly is, its structure, how it eliminates DLL Hell, and so forth. Instead, this chapter focuses on programmatically playing with the assembly.
As I've pointed out a few times in this book, the assembly is the cornerstone of .NET Framework deployment. To paraphrase, all roads lead to the assembly. Because this is the case, it only makes sense that the .NET Framework provides the programmer many programmatic tools to interact directly with the assembly.
In this chapter you'll look at some of these programming tools. Most of these tools are for the more advanced Managed C++ programmer. In most cases, you won't have to use them for most of your programs. On the other hand, knowing these tools will provide you with a powerful weapon in your .NET software development arsenal and, inevitably, sometime in your coding career you'll need to use each of these tools.
The first tool, reflection, gives you the ability to look inside an assembly to see how it works. You've used system-defined attributes on several occasions in this book. In this chapter you'll have the opportunity to create some of your own attributes. Up until now, you've worked only with private assemblies, but it's also possible to share them. Most of the time, you'll take versioning (the second tool) for granted, but you can take a much more active role. Assemblies need not be just metadata and MSIL code. They can house almost any resource that your program needs to run. The last tool—but definitely not the least—is globalization and localization. Your culture may be central to your life, but there are many other cultures out there. Why not make your programs work with these cultures as well?