The common language runtime manages memory, thread
execution, code execution, code safety verification, compilation, and
other system services. These features are intrinsic to the managed code
that runs on the common language runtime.
With regards to security, managed components are awarded
varying degrees of trust, depending on a number of factors that include
their origin (such as the Internet, enterprise network, or local
computer). This means that a managed component might or might not be
able to perform file-access operations, registry-access operations, or
other sensitive functions, even if it is being used in the same active
The runtime enforces code access security. For example,
users can trust that an executable embedded in a Web page can play an
animation on screen or sing a song, but cannot access their personal
data, file system, or network. The security features of the runtime thus
enable legitimate Internet-deployed software to be exceptionally
The runtime also enforces code robustness by implementing
a strict type-and-code-verification infrastructure called the common
type system (CTS). The CTS ensures that all managed code is
self-describing. The various Microsoft and third-party language
compilers generate managed code that conforms to the CTS. This means
that managed code can consume other managed types and instances, while
strictly enforcing type fidelity and type safety.
In addition, the managed environment of the runtime
eliminates many common software issues. For example, the runtime
automatically handles object layout and manages references to objects,
releasing them when they are no longer being used. This automatic memory
management resolves the two most common application errors, memory
leaks and invalid memory references.
The runtime also accelerates developer productivity. For
example, programmers can write applications in their development
language of choice, yet take full advantage of the runtime, the class
library, and components written in other languages by other developers.
Any compiler vendor who chooses to target the runtime can do so.
Language compilers that target the .NET Framework make the features of
the .NET Framework available to existing code written in that language,
greatly easing the migration process for existing applications.
While the runtime is designed for the software of the
future, it also supports software of today and yesterday.
Interoperability between managed and unmanaged code enables developers
to continue to use necessary COM components and DLLs.
The runtime is designed to enhance performance. Although
the common language runtime provides many standard runtime services,
managed code is never interpreted. A feature called just-in-time (JIT)
compiling enables all managed code to run in the native machine language
of the system on which it is executing. Meanwhile, the memory manager
removes the possibilities of fragmented memory and increases memory
locality-of-reference to further increase performance.
Finally, the runtime can be hosted by high-performance,
server-side applications, such as Microsoft SQL Server and Internet
Information Services (IIS). This infrastructure enables you to use
managed code to write your business logic, while still enjoying the
superior performance of the industry's best enterprise servers that
support runtime hosting.