application domain (AppDomain)

A boundary that the common language runtime establishes around objects created
within the same application scope (that is, anywhere along the sequence of object
activations beginning with the application entry point). Application domains help
isolate objects created in one application from those created in other applications
so that run-time behavior is predictable. Multiple application domains can exist in
a single process.

assembly
A collection of one or more files that are versioned and deployed as a unit. An
assembly is the primary building block of a .NET Framework application. All
managed types and resources are contained within an assembly and are marked
either as accessible only within the assembly or as accessible from code in other
assemblies. Assemblies also play a key role in security. The code access security
system uses information about the assembly to determine the set of permissions
that code in the assembly is granted.

private assembly
An assembly that is available only to clients in the same directory structure as the
assembly.

shared assembly
An assembly that can be referenced by more than one application. An assembly
must be explicitly built to be shared by giving it a cryptographically strong name.

assembly manifest
An integral part of every assembly that renders the assembly self-describing. The
assembly manifest contains the assembly's metadata. The manifest establishes the
assembly identity, specifies the files that make up the assembly implementation,
specifies the types and resources that make up the assembly, itemizes the compile-
time dependencies on other assemblies, and specifies the set of permissions
required for the assembly to run properly. This information is used at run time to
resolve references, enforce version binding policy, and validate the integrity of
loaded assemblies. The self-describing nature of assemblies also helps makes
zero-impact install and XCOPY deployment feasible.

metadata
Information that describes every element managed by the common language
runtime: an assembly, loadable file, type, method, and so on. This can include
information required for debugging and garbage collection, as well as security
attributes, marshaling data, extended class and member definitions, version
binding, and other information required by the runtime.

assertion (Assert)
In .NET Framework security, ensures that a method has access to a particular
resource even if the method's callers do not have the required permission. During
 a stack walk, if a stack frame asserting the required permission is encountered, a
security check for that permission will succeed. Assertions can create security
holes and should be used only with extreme caution.
attribute
A descriptive declaration that annotates programming elements such as types,
fields, methods, and properties. Attributes are saved with the metadata of a .NET
Framework file and can be used to describe code to the common language
runtime or to affect application behavior at run time.

boxing
The conversion of a value type instance to an object, which implies that the instance will
carry full type information at run time and will be allocated in the heap. The Microsoft
intermediate language (MSIL) instruction set's box instruction converts a value type to an
object by making a copy of the value type and embedding it in a newly allocated object.

Microsoft intermediate language (MSIL)

A language used as the output of a number of compilers and as the input to a just-
in-time (JIT) compiler. The common language runtime includes a JIT compiler for
converting MSIL to native code.

JIT
An acronym for "just-in-time," a phrase that describes an action that is taken only
when it becomes necessary, such as just-in-time compilation or just-in-time object
activation.
JIT compilation
The compilation that converts Microsoft intermediate language (MSIL) into
machine code at the point when the code is required at run time.

unboxing
The conversion of an object instance to a value type.

unmanaged code
Code that is executed directly by the operating system, outside the common
language runtime environment. Unmanaged code must provide its own garbage
collection, type checking, security support, and so on, unlike managed code,
which receives these services from the common language runtime.

user control
In Windows Forms: A composite control that provides consistent behavior and user
interface within or across applications. The user control can be local to one application or
added to a library and compiled into a DLL for use by multiple applications.
CLS-compliant
Code that publicly exposes only language features that are in the Common
Language Specification. CLS compliance can apply to classes, interfaces,
components, and tools.

common language runtime

The engine at the core of managed code execution. The runtime supplies managed
code with services such as cross-language integration, code access security, object
lifetime management, and debugging and profiling support.

Common Language Specification (CLS)

A subset of language features supported by the common language runtime,
including features common to several object-oriented programming languages.
CLS-compliant components and tools are guaranteed to interoperate with other
CLS-compliant components and tools. See also: CLS-compliant.

common type system

The specification that determines how the common language runtime defines,
uses, and manages types.

composite control
A custom server control that consists of a custom collection of other server
controls as child controls.

custom control
A control authored by a user or a third-party software vendor that does not belong
to the .NET Framework class library. This is a generic term that also includes user
controls. Custom server controls are used in Web Forms (ASP.NET pages).
Custom client controls are used in Windows Forms applications.

delegate
A reference type that is the managed version of a C++ function pointer. Delegates
can reference both instance and static (in Visual Basic, Shared) methods, whereas
function pointers can reference only static (in Visual Basic, Shared) methods.

reference type
A data type that is represented by a reference (similar to a pointer) to the type's
actual value. If a reference type is assigned to a variable, that variable references
(or "points to") the original value. No copy is made. Reference types comprise
classes, interfaces, delegates, and boxed value types.

encapsulation
The ability of an object to hide its internal data and methods, making only the
intended parts of the object programmatically accessible.
enum (enumeration)
A special form of value type that inherits from System.Enum and supplies
alternate names for the values of an underlying primitive type. An enumeration
type has a name, an underlying type, and a set of fields. The underlying type must
be one of the built-in signed or unsigned integer types (such as Byte, Int32, or
UInt64). The fields are static literal fields, each of which represents a constant.
The language you are using assigns a specific value of the underlying type to each
field.
Extensible Markup Language (XML)
A subset of Standard Generalized Markup Language (SGML) that is optimized
for delivery over the Web. XML provides a uniform method for describing and
exchanging structured data that is independent of applications or vendors.

