M

MAGE (Manifest Generation and Editing) Tool, ClickOnce Deployment

main entry points, Main Entry Point

Managed Debugger, Debuggers (see )

managed heap, Main Entry Point, Types, Arrays and Collections, Memory Management, Memory Example, Memory Example, Memory Management, Garbage Collection Overview, Unsafe Code

generations, Memory Example, Garbage Collection Overview

memory for arrays, Arrays and Collections

memory management, Memory Management

overview, Memory Management

reference types, Main Entry Point, Types

unsafe code, Unsafe Code

manifest, Metadata and Reflection, MSIL in Depth

Manifest Generation and Editing (MAGE) Tool, ClickOnce Deployment

MarshalAsAttribute type, Attributes, The stackalloc Command, Unmanaged Callbacks

marshaling, Unsafe Code, Unsafe Code, The stackalloc Command, Unmanaged Callbacks

defined, Unsafe Code

explicit, Unmanaged Callbacks

Interop marshaler, The stackalloc Command

mathematical and logical operators, Operator Overloading, Mathematical and Logical Operators, Mathematical and Logical Operators, Implementation, Increment and Decrement Operators, Operator True and Operator False, Operator True and Operator False, A Practical Example

implementing, Mathematical and Logical Operators

Increment/Decrement operators, Implementation

LeftShift/RightShift operators, Increment and Decrement Operators

overloading considerations, Operator Overloading

paired operators, Operator True and Operator False

replacement methods, A Practical Example

true/false logical operators, Operator True and Operator False

MDbg (Managed Debugger), Advanced Debugging, DebuggableAttribute Attribute, Debuggers, Debuggers, Debuggers, Managed Debugger (MDbg), MDbg Example

commands supported, Debuggers, MDbg Example

debugging example, Managed Debugger (MDbg)

downloading, DebuggableAttribute Attribute

functionality, Advanced Debugging, Debuggers

member operator (.), Classes

MemberInfo object, Loading Assemblies

members, Classes (see )

MemberTypes enumeration, Browsing Type Information

memory dumps, DebuggerTypeProxyAttribute (see )

memory management, Arrays and Collections, Arrays and Collections, Short Form, Advanced Debugging, Debuggers, Stack Trace Commands, Display Memory Commands, Memory Management, Object graph, Memory Example, Generations Example, Finalization, Symsrv Symbol Server, Memory Management, Memory Management, Memory Management, Server GC, The Console class and finalization, Weak Reference, Reliable Code, Managing Unmanaged Resources, The GC Class

array elements, Arrays and Collections

finalization process, Generations Example, Server GC

garbage collection, The GC Class

generations, Memory Example

IDisposable.Dispose method, The Console class and finalization

memory leaks, Memory Management, Reliable Code

MSIL load/store commands, Short Form

object graphs, Object graph

overview, Memory Management, Symsrv Symbol Server, Memory Management

Reliability and Performance Monitor, Advanced Debugging, Debuggers, Finalization

unmanaged resources, Memory Management, Managing Unmanaged Resources

weak references, Weak Reference

WinDbg breakpoint memory commands, Display Memory Commands

WinDbg display memory commands, Stack Trace Commands

metadata, The Exceptions Dialog Box, Metadata and Reflection, Metadata and Reflection, Metadata and Reflection, Metadata and Reflection, Metadata Validation, Metadata Validation, Attributes, MSIL in Depth

(see also )

attributes, Attributes

defined, The Exceptions Dialog Box, Metadata and Reflection

ILDASM support, Metadata Validation

manifests, Metadata and Reflection

MSIL directives, MSIL in Depth

overview, Metadata and Reflection

validating, Metadata Validation

metadata heaps, Metadata Heaps

metadata streams, Metadata Heaps

metadata tables, Metadata, Metadata, Metadata Heaps, Metadata Heaps, Metadata Heaps

metadata heaps, Metadata Heaps

metadata streams, Metadata Heaps

metadata tokens, Metadata

table identifiers, Metadata

metadata tokens, Metadata

method descriptors, Process Execution

method directives, .property (see )

MethodDef table, Metadata

