What is the CLI? Is it the same as the CLR?

The CLI (Common Language Infrastructure) is the definiton of the fundamentals
of the .NET framework - the Common Type System (CTS), metadata, the Virtual Execution
Environment (VES) and its use of intermediate language (IL), and the support of
multiple programming languages via the Common Language Specification (CLS). The
CLI is documented through ECMA - see http://msdn.microsoft.com/net/ecma/ for more
details.

The CLR (Common Language Runtime) is Microsoft's primary implementation of
the CLI. Microsoft also have a shared source implementation known as ROTOR,
for educational purposes, as well as the .NET Compact Framework for mobile devices.
Non-Microsoft CLI implementations include Mono and DotGNU Portable.NET.

What is the CTS, and how does it relate to the CLS?

CTS = Common Type System. This is the full range of types that the .NET runtime
understands. Not all .NET languages support all the types in the CTS.

CLS = Common Language Specification. This is a subset of the CTS which all
.NET languages are expected to support. The idea is that any program which uses
CLS-compliant types can interoperate with any .NET program written in any language.
This interop is very fine-grained - for example a VB.NET class can inherit from
a C# class.

2.3 What is IL?

IL = Intermediate Language. Also known as MSIL (Microsoft Intermediate Language)
or CIL (Common Intermediate Language). All .NET source code (of any language)
is compiled to IL during development. The IL is then converted to machine code
at the point where the software is installed, or (more commonly) at run-time
by a Just-In-Time (JIT) compiler.

2.4 What is C#?

C# is a new language designed by Microsoft to work with the .NET framework.
In their "Introduction to C#" whitepaper, Microsoft describe C# as
follows:

"C# is a simple, modern, object oriented, and type-safe programming language
derived from C and C++. C# (pronounced “C sharp”) is firmly planted
in the C and C++ family tree of languages, and will immediately be familiar
to C and C++ programmers. C# aims to combine the high productivity of Visual
Basic and the raw power of C++."

Substitute 'Java' for 'C#' in the quote above, and you'll see that the statement
still works pretty well :-).

If you are a C++ programmer, you might like to check out my C# FAQ.

What does 'managed' mean in the .NET context?

The term 'managed' is the cause of much confusion. It is used in various places
within .NET, meaning slightly different things.

Managed code: The .NET framework provides several core run-time services to
the programs that run within it - for example exception handling and security.
For these services to work, the code must provide a minimum level of information
to the runtime. Such code is called managed code.

Managed data: This is data that is allocated and freed by the .NET runtime's
garbage collector.

Managed classes: This is usually referred to in the context of Managed Extensions
(ME) for C++. When using ME C++, a class can be marked with the __gc keyword.
As the name suggests, this means that the memory for instances of the class
is managed by the garbage collector, but it also means more than that. The class
becomes a fully paid-up member of the .NET community with the benefits and restrictions
that brings. An example of a benefit is proper interop with classes written
in other languages - for example, a managed C++ class can inherit from a VB
class. An example of a restriction is that a managed class can only inherit
from one base class.

What is reflection?

All .NET compilers produce metadata about the types defined in the modules they
produce. This metadata is packaged along with the module (modules in turn are
packaged together in assemblies), and can be accessed by a mechanism called
reflection. The System.Reflection namespace contains classes that can be used
to interrogate the types for a module/assembly.

Using reflection to access .NET metadata is very similar to using ITypeLib/ITypeInfo
to access type library data in COM, and it is used for similar purposes - e.g.
determining data type sizes for marshaling data across context/process/machine
boundaries.

Reflection can also be used to dynamically invoke methods (see System.Type.InvokeMember),
or even create types dynamically at run-time (see System.Reflection.Emit.TypeBuilder).

Take it from http://www.andymcm.com/dotnetfaq.htm