ASP.NET Is Hosted by the Common Language Runtime

Perhaps the most important aspect of the ASP.NET engine is that it runs inside the runtime environment
of the CLR. The whole of the .NET Framework—that is, all namespaces, applications, and classes—is
referred to as managed code. Though a full-blown investigation of the CLR is beyond the scope of this
chapter, some of the benefits are as follows:
Automatic memory management and garbage collection: Every time your application instantiates
a reference-type object, the CLR allocates space on the managed heap for that object. However, you
never need to clear this memory manually. As soon as your reference to an object goes out of scope
(or your application ends), the object becomes available for garbage collection. The garbage
collector runs periodically inside the CLR, automatically reclaiming unused memory for
inaccessible objects. This model saves you from the low-level complexities of C++ memory handling
and from the quirkiness of COM reference counting.
Type safety: When you compile an application, .NET adds information to your assembly that
indicates details such as the available classes, their members, their data types, and so on. As a result,
other applications can use them without requiring additional support files, and the compiler can
verify that every call is valid at runtime. This extra layer of safety completely obliterates whole
categories of low-level errors.
Extensible metadata: The information about classes and members is only one of the types of
metadata that .NET stores in a compiled assembly. Metadata describes your code and allows you to
provide additional information to the runtime or other services. For example, this metadata might
tell a debugger how to trace your code, or it might tell Visual Studio how to display a custom control
at design time. You could also use metadata to enable other runtime services, such as transactions
or object pooling.
Structured error handling: .NET languages offer structured exception handling, which allows you to
organize your error-handling code logically and concisely. You can create separate blocks to deal
with different types of errors. You can also nest exception handlers multiple layers deep.
Multithreading: The CLR provides a pool of threads that various classes can use. For example, you
can call methods, read files, or communicate with web services asynchronously, without needing to
explicitly create new threads.
Figure 1-2 shows a high-level look at the CLR and the .NET Framework.