MethodInfo object, Dynamic Invocation, Type Creation, Type Creation, Reflection and Generics, Reflection and Generics, GetGenericTypeDefinition, GetGenericTypeDefinition, GetGenericTypeDefinition, Creating Generic Types

GetGenericArguments method, GetGenericTypeDefinition

GetGenericMethodDefinition method, GetGenericTypeDefinition

Invoke method, Dynamic Invocation, Type Creation

IsGenericMethod property, Reflection and Generics

IsGenericTypeDefinition property, Reflection and Generics

late binding delegates, Type Creation

MakeGenericMethod method, Creating Generic Types

methods, Class Members, Fields, Fields, Visibility, Visibility, Visibility, Partial Type, Cross-Language Inheritance, Overriding Inherited Behavior, Overriding Events, Abstract Classes, Abstract Classes, System.Array, Collections, Hashtable Collection, Queue Collection, SortedList, Stack Collection, Type Arguments, Generic Methods, Generic Methods, Constraints, Yield Statement, Iterator Internals, Anonymous Methods, System.Exception Functions, Browsing Type Information, Browsing Type Information, Dynamic Invocation, Late Binding Delegates, Branching, Tracing, DebuggerDisplayAttribute

abstract, Abstract Classes

anonymous, Anonymous Methods

ArrayList collection class, Collections

as class members, Class Members

as member functions, Fields

attributes and, Visibility

Binder class, Dynamic Invocation

calling, Branching

closed, Generic Methods

DebuggerDisplayAttribute limitations, DebuggerDisplayAttribute

defined, Fields

extension, Overriding Events

generic, Constraints (see )

Hashtable collection class, Hashtable Collection

invoking dynamically, Browsing Type Information, Late Binding Delegates

iterator, Yield Statement, Iterator Internals

open, Generic Methods

overloaded, Type Arguments

overview, Visibility

partial, Partial Type

Queue collection class, Queue Collection

return types, Visibility

SortedList collection class, SortedList

Stack collection class, Stack Collection

System.Array, System.Array

System.Exception class, System.Exception Functions

System.Object, Cross-Language Inheritance

TraceSource class, Tracing

Type object, Browsing Type Information

virtual keyword, Overriding Inherited Behavior

MFC (Microsoft Foundation Classes), An Exception Example

Microsoft Build Engine, MSBuild Example (see )

Microsoft FCL, Application Exceptions (see )

Microsoft Foundation Classes (MFC), An Exception Example

Microsoft Intermediate Language, tail (see )

Microsoft Office project templates, Migrating to Visual Studio 2008

Microsoft Public Symbol Store, Exception Example, Symsrv Symbol Server

Microsoft Visual Studio, Project Types (see )

Microsoft Visual Studio Debugger, Attaching to a Running Process (see )

Microsoft Windows Forms, Migrating to Visual Studio 2008, Project Types, Generics and Delegates, Generics and Delegates, Unhandled Exceptions, GetGenericTypeDefinition

asynchronous invocation, Generics and Delegates

debugging, GetGenericTypeDefinition

templates, Migrating to Visual Studio 2008, Project Types

trapping unhandled exceptions, Unhandled Exceptions

minidumps, Dumps

minus operator, Removing delegates

modifiers, Classes, Member Attributes

module version identifiers (MVIDs), Metadata Heaps

Month enumeration, Enumeration

MSBuild (Microsoft Build Engine), Refactoring Example, Refactoring Example, Items, Items, Project File, Project File, MSBuild Example, MSBuild Example

code example, MSBuild Example

command-line switches, Project File

default tasks, Items

items, Refactoring Example

overview, Refactoring Example

project files, Project File

properties, Items

mscorlib.dll library, .assembly extern

MSIL (Microsoft Intermediate Language), Cross-Language Inheritance, Arrays and Collections, Generics Internals, Iterator Blocks, A Practical Example, Metadata Validation, MSIL, MSIL Programming, MSIL Programming, MSIL Programming, MSIL Programming, "Hello World" Application, MSIL in Depth, MSIL in Depth, MSIL Instructions, Short Form, Complex Tasks, Managing Types, Inheritance, Interfaces, Interfaces, Branching, Branching, tail, tail, Arithmetic Instructions, Conversion Operations, Miscellaneous Operations, Process Execution

