Glossary

For the purpose of this International Standard, the following definitions apply. They are collected here for ease of reference, but the definitions are presented in context elsewhere in the specification, as noted. Definitions enclosed in square brackets [ ] were not extracted from the body of the standard.

The remainder of this section and its subsections contain only informative text.

Term	Description	Pt	Section	Section Title
Abstract	Only an abstract object type is allowed to define method contracts for which the type or the VES does not also provide the implementation. Such method contracts are called abstract methods.	I	8.9.6.2	Concreteness
Accessibility of members	A type scopes all of its members, and it also specifies the accessibility rules for its members. Except where noted, accessibility is decided based only on the statically visible type of the member being referenced and the type and assembly that is making the reference. The CTS [Common Type System] supports seven different rules for accessibility: Compiler-Controlled; Private; Family; Assembly; Family-and-Assembly; Family-or-Assembly; Public.	I	8.5.3.2	Accessibility of Members
Aggregate data	Data items that have sub-components (arrays, structures, or object instances) but are passed by copying the value. The sub-components can include references to managed memory. Aggregate data is represented using a value type . . .	I	12.1.6	Aggregate Data
Application domain	A mechanism . . . to isolate applications running in the same operating system process from one another.	I	12.5	Proxies and Remoting
Array elements	The representation of a value (except for those of built-in types) can be subdivided into sub-values. These sub-values are either named, in which case they are called fields, or they are accessed by an indexing expression, in which case they are called array elements.	I	8.4.1	Fields, Array Elements, and Values
Argument	[Value of an operand to a method call.]
Array types	Types that describe values composed of array elements are array types.	I	8.4.1	Fields, Array Elements, and Values
Assembly	An assembly is a configured set of loadable code modules and other resources that together implement a unit of functionality.	I	8.5.2	Assemblies and Scoping
Assembly scope	Type names are scoped by the assembly that contains the implementation of the type. . . . The type name is said to be in the assembly scope of the assembly that implements the type.	I	8.5.2	Assemblies and Scoping
Assignment compatibility	Assignment compatibility of a value (described by a type signature) to a location (described by a location signature) is defined as follows: One of the types supported by the exact type of the value is the same as the type in the location signature.	I	8.7	Assignment Compatibility
Attributes	Attributes of types and their members attach descriptive information to their definition.	II	5.9	Attributes and Metadata
Base Class Library	This library is part of the Kernel Profile. It is a simple runtime library for a modern programming language.	IV	5.2	Base Class Library
Binary operators	Binary operators take two arguments, perform some operation, and return a value. They are represented as static methods on the class that defines the type of one of their two operands or the return type.	I	10.3.2	Binary Operators
Boolean data type	A CLI [Common Language Infrastructure] Boolean type occupies 1 byte in memory. A bit pattern of all zeros denotes a value of false. A bit pattern with any bit set (analogous to a non-zero integer) denotes a value of true.	III	1.1.2	Boolean Data Type
Box	The box instruction is a widening (always typesafe) operation that converts a value type instance to System.Object by making a copy of the instance and embedding it in a newly allocated object.	I	12.1.6.2.5	Boxing and Unboxing
Boxed type	For every Value Type, the CTS [Common Type System] defines a corresponding Reference Type called the boxed type.	I	8.2.4	Boxing and Unboxing of Values
Boxed value	The representation of a value of a boxed type (a boxed value) is a location where a value of the Value Type may be stored.	I	8.2.4	Boxing and Unboxing of Values
Built-in types	Data types [that] are an integral part of the CTS [Common Type System] and are supported directly by the Virtual Execution System (VES).	I	8.2.2	Built-in Types
By-ref parameters	The address of the data is passed from the caller to the callee, and the type of the parameter is therefore a managed or unmanaged pointer.	I	12.4.1.5	Parameter Passing
By-value parameters	The value of an object is passed from the caller to the callee.	I	12.4.1.5	Parameter Passing
Calling convention	A calling convention specifies how a method expects its arguments to be passed from the caller to the called method.	II	14.3	Calling Convention
Casting	Since a value can be of more than one type, a use of the value needs to clearly identify which of its types is being used. Since values are read from locations that are typed, the type of the value which is used is the type of the location from which the value was read. If a different type is to be used, the value is cast to one of its other types.	I	8.3.3	Casting
CIL	[Common Intermediate Language]	[III]
Class contract	A class contract specifies the representation of the values of the class type. Additionally, a class contract specifies the other contracts that the class type supports e.g., which interfaces, methods, properties, and events shall be implemented.	I	8.6	Contracts
Class type	A complete specification of the representation of the values of the class type and all of the contracts (class, interface, method, property, and event) that are supported by the class type.	I	8.9.5	Class Type Definition
CLI	At the center of the Common Language Infrastructure (CLI) is a single type system, the Common Type System (CTS), that is shared by compilers, tools, and the CLI itself. It is the model that defines the rules the CLI follows when declaring, using, and managing types.	I	6	Overview of the Common Language Infrastructure
CLS	The Common Language Specification (CLS) is a set of conventions intended to promote language interoperability.	I	7	Common Language Specification (CLS)
CLS (consumer)	A CLS consumer is a language or tool that is designed to allow access to all of the features supplied by CLS-compliant frameworks (libraries), but not necessarily be able to produce them.	I	7	Common Language Specification (CLS)
CLS (extender)	A CLS extender is a language or tool that is designed to allow programmers to both use and extend CLS-compliant frameworks.	I	7	Common Language Specification (CLS)
CLS (framework)	A library consisting of CLS-compliant code is herein referred to as a "framework."	I	7	Common Language Specification (CLS)
Code labels	Code labels are followed by a colon (":") and represent the address of an instruction to be executed.	II	5.4	Labels and Lists of Labels
Coercion	Coercion takes a value of a particular type and a desired type and attempts to create a value of the desired type that has equivalent meaning to the original value.	I	8.3.2	Coercion
Common Language Specification (CLS)	The Common Language Specification (CLS) is a set of conventions intended to promote language interoperability.	I	7	Common Language Specification (CLS)
Common Type System (CTS)	The Common Type System (CTS) provides a rich type system that supports the types and operations found in many programming languages.	I	8	Common Type System
Compiler-controlled accessibility	Accessible only through use of a definition, not a reference, hence only accessible from within a single compilation unit and under the control of the compiler.	I	8.5.3.2	Accessibility of Members
Compound types	Types that describe values composed of fields are compound types.	I	8.4.1	Fields, Array Elements, and Values
Computed destinations	The destination of a method call may be either encoded directly in the CIL instruction stream (the call and jmp instructions) or computed (the callvirt and calli instructions).	I	12.4.1.3	Computed Destinations
Concrete	An object type that is not marked abstract is by definition concrete.	I	8.9.6.2	Concreteness
Conformance	A system claiming conformance to this International Standard shall implement all the mandatory requirements of this standard, and shall specify the profile that it implements.	I	2	Conformance
Contracts	Contracts are named. They are the shared assumptions on a set of signatures . . . between all implementers and all users of the contract.	I	8.6	Contracts
Conversion operators	Conversion operators are unary operations that allow conversion from one type to another. The operator method shall be defined as a static method on either the operand or the return type.	I	10.3.3	Conversion Operators
Custom attributes	Custom attributes add user-defined annotations to the metadata. Custom attributes allow an instance of a type to be stored with any element of the metadata.	II	20	Custom Attributes
Custom modifiers	Custom modifiers, defined using modreq ("required modifier") and modopt ("optional modifier"), are similar to custom attributes . . . except that modifiers are part of a signature rather than attached to a declaration. Each modifer associates a type reference with an item in the signature.	II	7.1.1	modreq and modopt
Data labels	Data labels specify the location of a piece of data.	II	5.4	Labels and Lists of Labels
Delegates	Delegates are the object-oriented equivalent of function pointers. Delegates are created by defining a class that derives from the base type System.Delegate.	I	8.9.3	Delegates
Derived type	A derived type guarantees support for all of the type contracts of its base type. A type derives directly from its specified base type(s), and indirectly from their base type(s).	I	8.9.8	Type Inheritance
Enums	An enum, short for "enumeration," defines a set of symbols that all have the same type.	II	13.3	Enums
Equality	For value types, the equality operator is part of the definition of the exact type. Definitions of equality should obey the following rules: Equality should be an equivalence operator, as defined above. Identity should imply equality, as stated earlier. If either (or both) operand is a boxed value, equality should be computed by First unboxing any boxed operand(s), and then Applying the usual rules for equality on the resulting values.	I	8.2.5.2	Equality
Equality of values	The values stored in the variables are equal if the sequences of characters are the same.	I	8.2.5	Identity and Equality of Values
Evaluation stack	Associated with each method state is an evaluation stack. . . . The evaluation stack is made up of slots that can hold any data type, including an unboxed instance of a value type.	I	12.3.2.1	The Evaluation Stack
Event contract	An event contract is specified with an event definition. There is an extensible set of operations for managing a named event, which includes three standard methods (register interest in an event, revoke interest in an event, fire the event). An event contract specifies method contracts for all of the operations that shall be implemented by any type that supports the event contract.	I	8.6	Contracts
Event definitions	The CTS [Common Type System] supports events in precisely the same way that it supports properties. . . . The conventional methods, however, are different and include means for subscribing and unsubscribing to events as well as for firing the event.	I	8.11.4	Event Definitions
Exception handling	Exception handling is supported in the CLI through exception objects and protected blocks of code	I	12.4.2	Exception Handling
Extended Array Library	This Library is not part of any Profile, but can be supplied as part of any CLI implementation. It provides support for non-vector arrays.	IV	5.7	Extended Array Library
Extended Numerics Library	The Extended Numerics Library is not part of any Profile, but can be supplied as part of any CLI implementation. It provides the support for floating point (System.Float, System.Double) and extended-precision (System.Decimal) data types.	IV	5.6	Extended Numerics Library
Family accessibility	Accessible to referents that support the same type i.e., an exact type and all of the types that inherit from it.	I	8.5.3.2	Accessibility of Members
Family-and-assembly accessibilty	Accessible only to referents that qualify for both family and assembly access.	I	8.5.3.2	Accessibility of Members
Family-or-assembly accessibility	Accessible only to referents that qualify for either family or assembly access.	I	8.5.3.2	Accessibility of Members
Field definitions	Field definitions [are composed of a] name and a location signature.	I	8.11.2	Field Definitions
Field inheritance	A derived object type inherits all of the non-static fields of its base object type.	I	8.10.1	Field Inheritance
Fields	Fields are typed memory locations that store the data of a program.	II	15	Defining and Referencing Fields
File names	A file name is like any other name where "." is considered a normal constituent character. The specific syntax for file names follows the specifications of the underlying operating system.	II	5.8	File Names
Finalizers	A class definition that creates an object type may supply an instance method to be called when an instance of the class is no longer accessible.	I	8.9.6.7	Finalizers
Getter method	By convention, properties define a getter method (for accessing the current value of the property).	I	8.11.3	Property Definitions
Global fields	In addition to types with static members, many languages have the notion of data and methods that are not part of a type at all. These are referred to as global fields and methods.	II	9.8	Global Fields and Methods
Global methods	In addition to types with static members, many languages have the notion of data and methods that are not part of a type at all. These are referred to as global fields and methods.	II	9.8	Global Fields and Methods
Global state	The CLI manages multiple concurrent threads of control . . . , multiple managed heaps, and a shared memory address space.	I	12.3.1	The Global State
GUID	[A unique identification string used with remote procedure calls.]	II	23
hide-by-name	The introduction of a name in a given type hides all inherited members of the same kind (method or field) with the same name.	II	8.3	Hiding
hide-by-name-and-sig	The introduction of a name in a given type hides any inherited member of the same kind but with precisely the same type (for fields) or signature (for methods, properties, and events).	II	8.3	Hiding
Hiding	Hiding controls which method names inherited from a base type are available for compile-time name binding.	II	8	Visibility, Accessibility, and Hiding
Homes	The home of a data value is where it is stored for possible reuse.	I	12.1.6.1	Homes for Values
Identifiers	Identifiers are used to name entities	II	5.3	Identifiers
Identity	The identity operator is defined by the CTS as follows. If the values have different exact types, then they are not identical. Otherwise, if their exact type is a Value Type, then they are identical if and only if the bit sequences of the values are the same, bit by bit. Otherwise, if their exact type is a Reference Type, then they are identical if and only if the locations of the values are the same.	I	8.2.5.1	Identity
Identity of values	The values of the variables are identical if the locations of the sequences of characters are the same i.e., there is in fact only one string in memory.	I	8.2.5	Identity and Equality of Values
ilasm	An assembler language for CIL.	II	2	Overview
Inheritance demand	When attached to a type, an inheritance demand requires that any type that wishes to inherit from this type shall have the specified security permission. When attached to a non-final virtual method, it requires that any type that wishes to override this method shall have the specified permission.	I	8.5.3.3	Security Permissions
Instance methods	Instance methods are associated with an instance of a type: within the body of an instance method it is possible to reference the particular instance on which the method is operating (via the this pointer).	II	14.2	Static, Instance, and Virtual Methods
Instruction pointer (IP)	An instruction pointer (IP) points to the next CIL instruction to be executed by the CLI in the present method.	I	12.3.2	Method State
Interface contract	Interface contracts specify which other contracts the interface supports e.g., which interfaces, methods, properties and events shall be implemented.	I	8.6	Contracts
Interface type definition	An interface definition defines an interface type. An interface type is a named group of methods, locations, and other contracts that shall be implemented by any object type that supports the interface contract of the same name.	I	8.9.4	Interface Type Definition
Interface type inheritance	Interface types may inherit from multiple interface types; i.e., an interface contract may list other interface contracts that shall also be supported.	I	8.9.8.3	Interface Type Inheritance
Interface types	Interface types describe a subset of the operations and none of the representation, and hence, cannot be an exact type of any value.	I	8.2.3	Classes, Interfaces, and Objects
Interfaces	Interfaces . . . define a contract that other types may implement.	II	11	Semantics of Interfaces
Kernel Profile	This profile is the minimal possible conforming implementation of the CLI.	IV	3.1	The Kernel Profile
Labels	Provided as a programming convenience; they represent a number that is encoded in the metadata. The value represented by a label is typically an offset in bytes from the beginning of the current method, although the precise encoding differs depending on where in the logical metadata structure or CIL stream the label occurs.	II	5.4	Labels and Lists of Labels
Libraries	To a programmer a Library is a self-consistent set of types (classes, interfaces, and value types) that provide a useful set of functionality.	IV	2.1	Libraries
Local memory pool	The local memory pool is used to allocate objects whose type or size is not known at compile time and which the programmer does not wish to allocate in the managed heap.	I	12.3.2.4	Local Memory Pool
Local signatures	A local signature specifies the contract on a local variable allocated during the running of a method.	I	8.6.1.3	Local Signatures
Location signatures	All locations are typed. This means that all locations have a location signature, which defines constraints on the location, its usage, and on the usage of the values stored in the location.	I	8.6.1.2	Location Signatures
Locations	Values are stored in locations. A location can hold a single value at a time. All locations are typed. The type of the location embodies the requirements that shall be met by values that are stored in the location.	I	8.3	Locations
Machine state	One of the design goals of the CLI is to hide the details of a method call frame from the CIL code generator. The machine state definitions . . . reflect these design choices, where machine state consists primarily of global state and method state.	I	12.3	Machine State
Managed code	Managed code is simply code that provides enough information to allow the CLI to provide a set of core services, including Given an address inside the code for a method, locate the metadata describing the method Walk the stack Handle exceptions Store and retrieve security information	I	6.2.1	Managed Code
Managed data	Managed data is data that is allocated and released automatically by the CLI, through a process called garbage collection. Only managed code can access managed data, but programs that are written in managed code can access both managed and unmanaged data.	I	6.2.2	Managed Data
Managed pointer types	[The O and &] data types represent an object reference that is managed by the CLI.	I	12.1.1.2	Managed Pointer Types: O and &
Managed pointers	Managed pointers (&) may point to a field of an object, a field of a value type, an element of an array, or the address where an element just past the end of an array would be stored (for pointer indexes into managed arrays).	II	13.4.2	Managed Pointers
Manifest	An assembly is a set of one or more files deployed as a unit. Every assembly has a manifest that declares what files make up the assembly, what types are exported, and what other assemblies are required to resolve type references within the assembly.	II	6	Assemblies, Manifests, and Modules
Marshalling descriptors	A marshalling descriptor is like a signature it's a "blob" of binary data. It describes how a field or parameter (which, as usual, covers the method return, as parameter number 0) should be marshalled when calling to or from unmanaged coded via PInvoke dispatch or IJW ("It Just Works") thunking.	II	22.4	Marshalling Descriptors
Member	Fields, array elements, and methods are called members of the type. Properties and events are also members of the type.	I	8.4	Type Members
Member inheritance	Only object types may inherit implementations, hence only object types may inherit members.	I	8.10	Member Inheritance
Memory store	By "memory store" we mean the regular process memory that the CLI operates within. Conceptually, this store is simply an array of bytes.	I	12.6.1	The Memory Store
Metadata	The CLI uses metadata to describe and reference the types defined by the Common Type System. Metadata is stored ("persisted") in a way that is independent of any particular programming language. Thus, metadata provides a common interchange mechanism for use between tools that manipulate programs (compilers, debuggers, etc.) as well as between these tools and the Virtual Execution System.	I	9	Overview of the Common Language Infrastructure
Metadata token	This is a 4-byte value that specifies a row in a metadata table, or a starting byte offset in the Userstring heap.	III	1.9	Metadata Tokens
Method	A method describes an operation that may be performed on values of an exact type.	I	8.2.3	Classes, Interfaces, and Objects
Method contract	A method contract is specified with a method definition. A method contract is a named operation that specifies the contract between the implementation(s) of the method and the callers of the method.	I	8.6	Contracts
Method definitions	Method definitions are composed of a name, a method signature, and optionally an implementation of the method.	I	8.11.1	Method Definitions
Method inheritance	A derived object type inherits all of the instance and virtual methods of its base object type. It does not inherit constructors or static methods.	I	8.10.2	Method Inheritance
Method pointers	Variables of type method pointer shall store the address of the entry point to a method with compatible signature.	II	13.5	Method Pointers
Method signatures	Method signatures are composed of A calling convention, A list of zero or more parameter signatures, one for each parameter of the method, And a type signature for the result value if one is produced.	I	8.6.1.5	Method Signatures
Method state	Method state describes the environment within which a method executes. (In conventional compiler terminology, it corresponds to a superset of the information captured in the "invocation stack frame.")	I	12.3.2	Method State
methodInfo handle	This . . . holds the signature of the method, the types of its local variables, and data about its exception handlers.	I	12.3.2	Method State
Module	A single file containing executable content.	II	6	Assemblies, Manifests, and Modules
Name Mangling	The platform may use name-mangling rules that force the name as it appears to a managed program to differ from the name as seen in the native implementation (this is common, for example, when the native code is generated by a C++ compiler).	II	14.5.2	Platform Invoke
Native data types	Some implementations of the CLI will be hosted on top of existing operating systems or runtime platforms that specify data types required to perform certain functions. The metadata allows interaction with these native data types by specifying how the built-in and user-defined types of the CLI are to be marshalled to and from native data types.	II	7.4	Native Data Types
Native size types	The native-size, or generic, types (native int, native unsigned int, O, and &) are a mechanism in the CLI for deferring the choice of a value's size.	I	12.1.1	Native Size: native int, native unsigned int, O, and &
Nested type definitions	A nested type definition is identical to a top-level type definition, with one exception: a top-level type has a visibility attribute, while the visibility of a nested type is the same as the visibility of the enclosing type.	I	8.11.5	Nested Type Definitions
Nested types	A type (called a nested type) can be a member of an enclosing type.	I	8.5.3.4	Nested Types
Network Library	This Library is part of the Compact Profile. It provides simple networking services, including direct access to network ports as well as HTTP support.	IV	5.3	Network Library
OOP	[Object-Oriented Programming]
Object type	The object type describes the physical structure of the instance and the operations that are allowed on it.	I	8.9.6	Object Type Definitions
Object type inheritance	With the sole exception of System.Object, which does not inherit from any other object type, all object types shall either explicitly or implicitly declare support for (inherit from) exactly one other object type.	I	8.9.8.1	Object Type Inheritance
Objects	[Instances of a class.] Each object is self-typing; that is, its type is explicitly stored in its representation. It has an identity that distinguishes it from all other objects, and it has slots that store other entities (which may be either objects or values). While the contents of its slots may be changed, the identity of an object never changes.	I	8	Common Type System
Opaque classes	Some languages provide multi-byte data structures whose contents are manipulated directly by address arithmetic and indirection operations. To support this feature, the CLI allows value types to be created with a specified size but no information about their data members.	I	12.1.6.3	Opaque Classes
Overloading	Within a single scope, a given name may refer to any number of methods, provided they differ in any of the following: Number of parameters Type of each argument	I	10.2	Overloading
Overriding	Overriding deals with object layout and is applicable only to instance fields and virtual methods. The CTS provides two forms of member overriding, new slot and expect existing slot.	I	8.10.4	Hiding, Overriding, and Layout
Parameter	[Name used within the body of a method to refer to the corresponding argument of the method.]
Parameter passing	The CLI supports three kinds of parameter passing, all indicated in metadata as part of the signature of the method. Each parameter to a method has its own passing convention (e.g., the first parameter may be passed by value while all others are passed by ref).	I	12.4.1.5	Parameter Passing
Parameter signatures	Parameter signatures define constraints on how an individual value is passed as part of a method invocation.	I	8.6.1.4	Parameter Signatures
Pinned	While a method with a pinned local variable is executing, the VES shall not relocate the object to which the local refers.	II	7.1.2	Pinned
PInvoke	Methods defined in native code may be invoked using the platform invoke (also know as PInvoke or p/invoke) functionality of the CLI.	II	14.5.2	Platform Invoke
Pointer type	A pointer type is a compile-time description of a value whose representation is a machine address of a location.	I	8.2.1	Value Types and Reference Types
Pointers	Pointers may contain the address of a field (of an object or value type) or an element of an array.	II	13.4	Pointer Types
Private accessibility	Accessible only to referents in the implementation of the exact type that defines the member.	I	8.5.3.2	Accessibility of Members
Profiles	A Profile is simply a set of Libraries, grouped together to form a consistent whole that provides a fixed level of functionality.	IV	2.2	Profiles
Properties	Propert[ies] define named groups of accessor method definitions that implement the named event or property behavior.	I	8.11	Member Definitions
Property contract	A property contract is specified with a property definition. There is an extensible set of operations for handling a named value, which includes a standard pair for reading the value and changing the value [typically get and set]. A property contract specifies method contracts for the subset of these operations that shall be implemented by any type that supports the property contract.	I	8.6	Contracts
Property definitions	A property definition defines a named value and the methods that access the value. A property definition defines the accessing contracts on that value.	I	8.11.3	Property Definitions
Public accessibility	Accessible to all referents.	I	8.5.3.2	Accessibility of Members
Qualified name	Consider a compound type Point that has a field named x. The name "field x" by itself does not uniquely identify the named field, but the qualified name "field x in type Point" does.	I	8.5.2	Assemblies and Scoping
Rank	The rank of an array is the number of dimensions.	II	13.2	Arrays
Reference demand	Any attempt to resolve a reference to the marked item shall have specified security permission.	I	8.5.3.3	Security Permissions
Reference types	Reference Types describe values that are represented as the location of a sequence of bits. There are four kinds of Reference Types: Object types Interface types Pointer types Built-in types	I	8.2.1	Value Types and Reference Types
Reflection Library	This Library is part of the Compact Profile. It provides the ability to examine the structure of types, create instances of types, and invoke methods on types, all based on a description of the type.	IV	5.4	Reflection Library
Remoting boundary	A remoting boundary exists if it is not possible to share the identity of an object directly across the boundary. For example, if two objects exist on physically separate machines that do not share a common address space, then a remoting boundary will exist between them.	I	12.5	Proxies and Remoting
Return state handle	This handle is used to restore the method state on return from the current method.	I	12.3.2	Method State
Runtime Infrastructure Library	This Library is part of the Kernel Profile. It provides the services needed by a compiler to target the CLI and the facilities needed to dynamically load types from a stream in the file format.	IV	5.1	Runtime Infrastructure Library
Scopes	Names are collected into groupings called scopes.	I	8.5.2	Assemblies and Scoping
Sealed	Specifies that a type shall not have subclasses.	II	9.1.4	Inheritance Attributes
Sealed type	An object type declares it shall not be used as a base type (be inherited from) by declaring that it is a sealed type.	I	8.9.8.1	Object Type Inheritance
Security descriptor	This descriptor is not directly accessible to managed code but is used by the CLI security system to record security overrides (assert, permit-only, and deny).	I	12.3.2	Method State
Security permissions	Access to members is also controlled by security demands that may be attached to an assembly, type, method, property, or event.	I	8.5.3.3	Security Permissions
Serializable fields	A field that is marked serializable is to be serialized as part of the persistent state of a value of the type.	I	8.11.2	Field Definitions
Setter method	By convention, properties define . . . optionally a setter method (for modifying the current value of the property).	I	8.11.3	Property Definitions
Signatures	Signatures are the part of a contract that can be checked and automatically enforced. Signatures are formed by adding constraints to types and other signatures.	I	8.6.1	Signatures
Simple labels	A simple label is a special name that represents an address.	II	5.4	Labels and Lists of Labels
Special members	There are three special members, all methods, that can be defined as part of a type: instance constructors, instance finalizers, and type initializers.	II	9.5	Special Members
Special types	Special Types are those that are referenced from CIL, but for which no definition is supplied: the VES supplies the definitions automatically based on information available from the reference.	II	13	Semantics of Special Types
Standard profiles	There are two Standard Profiles. The smallest conforming implementation of the CLI is the Kernel Profile, while the Compact Profile contains additional features useful for applications targeting a more resource-rich set of devices.	IV	3	The Standard Profiles
Static fields	Types may declare locations that are associated with the type rather than any particular value of the type. Such locations are static fields of the type.	I	8.4.3	Static Fields and Static Methods
Static methods	Types may also declare methods that are associated with the type rather than with values of the type. Such methods are static methods of the type.	I	8.4.3	Static Fields and Static Methods
Super calls	In some cases, it may be desirable to reuse code defined in the base type. For example, an overriding virtual method may want to call its previous version. This kind of reuse is called a super call, since the overridden method of the base type is called.
This	When they are invoked, instance and virtual methods are passed the value on which this invocation is to operate (known as this or a this pointer).	I	8.4.2	Methods
Thunk	A (typically) small piece of code used to provide a transition between two pieces of code where special handling is required.
try block	In the CLI, a method may define a range of CIL instructions that are said to be protected. This is called the "try block."	II	18	Exception Handling
Type	Types describe values and specify a contract . . . that all values of that type shall support.	I	8	Common Type System
Type definers	Type definers construct a new type from existing types.	I	8.9	Type Definers
Type definition	The type definition: Defines a name for the type being defined i.e., the type name and specifies a scope in which that name will be found. Defines a member scope in which the names of the different kinds of members (fields, methods, events, and properties) are bound. The tuple of (member name, member kind, and member signature) is unique within a member scope of a type. Implicitly assigns the type to the assembly scope of the assembly that contains the type definition.	I	8.5.2	Assemblies and Scoping
Type inheritance	Inheritance of types is another way of saying that the derived type guarantees support for all of the type contracts of the base type. In addition, the derived type usually provides additional functionality or specialized behavior.	I	8.9.8	Type Inheritance
Type members	Object type definitions include member definitions for all of the members of the type. Briefly, members of a type include fields into which values are stored, methods that may be invoked, properties that are available, and events that may be raised.	I	8.9.6.3	Type Members
Type safety	An implementation that lives up to the enforceable part of the contract (the named signatures) is said to be typesafe.	I	8.8	Type Safety and Verification
Type signatures	Type signatures define the constraints on a value and its usage.	I	8.6.1.1	Type Signatures
Typed reference parameters	A runtime representation of the data type is passed along with the address of the data, and the type of the parameter is therefore one specially supplied for this purpose.	I	12.4.1.5	Parameter Passing
Types	Types describe values. All places where values are stored, passed, or operated upon have a type e.g., all variables, parameters, evaluation stack locations, and method results. The type defines the allowable values and the allowable operations supported by the values of the type. All operators and functions have expected types for each of the values accessed or used.	I	8.2	Values and Types
Unary operators	Unary operators take one argument, perform some operation on it, and return the result. They are represented as static methods on the class that defines the type of their one operand or their return type.	I	10.3.1	Unary Operators
Unbox	Unbox is a narrowing (runtime exception may be generated) operation that converts a System.Object (whose runtime type is a value type) to a value type instance.	I	12.1.6.2.5	Boxing and Unboxing
Unmanaged code	[Code that does not require the runtime for execution. This code may not use the Common Type System or other features of the runtime. Traditional native code (before the CLI) is considered unmanaged.]
Unmanaged pointer types	An unmanaged pointer type (also known simply as a "pointer type") is defined by specifying a location signature for the location the pointer references. Any signature of a pointer type includes this location signature.	I	8.9.2	Unmanaged Pointer Types
Validation	Validation refers to a set of tests that can be performed on any file to check that the file format, metadata, and CIL are self-consistent.	II	3	Validation and Verification
Value type inheritance	Value Types, in their unboxed form, do not inherit from any type.	I	8.9.8.2	Value Type Inheritance
Value types	In contrast to classes, value types (see Partition I) are not accessed by using a reference but are stored directly in the location of that type.	II	12	Semantics of Value Types
Values	The representation of a value (except for those of built-in types) can be subdivided into sub-values. These sub-values are either named, in which case they are called fields, or they are accessed by an indexing expression, in which case they are called array elements.	I	8.4.1	Fields, Array Elements, and Values
Vararg methods	vararg methods accept a variable number of arguments.	II	14.4.5	vararg Methods
Variable [-length] argument lists	The CLI works in conjunction with the class library to implement methods that accept argument lists of unknown length and type ("varargs methods").	I	12.3.2.3	Variable [-Length] Argument Lists
Vectors	Vectors are single-dimension arrays with a zero lower bound.	II	13.1	Vectors
Verifiability	Memory safety is a property that ensures programs running in the same address space are correctly isolated from one another . . . Thus, it is desirable to test whether programs are memory-safe prior to running them. Unfortunately, it is provably impossible to do this with 100% accuracy. Instead, the CLI can test a stronger restriction, called verifiability.	III	1.8	Verifiability
Verification	Verification refers to a check of both CIL and its related metadata to ensure that the CIL code sequences do not permit any access to memory outside the program's logical address space.	II	3	Validation and Verification
Version number	The version number of the assembly is specified as four 32-bit integers.	II	6.2.1.4	Version Numbers
Virtual call	A virtual method may be invoked by a special mechanism (a virtual call) that chooses the implementation based on the dynamically detected type of the instance used to make the virtual call rather than the type statically known at compile time.	I	8.4.4	Virtual Methods
Virtual calling convention	The CIL provides a "virtual calling convention" that is converted by an interpreter or JIT compiler into a native calling convention.	I	12.4.1.4	Virtual Calling Convention
Virtual Execution System	The Virtual Execution System (VES) provides an environment for executing managed code. It provides direct support for a set of built-in data types, defines a hypothetical machine with an associated machine model and state, a set of control flow constructs, and an exception handling model.	I	12	Virtual Execution System
Virtual methods	Virtual methods are associated with an instance of a type in much the same way as for instance methods. However, unlike instance methods, it is possible to call a virtual method in such a way that the implementation of the method shall be chosen at runtime by the VES depends upon the type of object used for the this pointer.	II	14.2	Static, Instance, and Virtual Methods
Visibility	Visibility is attached only to top-level types, and there are only two possibilities: visible to types within the same assembly, or visible to types regardless of assembly.	II	8.1	Visibility of Top-Level Types and Accessibility of Nested Types
Widen	If a type overrides an inherited method, it may widen, but it shall not narrow, the accessibility of that method.	II	9.3.3	Accessibility and Overriding
XML Library	This Library is part of the Compact Profile. It provides a simple "pull-style" parser for XML. It is designed for resource-constrained devices, yet provides a simple user model.	IV	5.5	XML Library

End informative text