M

Machine.config file, Simple Administrative Control (Configuration)

Main method, A Brief Look at Metadata, Volatile Constructs

maintaining state, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State

MakeByRefType method, Invoking a Type’s Members

MakeGenericType method, Constructing an Instance of a Type

managed applications, prioritization of, Thread Scheduling and Priorities

managed code, Compiling Source Code into Managed Modules, Executing Your Assembly’s Code, IL and Verification, Trading Reliability for Productivity, Managing the CLR by Using Managed Code, Defining WinRT Components in C#

AppDomains and, Managing the CLR by Using Managed Code

C++ compiler and, Compiling Source Code into Managed Modules

performance of, vs. unmanaged, Executing Your Assembly’s Code

reducing processes with, IL and Verification

state corruption and, Trading Reliability for Productivity

WinRT components as, Defining WinRT Components in C#

Managed Debugging Assistants (MDAs), An Interesting Dependency Issue

Managed Extensibility Framework (MEF), Designing an Application That Supports Add-Ins

managed heap, Arrays, Allocating Resources from the Managed Heap, Allocating Resources from the Managed Heap, The Garbage Collection Algorithm

allocating resources from, Allocating Resources from the Managed Heap

arrays in, Arrays

example of, Allocating Resources from the Managed Heap

garbage collection and, The Garbage Collection Algorithm

managed modules, Compiling Source Code into Managed Modules, Compiling Source Code into Managed Modules, Combining Managed Modules into Assemblies

combining into assemblies, Combining Managed Modules into Assemblies

metadata in, Compiling Source Code into Managed Modules

manifest tables, Combining Modules to Form an Assembly, Combining Modules to Form an Assembly

ManifestResourceDef table, Combining Modules to Form an Assembly

manual-reset events, Event Constructs

ManualResetEventSlim class, The ManualResetEventSlim and SemaphoreSlim Classes, The CountdownEvent Class

marking objects in garbage collection, The Garbage Collection Algorithm

Marshal class, Secure Strings

MarshalByRefObject class, Demo #1: Cross-AppDomain Communication Using Marshal-by-Reference, Demo #1: Cross-AppDomain Communication Using Marshal-by-Reference, Designing an Application That Supports Add-Ins, The Monitor Class and Sync Blocks

MarshalByValType type, Demo #2: Cross-AppDomain Communication Using Marshal-by-Value

Match method, Matching Two Attribute Instances Against Each Other

Math class, Class Libraries and Thread Safety

Max method, Class Libraries and Thread Safety

Maximum method, The Interlocked Anything Pattern

MaxValue field, Characters

MBCS (Multi-Byte Character Set), converting Unicode to, Encodings: Converting Between Characters and Bytes

MEF (Managed Extensibility Framework), Designing an Application That Supports Add-Ins

member accessibility, Member Accessibility, Using Type Visibility and Member Accessibility Intelligently

MemberInfo, Designing an Application That Supports Add-Ins, Discovering a Type’s Members

class, Discovering a Type’s Members

type, Designing an Application That Supports Add-Ins

MemberRef table, A Brief Look at Metadata

MemberwiseClone method, All Types Are Derived from System.Object, Instance Constructors and Classes (Reference Types)

System.Object, All Types Are Derived from System.Object

memcpy function, Casting Arrays

memory, Managed Heap Basics, Managed Heap Basics, Allocating Resources from the Managed Heap, Allocating Resources from the Managed Heap, The Garbage Collection Algorithm, Generations: Improving Performance, Generations: Improving Performance, Monitoring Your Application’s Memory Usage, Other GC Features for Use with Native Resources

allocating, Allocating Resources from the Managed Heap, Allocating Resources from the Managed Heap, Generations: Improving Performance

compacting, in garbage collection, The Garbage Collection Algorithm

corruption, Managed Heap Basics

leaks, Managed Heap Basics

monitoring, Monitoring Your Application’s Memory Usage

pressure methods, Other GC Features for Use with Native Resources

reclaiming, with garbage collection, Generations: Improving Performance

MemoryStream, Serialization/Deserialization Quick Start, Passing Blocks of Data Between the CLR and WinRT

class, Passing Blocks of Data Between the CLR and WinRT

object, Serialization/Deserialization Quick Start

merging LINQ query results, Parallel Language Integrated Query