arrays, tail

boxing, Managing Types

branching, Branching

calling methods, Branching

case sensitivity, MSIL in Depth

conversion operations, Arithmetic Instructions

cross-language inheritance, Cross-Language Inheritance

evaluation stack, "Hello World" Application, Short Form

exception handling, Conversion Operations

generic internals, Generics Internals

Hello World application, MSIL Programming

inheritance, Inheritance

interfaces, Interfaces

iterator internals, Iterator Blocks

managing types, Complex Tasks

metadata validation, Metadata Validation

OOP support, MSIL Programming

operator methods, A Practical Example

overview, MSIL, MSIL Programming, MSIL in Depth

process execution, Miscellaneous Operations

roundtripping, MSIL Programming, Process Execution

short-form syntax, MSIL Instructions

single-dimensional arrays, Arrays and Collections

structures, Interfaces

MSIL directives, "Hello World" Application, "Hello World" Application, "Hello World" Application, MSIL in Depth, Assembly Directives, Assembly Directives, Assembly Directives, Assembly Directives, Assembly Directives, Assembly Directives, .assembly extern, .assembly extern, .assembly extern, .assembly extern, .stackreserve, .stackreserve, .class header {members}, .class header {members}, .class header {members}, .class header {members}, .property, .property, .property, .property, .property, .property, .property, .event, .event, .maxstack, Complex Tasks, Complex Tasks, Interfaces, Interfaces

.addon directive, .property

.assembly directive, Assembly Directives

.assembly extern directive, Assembly Directives

.class directive, .stackreserve, Interfaces

.corflags directive, .assembly extern

.ctor directive, Complex Tasks

.custom directive, Assembly Directives, .class header {members}

.entrypoint directive, "Hello World" Application, .maxstack

.event directive, .property

.field directive, .class header {members}, Complex Tasks

.file directive, .assembly extern

.get directive, .property

.imagebase directive, .stackreserve

.locale directive, Assembly Directives

.locals directive, "Hello World" Application, .event, Interfaces

.maxstack directive, "Hello World" Application, .event

.method directive, .class header {members}

overview, MSIL in Depth

.property directive, .class header {members}, .property

.publickey directive, Assembly Directives

.removeon directive, .property

.set directive, .property

.stackreserve directive, .assembly extern

.subsystem directive, .assembly extern

.ver directive, Assembly Directives

MSIL instructions, "Hello World" Application, "Hello World" Application, "Hello World" Application, "Hello World" Application, "Hello World" Application, "Hello World" Application, "Hello World" Application, MSIL Instructions, MSIL Instructions, MSIL Instructions, Short Form, Short Form, Load and Store Methods, Load and Store Methods, Load and Store Methods, Load and Store Methods, Load and Store Methods, Complex Tasks, Complex Tasks, Complex Tasks, Complex Tasks, Complex Tasks, Complex Tasks, Complex Tasks, Managing Types, Managing Types, Managing Types, Inheritance, Interfaces, Interfaces, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Branching, Calling Methods, Calling Methods, Calling Methods, Calling Methods, jmp, tail, tail, tail, tail, tail, Arithmetic Instructions, Arithmetic Instructions, Arithmetic Instructions, Arithmetic Instructions, Arithmetic Instructions, Arithmetic Instructions, Arithmetic Instructions, Arithmetic Instructions, Arithmetic Instructions, Conversion Operations, Miscellaneous Operations, Miscellaneous Operations, Miscellaneous Operations, Miscellaneous Operations, Miscellaneous Operations, Miscellaneous Operations, Miscellaneous Operations, Miscellaneous Operations, Roundtripping, Roundtripping

add instruction, Arithmetic Instructions, Roundtripping

and instruction, Miscellaneous Operations

beq instruction, Branching

bge instruction, Branching

bgt instruction, Branching

bgt.un instruction, Branching

ble instruction, Branching

blt instruction, Branching

blt.un instruction, Branching

bne instruction, Branching

