Sharing a common base for source code•
Compiling code to the Microsoft intermediate language (MSIL)•
I discuss these features in the next few sections.
Managed Data
The .NET Framework compilers mainly produce managed code, which is managed by the CLR. Managed
code means managed data, which in turn means data with lifetimes managed by the CLR. This is also referred
to as garbage collection, which you can read about in the next section. Managed data will definitely help
eliminate memory leaks, but at the same time it also means you have less control over your data, because you
no longer have deterministic finalization, which is arguably one of the strengths of COM(+).
Automatic Garbage Collection
When objects are managed (allocated and released) by the CLR, you don't have full control over them. The
CLR handles the object layout and the references to the objects, disposing of the objects when they're no
longer being used. This process is called automatic garbage collection. This process is very different from the
one for handling objects in previous versions of Visual Basic or Visual C++ known as deterministic
finalization. These programming languages used COM as their component model and, as such, they used the
COM model for referencing and counting objects. As a result, whenever your application instantiated an
object, a counter for this object reference was incremented by one, and when your application destroyed the
object reference or when it went out of scope, the counter was decremented. When the counter hit zero, the
object would be released automatically from memory. This is something you have to be very aware of now,
because you no longer have full control over your object references. If you're aJava programmer, you
probably already know about this.
Source Code Shares Common Base
Because all the CLR−compliant compilers produce managed code, the source code shares the same basethat
is, the type system (CTS) and to some extent the language specification (CLS). This means you can inherit
classes written in a language other than the one you're using, a concept known as cross−language inheritance.
This is a great benefit to larger development teams, where the developers' skill sets are likely rather different.
Another major benefit is when you need to debugyou can now safely debug within the same environment
source code across various programming languages.
Intermediate Language Compilation
When you compile your code, it's compiled to what is called Microsoft intermediate language (MSIL) and
stored in a portable executable (PE) file along with metadata that describes the types (classes, interfaces, and
value types) used in the code. Because the compiled code is in an "intermediate state," the code is platform
independent. This means the MSIL code can be executed on any platform that has the CLR installed. The
metadata that exists in the PE file along with the MSIL enables your code to describe itself, which means
there is no need for type libraries or Interface Definition Language (IDL) files. The CLR locates the metadata
in the PE file and extracts it from there as necessary when the file is executed.
At runtime, the CLR's JIT compilers convert the MSIL code to machine code, which is then executed. This
machine code is obviously appropriate for the platform on which the CLR is installed. The JIT compilers and
the CLR are made by various vendors, and I suppose the most notable one is Microsoft's Windows CLR
(surprise, eh?).
Database Programming with C#
A Quick Look at Components of the .NET Framework 9