《Metadata Tables》 Introduction

Introduction

This book on MetaData Tables is a heady cocktail of the esoteric and mysterious details pertaining to the internals of an executable file, which gets created by the compiler of any .Net product.

It is an intricate book, which would appear formidable to those uninitiated to the world of C#. It is replete with programs written using the C# language, and is predicated on the presumption that you possess adequate knowledge of this language.

In the .Net world, when the compiler processes the source code, it creates an IL file. This IL file is inherently capable of comprehending object types. It is equipped with instructions that do the following: create and initialize objects, call methods, raise and catch exceptions, etc. This IL file is thereafter converted into an executable or a DLL file, i.e. PE file, after the compiler has firmly embedded the MetaData information in it. It is the repository of information that relates to the types and the methods that have been employed in the file.

Earlier, Microsoft had extended its original DOS format and had incorporated the PE file format in order to buttress the execution of files on the Windows platform. However, with the introduction of .Net, Microsoft remolded its PE file format and instituted a header to store the MetaData information. Specifically, one of the structures in the optional header has been used for the CLR header.

MetaData is a key component that casts a significant shadow on the .NET architecture. It renders the Runtime with vital information about assemblies, classes, methods and scores of other significant details. Thus, MetaData represents data, which is exacting, comprehensive, and most importantly, language-independent. This results in a common format for exposing the information contained in a file or an assembly, thereby introducing flexibility and code sharing between applications that use disparate languages. Finally, the MetaData facilitates remote method calls in the .Net Framework.

Our book on 'MetaData Tables' delineates how the MetaData is laid out after being read into memory from a PE file. The MetaData is stored in either tables or streams. There are five streams in all. One of the streams comprises of tables that store the relevant data. The remaining four are String, Blob, UserString and Guid. There exists an awesome amount of interdependence between these streams.

All MetaData is stored internally in the form of tables. There exist about 43 assorted table types in the realm of MetaData, each of which stores specific information. For instance, all the types are stored in one table, all the methods are stored in another table, all the parameters are stored in yet another table, and so on. Each table is assigned one bit in one of the MetaData fields. Contingent upon the status of this bit field, the presence of a particular table can be ascertained.

Every table has been assigned a name and a number. The table that is assigned the number 0 is known as 'Module', while the table that is assigned the number 1 is called TypeRef, and so on. Moreover, Microsoft has extensively utilized the features of coded indexes to enhance efficiency and to restrict the byte-consumption, thereby avoiding dissipation of memory space.

The captivating feature of this book is its remarkably simplistic approach. Firstly, we get you well acquainted with the PE file format, where we introduce you to the relevant details of the file. Then, we focus our attention on the Metadata header.

Next, we plough our way ahead, scrutinizing every Metadata table meticulously, one at a time. On certain occasions, we have replicated some portions of the code, in order to facilitate ease of understanding. Further, to expound every table, miniature snippets of code have been provided, using either IL or the C# language. An independent chapter has been devoted to the topic of Blob Signatures, since they unravel an altogether unique class of information.

At times, we have undertaken discursive diversions at crucial junctures to explain specific concepts, which may not be directly related to the main topic. This has been done to provide a holistic panorama of the .Net architecture.

Tables have been drawn and screen shots have been provided to reinforce the assumptions and to illustrate the concepts that have been proffered.

Finally, since no cross-connections could be established between these tables while exploring each of them, we chose to dedicate the last chapter to the display of all the linkages and to provide values to the data stored in the table.

Although we are aware that there is scope for extensive enhancement to make this book exhaustive, we chose to wrap it up at this stage. This is because we hope that by the time you reach the end of this book, you would have developed a penchant for Metadata tables and would be in a position to explore the subject further by yourself.

In addition to the samples, Microsoft has also offered a program called Metainfo, which provides a dump of the Metadata. Another program utility that can be used is the disassembler, known as the ILDASM. These two utilities can be used to verify and validate the output of our program.

We take immense pleasure in proclaiming the fact that we are the pioneers in employing the C# language while writing our metadata program. We are convinced that even the tools have not been written in C#. Since our primary focus has been on the task of discerning the tables and their contents, the chores of alignment and the formatting have taken a back seat.

In order to serve up all this information to you, we have scrutinized the Web in its entirety, and have extracted meaningful inputs from it. Further, we have probed the unfathomable depths of the 'uncomplicated' technical documentation provided by Microsoft.

Towards the latter part of this book, we have inspected the intricacies of each and every bit, and have investigated all the formatting issues. Once more, a program written in C# comports itself like the ILDASM utility, providing substantial information about every table and its field attributes.

In conclusion, we reiterate that this is a path-breaking book, which delves into the internals of the .Net architecture, which is a virgin territory. We hope that you enjoy your journey into this exotic domain and put the knowledge gained from this book to good use. We are confident that this book will pave the way to sculpt you into an aficionado of the .Net architecture. We wish you good luck and happy reading!

Minimum Requirements

The software requirements to successfully run all the programs in this book are

• Operating System - Windows 2000, Windows XP

• Visual Studio.Net or .Net Framework SDK

• UltraEdit-32 (can be downloaded from http://www.download.com)

Acknowledgements

I wish to thank a number of people who gave me their support, new ideas and inspiration while writing this book.

First and foremost, thanks to Manish Jain, BPB Publications for publishing the book.

Special thanks to my co-authors, Akash and Sonal, who have put in their very best in the work assigned to them as without them and their efforts the book would have never seen the light of day.

Thanks to Tanuja Sodhi, an ex-naval officer from the first batch of lady officers and an MBA from JBIMS for editing the book. She is presently freelancing as a creative writer.

Thanks to my cover designers, Altaf Hemani and Kishore Rohra, for designing the cover.

Thanks to Manish Purohit for putting in all the time he had to verify the code with the explanations and then giving the book a good look and feel.

To Shivanand Shetty, who made it simple for me and my co-authors to come up with the book. He has always been a source of inspiration and encouragement.

A long list of friends need a mention here for their patience and cooperation on this book while it was being written.

-Vijay Mukhi