field
A member that represents a variable associated with an object or class.

global assembly cache (GAC)

A machine-wide code cache that stores assemblies specifically installed to be
shared by many applications on the computer. Applications deployed in the global
assembly cache must have a strong name.

globalization
The process of designing and developing a software product to function in
multiple locales. Globalization involves identifying the locales that must be
supported, designing features that support those locales, and writing code that
functions equally well in any of the supported locales.
localization
The process of customizing or translating the separated data and resources needed
for a specific region or language.
GDI+
The portion of the Microsoft Windows XP operating system that provides two-
dimensional vector graphics, imaging, and typography. GDI+ improves on GDI
(the graphics device interface included with earlier versions of Windows) by
adding new features and optimizing existing features. The GDI+ managed class
interface (a set of wrappers) is part of the Microsoft .NET Framework.

garbage collection (GC)

The process of transitively tracing through all pointers to actively used objects in
order to locate all objects that can be referenced, and then arranging to reuse any
heap memory that was not found during this trace. The common language runtime
garbage collector also compacts the memory that is in use to reduce the working
space needed for the heap.
heap
A portion of memory reserved for a program to use for the temporary storage of
data structures whose existence or size cannot be determined until the program is
running.

indexer
A class member that permits instances of a class or structure to be sorted in the
same way as arrays. Indexers are similar to properties, except that the get and set
accessor methods of indexers take parameters, while property accessor methods
do not.
interface
A reference type that defines a contract. Other types implement an interface to
guarantee that they support certain operations. The interface specifies the
members that must be supplied by classes or other interfaces that implement it.
Like classes, interfaces can contain methods, properties, indexers, and events as
members.

managed code
Code that is executed by the common language runtime environment rather than
directly by the operating system. Managed code applications gain common
language runtime services such as automatic garbage collection, runtime type
checking and security support, and so on. These services provide uniform
platform- and language-independent behavior of managed-code applications.
module
A loadable unit, which can contain type declarations and type implementations.
The module contains enough information to enable the common language runtime
to locate all implementation bits when the module is loaded. The format for
modules is an extension of the Windows portable executable (PE) file format.
When deployed, a module is always contained in an assembly.

namespace
A logical naming scheme for grouping related types. The .NET Framework uses a
hierarchical naming scheme for grouping types into logical categories of related
functionality, such as the ASP.NET technology or remoting functionality. Design
tools can use namespaces to make it easier for developers to browse and reference
types in their code. A single assembly can contain types whose hierarchical names
have different namespace roots, and a logical namespace root can span multiple
assemblies. In the .NET Framework, a namespace is a logical design-time naming
convenience, whereas an assembly establishes the name scope for types at run
time.

.NET Compact Framework

A hardware-independent environment for running programs on resource-
constrained computing devices. It inherits the full .NET Framework architecture
of the common language runtime, supports a subset of the .NET Framework class
 library, and contains classes designed exclusively for the .NET Compact
Framework. Supported devices include personal data assistants (PDAs) (such as
the Pocket PC), mobile phones, set-top boxes, automotive computing devices, and
custom-designed embedded devices built with the Microsoft Windows CE.NET
operating system.

.NET Framework class library

A CLS-compliant library of classes, interfaces, and value types that are included
in the Microsoft .NET Framework SDK. This library provides access to system
functionality and is designed to be the foundation on which .NET Framework
applications, components, and controls are built.

property
A class member that is like a public field, but that includes features such as
versioning, encapsulation, and the ability to execute additional logic through get
and set accessor methods.

portable executable (PE) file

The file format used for executable programs and for files to be linked together to
form executable programs

reflection
The process of obtaining information about assemblies and the types defined
within them, and creating, invoking, and accessing type instances at run time.

remoting
The process of communication between different operating system processes,
regardless of whether they are on the same computer. The .NET remoting system
is an architecture designed to simplify communication between objects living in
different application domains, whether on the same computer or not, and between
different contexts, whether in the same application domain or not.

strong name
A name that consists of an assembly's identity — its simple text name, version
number, and culture information (if provided) — strengthened by a public key and
a digital signature generated over the assembly. Because the assembly manifest
contains file hashes for all the files that constitute the assembly implementation, it
is sufficient to generate the digital signature over just the one file in the assembly
that contains the assembly manifest. Assemblies with the same strong name are
expected to be identical.

SOAP
A simple, XML-based protocol for exchanging structured and type information on
the Web. The protocol contains no application or transport semantics, which
makes it highly modular and extensible.
structure
A user-defined value type. Like a class, structures can contain constructors,
constants, fields, methods, properties, indexers, operators, and nested types.
Unlike classes, however, structures do not support inheritance.

value type
A data type that is represented by the type's actual value. If a value type is
assigned to a variable, that variable is given a fresh copy of the value. (This is in
contrast to a reference type, where assignment does not create a copy.) Value
types are usually created on a method's stack frame, rather than in the garbage-
collected heap. A value type can be boxed, which is a process that creates a
corresponding reference type.

XML Web services

Units of application logic providing data and services to other applications.
Applications access XML Web services using standard Web protocols and data
formats such as HTTP, XML, and SOAP, independent of how each XML Web
service is implemented. XML Web services combine the best aspects of both
component-based development and the Web, and they are a cornerstone of the
Microsoft .NET programming model.