metadata, Compiling Source Code into Managed Modules, Compiling Source Code into Managed Modules, A Brief Look at Metadata, Combining Modules to Form an Assembly, The Different Kinds of Type Members, Constants and Fields, Conversion Operator Methods, Parameterless Properties, Assembly Loading, Invoking a Type’s Members, Invoking a Type’s Members, Interoperating with WinRT Components, Defining WinRT Components in C#

assembly, Assembly Loading

constants and, Constants and Fields

for conversion operator methods, Conversion Operator Methods

for events, Invoking a Type’s Members

identical format of, The Different Kinds of Type Members

in human-readable form, A Brief Look at Metadata

on properties, Invoking a Type’s Members

property definitions in, Parameterless Properties

tokens, Combining Modules to Form an Assembly

uses for, Compiling Source Code into Managed Modules

WinRT, Interoperating with WinRT Components, Defining WinRT Components in C#

method parameters, passing, Passing Parameters by Reference to a Method

MethodDef table, A Brief Look at Metadata

MethodInfo, Delegates and Reflection, Using Binding Handles to Reduce Your Process’s Memory Consumption

method, Delegates and Reflection

objects, converting to RuntimeMethodHandle, Using Binding Handles to Reduce Your Process’s Memory Consumption

methods, Executing Your Assembly’s Code, The Common Type System, How Things Relate at Run Time, How Things Relate at Run Time, How Things Relate at Run Time, Boxing and Unboxing Value Types, Components, Polymorphism, and Versioning, How the CLR Calls Virtual Methods, Properties, and Events, How the CLR Calls Virtual Methods, Properties, and Events, How the CLR Calls Virtual Methods, Properties, and Events, How the CLR Calls Virtual Methods, Properties, and Events, Using Type Visibility and Member Accessibility Intelligently, Dealing with Virtual Methods When Versioning Types, Dealing with Virtual Methods When Versioning Types, Dealing with Virtual Methods When Versioning Types, Methods, Type Constructors, Operator Overload Methods, Conversion Operator Methods, Extension Methods, Implicitly Typed Local Variables, Passing a Variable Number of Arguments to a Method, Parameter and Return Type Guidelines, Parameterless Properties, Parameterless Properties, Anonymous Types, The System.Tuple Type, Parameterful Properties, Events, Step #3: Define a method responsible for raising the event to notify registered objects that the event has occurred, Step #3: Define a method responsible for raising the event to notify registered objects that the event has occurred, Step #4: Define a method that translates the input into the desired event, Generics, Generics in the Framework Class Library, Code Explosion, Delegate and Interface Contra-variant and Covariant Generic Type Arguments, Generic Methods, Generic Methods and Type Inference, Generic Methods and Type Inference, Generic Methods and Type Inference, Verifiability and Constraints, Verifiability and Constraints, Inheriting an Interface, Implicit and Explicit Interface Method Implementations (What’s Happening Behind the Scenes), Encodings: Converting Between Characters and Bytes, Bit Flags, Using Delegates to Call Back Static Methods, Hiding an Implementation Detail to Maintain a “Contract”, Constrained Execution Regions (CERs), Constrained Execution Regions (CERs), WinRT Type System Core Concepts, Calling Asynchronous WinRT APIs from .NET Code, C#’s Asynchronous Functions, Class Libraries and Thread Safety

accessor, Parameterless Properties, Parameterless Properties, Parameterful Properties

anonymous types and, Anonymous Types

callback, Events

calling, How Things Relate at Run Time, How the CLR Calls Virtual Methods, Properties, and Events

calling for the second time, Executing Your Assembly’s Code

compiling once only, Code Explosion

contract, maintaining when exception thrown, Hiding an Implementation Detail to Maintain a “Contract”

conversion operator, Conversion Operator Methods

declaring return types, Parameter and Return Type Guidelines

defined, The Common Type System

extension, Extension Methods, Step #3: Define a method responsible for raising the event to notify registered objects that the event has occurred

for encoding classes, Encodings: Converting Between Characters and Bytes

for enumerated types, Bit Flags

generic, Generics, Generics in the Framework Class Library, Delegate and Interface Contra-variant and Covariant Generic Type Arguments, Generic Methods and Type Inference, Verifiability and Constraints

generic and non-generic, Generic Methods and Type Inference

instance constructors, Methods

interface, calling, Implicit and Explicit Interface Method Implementations (What’s Happening Behind the Scenes)

invoking after removal from delegate chain, Step #3: Define a method responsible for raising the event to notify registered objects that the event has occurred

