What is .NET metadata?

In the past, a software component (.exe or .dll) written in one language could not easily use a software component written in another language. COM provided a step forward in solving this problem. The .NET Framework makes component interoperation even easier by allowing compilers to emit additional declarative information into all modules and assemblies. This information, called metadata, helps components to seamlessly interact.

Metadata is binary information describing your program that is stored either in a common language runtime portable executable (PE) file or in memory. When you compile your code into a PE file, metadata is inserted into one portion of the file, while your code is converted to Microsoft intermediate language (MSIL) and inserted into another portion of the file.

Metadata describes all classes and class members that are defined in the assembly, and the classes and class members that the current assembly will call from another assembly. The metadata for a method contains the complete description of the method, including the class (and the assembly that contains the class), the return type and all of the method parameters. When the CLR executes CIL it will check to make sure that the metadata of the called method is the same as the metadata that is stored in the calling method. This ensures that a method can only be called with exactly the right number of parameters and exactly the right parameter types.

Metadata is the key to a simpler programming model, eliminating the need for Interface Definition Language (IDL) files, header files, or any external method of component reference. Metadata allows .NET languages to describe themselves automatically in a language-neutral manner, unseen by both the developer and the user. Additionally, metadata is extensible through the use of attributes.

The Common Language Specification (CLS), which is a set of basic language features needed by many .Net applications to fully interact with other objects regardless of the language in which they were implemented. The CLS represents the guidelines defined by for the .NET Framework. These specifications are normally used by the compiler developers and are available for all languages, which target the .NET Framework.

The CLS helps enhance and ensure language interoperability by defining a set of features that developer can rely on to be available in a wide variety of languages.

The CLR is the layer of the .NET Framework that makes language independence work. Written mostly in Microsoft’s new language, C#, the CLR provides services that any .NET program can use. Because of .NET’s component architecture, software written in any language can call upon these services.

Microsoft has also submitted a subset of the CLR to ECMA, the European information and communications standards organization. This subset is referred to as the Common Language Infrastructure (CLI).

CLR provides following services:

• Language Integration
• Memory Management (Memory Allocation and Garbage Collection)
• Memory Type Safety (Memory Leaks)
• Security
• Thread management
• Exception handling

There are three types JIT (just in time) compiler. Those are as follows…

• Pre-JIT compiler (Compiles entire code into native code completely)
• Econo JIT compiler (Compiles code part by part freeing when required)
• Normal JIT compiler (Compiles only that part of code when called and places in cache)

JIT (just-in-time) is a CLR’s (Common Language Runtime) compiler. The JIT Compiler function is responsible for compiling a method’s IL code into native CPU instructions. Because the IL(intermediate language) is being compiled "just in time," this component of the CLR is frequently referred to as a JITter or a JIT compiler.

When JIT called, the JIT Compiler function knows what method is being called and what type defines this method. The JIT Compiler function then searches the defining assembly’s metadata for the called method’s IL. JITCompiler next verifies and compiles the IL code into native CPU instructions. The native CPU instructions are saved in a dynamically allocated block of memory. Then, JITCompiler goes back to the type’s internal data structure and replaces the address of the called method with the address of the block of memory containing the native CPU instructions. Finally, JITCompiler jumps to the code in the memory block. This code is then implementation means particular code get executed.