bne.un instruction, Branching

box instruction, Complex Tasks, Managing Types

br instruction, MSIL Instructions, Branching

break instruction, Miscellaneous Operations

brfalse instruction, Branching

brtrue instruction, Branching

call instruction, "Hello World" Application, Interfaces, Calling Methods

calli instruction, Calling Methods

callvirt instruction, Inheritance, Calling Methods

castclass instruction, Miscellaneous Operations

ceq instruction, Branching

cgt instruction, Branching

cgt.un instruction, Branching

clt instruction, Branching

clt.un instruction, Branching

complex tasks, Complex Tasks

conv instruction, Arithmetic Instructions

conv.ovf instruction, Arithmetic Instructions, Roundtripping

div instruction, Arithmetic Instructions

dup instruction, Complex Tasks, tail

jmp instruction, "Hello World" Application, jmp

ldarg instruction, Load and Store Methods, Managing Types

ldc instruction, Short Form

ldelem instruction, tail

ldftn instruction, Calling Methods

ldloc instruction, "Hello World" Application, MSIL Instructions, Load and Store Methods

ldloca instruction, Interfaces

ldnull instruction, Load and Store Methods

ldsfld instruction, Complex Tasks

ldstr instruction, "Hello World" Application

leave instruction, Conversion Operations

mul instruction, Arithmetic Instructions

neg instruction, Arithmetic Instructions

newarr instruction, tail

newobj instruction, Complex Tasks, Branching

nop instruction, Miscellaneous Operations

or instruction, Miscellaneous Operations

overview, MSIL Instructions

pop instruction, Short Form, Miscellaneous Operations

rem instruction, Arithmetic Instructions

ret instruction, "Hello World" Application

rethrow instruction, Miscellaneous Operations

starg instruction, Load and Store Methods

stelem instruction, tail

stfld instruction, Complex Tasks

stloc instruction, "Hello World" Application, Load and Store Methods

stsfld instruction, Complex Tasks

sub instruction, Arithmetic Instructions

tail instruction, "Hello World" Application, tail

throw instruction, Miscellaneous Operations

unbox instruction, Managing Types

Mueller, John Paul, Unsafe Code

multicast delegates, System.MulticastDelegate Class, Removing delegates, Methods and properties, Methods and properties, Type Creation

generics and, Methods and properties

invocation lists, Removing delegates

late binding, Type Creation

overview, System.MulticastDelegate Class

MulticastDelegate class, Delegates and Events, Contravariance and Covariance, System.MulticastDelegate Class, System.MulticastDelegate Class, System.MulticastDelegate Class, Removing delegates, Removing delegates, Methods and properties, Methods and properties, Methods and properties, Methods and properties, Methods and properties, Methods and properties, Methods and properties, Methods and properties, Methods and properties, Methods and properties, Asynchronous Delegate Diagram, Asynchronous Delegate Diagram, Asynchronous Delegate Diagram

arrays of delegates, System.MulticastDelegate Class

as reference type, Delegates and Events

BeginInvoke method, Methods and properties, Asynchronous Delegate Diagram

Combine method, System.MulticastDelegate Class, Methods and properties

CreateDelegate method, Methods and properties

DynamicInvoke method, Methods and properties

EndInvoke method, Methods and properties, Asynchronous Delegate Diagram

GetInvocationList method, Removing delegates

Invoke method, Contravariance and Covariance, Methods and properties, Asynchronous Delegate Diagram

Method property, Methods and properties

Remove method, Removing delegates, Methods and properties

RemoveAll method, Methods and properties

Target property, Methods and properties

multidimensional arrays, Arrays and Collections, Multidimensional Arrays, Multidimensional Arrays, Multidimensional Arrays, Multidimensional Arrays, Multidimensional Arrays

array elements, Multidimensional Arrays

code example, Multidimensional Arrays

defined, Arrays and Collections, Multidimensional Arrays

syntax, Multidimensional Arrays

multi-line comments, Delimited comments: /* and */, Single-line documentation comments: ///, MSIL in Depth

multiple-targeting feature, Multiple-Targeting

MVIDs (module version identifiers), Metadata Heaps