marking as async, C#’s Asynchronous Functions

nonvirtual vs. virtual, How the CLR Calls Virtual Methods, Properties, and Events

operator overload, Operator Overload Methods

overloading, arity-based, Verifiability and Constraints

overrides, Dealing with Virtual Methods When Versioning Types

parameter types, Implicitly Typed Local Variables

passing variable number of arguments to, Passing a Variable Number of Arguments to a Method

performance issues, Using Type Visibility and Member Accessibility Intelligently

polymorphic, How the CLR Calls Virtual Methods, Properties, and Events

public, Inheriting an Interface

reliability contract documentation, Constrained Execution Regions (CERs)

reliable, Constrained Execution Regions (CERs)

return types, Using Delegates to Call Back Static Methods

splitting specific and generic, Generic Methods and Type Inference

static, How Things Relate at Run Time

thread-safe, Class Libraries and Thread Safety

translating input into events, Step #4: Define a method that translates the input into the desired event

tuple types and, The System.Tuple Type

type constructors, Type Constructors

type parameters, defining, Generic Methods

virtual, Boxing and Unboxing Value Types, How the CLR Calls Virtual Methods, Properties, and Events, Dealing with Virtual Methods When Versioning Types

virtual instance, How Things Relate at Run Time

virtual, changing to override, Dealing with Virtual Methods When Versioning Types

WinRT, WinRT Type System Core Concepts, Calling Asynchronous WinRT APIs from .NET Code

MethodWithReturn method, Demo #2: Cross-AppDomain Communication Using Marshal-by-Value

Microsoft Silverlight applications, AppDomains and, Microsoft Silverlight Rich Internet Applications

Microsoft Spy++, Thread Scheduling and Priorities

Microsoft SQL Server, AppDomains and, Microsoft SQL Server

Microsoft Visual Studio, Checked setting, Checked and Unchecked Primitive Type Operations

Microsoft Windows NT kernel, Why Does Windows Support Threads?

MinValue field, Characters

ModuleDef table, A Brief Look at Metadata, How the Runtime Resolves Type References

ModuleRef table, A Brief Look at Metadata, How the Runtime Resolves Type References

modules, Building Types into a Module, Combining Modules to Form an Assembly, Friend Assemblies

building types into, Building Types into a Module

combining into assemblies, Combining Modules to Form an Assembly

in friend assemblies, Friend Assemblies

Monitor class, Trading Reliability for Productivity, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks

as static class, avoiding, The Monitor Class and Sync Blocks

commonly used methods, The Monitor Class and Sync Blocks

example code, The Monitor Class and Sync Blocks

passing reference to type object into, The Monitor Class and Sync Blocks

problems with, The Monitor Class and Sync Blocks

monitoring, Monitoring and Controlling the Lifetime of Objects Manually, AppDomain Monitoring

AppDomains, AppDomain Monitoring

object lifetimes, Monitoring and Controlling the Lifetime of Objects Manually

MPGO.exe, The Native Code Generator Tool: NGen.exe

MSCorEE.dll file, CLR Hosting

MSCorLib.dll, Building Types into a Module, AppDomains

MSCorWks.dll, CLR Hosting

MSIExec.exe, Simple Application Deployment (Privately Deployed Assemblies)

multi-dimensional arrays, Array Internals, Array Internals

MulticastDelegate class, Demystifying Delegates, Demystifying Delegates

non-public fields, Demystifying Delegates

multifile assemblies, Combining Modules to Form an Assembly, Combining Modules to Form an Assembly

multiple cores, CPU Trends, Reasons to Use Threads, Reasons to Use Threads, Reasons to Use Threads, Reasons to Use Threads, Thread Scheduling and Priorities

processing power of, Reasons to Use Threads

taking advantage of, Reasons to Use Threads

thread starvation on, Thread Scheduling and Priorities

UI element removal and, Reasons to Use Threads

user productivity and, Reasons to Use Threads

multiple inheritance, Interfaces

multithreaded operating system, Thread Scheduling and Priorities

MultiWebRequest class, Interlocked Constructs

Mutex, Working with Types Requiring Special Cleanup, Kernel-Mode Constructs, Semaphore Constructs, Spinning, Thread Ownership, and Recursion

class, Kernel-Mode Constructs, Semaphore Constructs

lock, Spinning, Thread Ownership, and Recursion

type, Working with Types Requiring Special Cleanup

mutexes, Mutex Constructs