C

C++ compiler, managed/unmanaged code and, Compiling Source Code into Managed Modules

caching, Monitoring and Controlling the Lifetime of Objects Manually, Thread Overhead

threads, Thread Overhead

weak references and, Monitoring and Controlling the Lifetime of Objects Manually

callback functions, Delegates, A First Look at Delegates

unmanaged, A First Look at Delegates

callback methods, Events, Enough with the Delegate Definitions Already (Generic Delegates), C#’s Syntactical Sugar for Delegates, Syntactical Shortcut #2: No Need to Define a Callback Method (Lambda Expressions), Syntactical Shortcut #3: No Need to Wrap Local Variables in a Class Manually to Pass Them to a Callback Method, Assembly Loading, Assembly Loading, Cooperative Cancellation and Timeout, Cooperative Cancellation and Timeout

assembly loading and, Assembly Loading, Assembly Loading

exceptions thrown by, Cooperative Cancellation and Timeout

lambda expressions, Syntactical Shortcut #2: No Need to Define a Callback Method (Lambda Expressions)

referencing local parameters, Syntactical Shortcut #3: No Need to Wrap Local Variables in a Class Manually to Pass Them to a Callback Method

registering after cancellation, Cooperative Cancellation and Timeout

returning values with, Enough with the Delegate Definitions Already (Generic Delegates)

syntax for, C#’s Syntactical Sugar for Delegates

calling back static methods, Using Delegates to Call Back Static Methods

calling methods, How the CLR Calls Virtual Methods, Properties, and Events, Demo #1: Cross-AppDomain Communication Using Marshal-by-Reference

across AppDomain boundaries, Demo #1: Cross-AppDomain Communication Using Marshal-by-Reference

calling type constructors, Type Constructors

callvirt instruction, How the CLR Calls Virtual Methods, Properties, and Events

CAN-DO relationships, Design: Base Class or Interface?

Cancel method, Class Libraries and Thread Safety

canceling operations, Cooperative Cancellation and Timeout, Cooperative Cancellation and Timeout, Cooperative Cancellation and Timeout

after set time, Cooperative Cancellation and Timeout

invoking methods after, Cooperative Cancellation and Timeout

canceling tasks, Canceling a Task

canceling WinRT APIs, Calling Asynchronous WinRT APIs from .NET Code

CancellationToken objects, Canceling a Task, Starting a New Task Automatically When Another Task Completes

associating with tasks, Starting a New Task Automatically When Another Task Completes

passing as closure variables, Canceling a Task

CancellationToken value type, Cooperative Cancellation and Timeout

CancellationTokenSource objects, Cooperative Cancellation and Timeout

CancellationTokenSource type, Canceling a Task

CannotUnloadAppDomainException, AppDomain Unloading

exception, AppDomain Unloading

carriage returns, Constructing Strings

casting arrays, Casting Arrays

casting types, Casting Between Types, Casting with the C# is and as Operators, Programming Language Primitive Types, Programming Language Primitive Types, The dynamic Primitive Type

between objects, Casting Between Types

dynamic, The dynamic Primitive Type

implicit vs. explicit, Programming Language Primitive Types

primitive, Programming Language Primitive Types

with is/as operators, Casting with the C# is and as Operators

casting, Char type to numeric value, Characters

catch blocks, The catch Block, The finally Block, The finally Block, The System.Exception Class, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State

exceptions thrown by, The finally Block

stack trace, obtaining, The System.Exception Class

catch types, The catch Block, The catch Block

variable names after, The catch Block

CCCheck.exe (Code Contract Checker), Code Contracts

CCDocGen.exe (Code Contract Document Generator), Code Contracts

CCRefGen.exe (Code Contract Reference Assembly Generator), Code Contracts

CCWs (COM Callable Wrappers), Interoperating with WinRT Components

CERs, Using Delegates to Call Back Many Methods (Chaining)

C# support for, Using Delegates to Call Back Many Methods (Chaining)

ChainSelector method, Surrogate Selector Chains

char type, Programming Language Primitive Types, Chars, Strings, and Working with Text, Characters, Characters, Characters, Characters

casting to numeric value, Characters

converting numeric types to, Characters

instance methods, Characters

static methods, Characters

character arrays, Constructing a StringBuilder Object, StringBuilder Members

methods for, StringBuilder Members

characters, Chars, Strings, and Working with Text, Characters, Examining a String’s Characters and Text Elements, Encodings: Converting Between Characters and Bytes

converting to bytes, Encodings: Converting Between Characters and Bytes

examining in strings, Examining a String’s Characters and Text Elements

numeric equivalent, returning, Characters

checked operators, Checked and Unchecked Primitive Type Operations

child tasks, A Task May Start Child Tasks

circuit boards, How Windows Performs I/O Operations

class constraint, Verifiability and Constraints

class libraries, thread synchronization and, Class Libraries and Thread Safety

class library developers, exception handling guidelines, Guidelines and Best Practices, Unhandled Exceptions

classes, Reference Types and Value Types, Boxing and Unboxing Value Types, Static Classes, Partial Classes, Structures, and Interfaces, Using Type Visibility and Member Accessibility Intelligently, Using Type Visibility and Member Accessibility Intelligently, Using Type Visibility and Member Accessibility Intelligently, Generic Type Identity, Class and Interface Inheritance, WinRT Type System Core Concepts

as reference types, Reference Types and Value Types

defining, Using Type Visibility and Member Accessibility Intelligently, Generic Type Identity

generic collection, Boxing and Unboxing Value Types

inheritance, Class and Interface Inheritance

partial, Partial Classes, Structures, and Interfaces

sealed, Using Type Visibility and Member Accessibility Intelligently

security, Using Type Visibility and Member Accessibility Intelligently

static, Static Classes

WinRT, WinRT Type System Core Concepts

cleanup code, Use finally Blocks Liberally, Using a Type That Wraps a Native Resource, Using a Type That Wraps a Native Resource, An Interesting Dependency Issue

Dispose method, Using a Type That Wraps a Native Resource, An Interesting Dependency Issue

for native resources, Using a Type That Wraps a Native Resource

Clear method, StringBuilder Members

CLI (Common Language Infrastructure), The Common Type System

Clone method, Other String Operations

cloneable variables, More About Calling Interface Methods

cloning strings, Other String Operations

Close method, WinRT Type System Core Concepts

closed types, Open and Closed Types

CloseHandle method, Kernel-Mode Constructs

CLR (Common Language Runtime), Compiling Source Code into Managed Modules, Loading the Common Language Runtime, The Common Type System, Interoperability with Unmanaged Code, How the Runtime Resolves Type References, Casting Between Types, Namespaces and Assemblies, The Different Kinds of Type Members, The CLR Has Special Support for Nullable Value Types, Garbage Collection Triggers, CLR Hosting, CLR Hosting, CLR Hosting, Passing Blocks of Data Between the CLR and WinRT, Defining WinRT Components in C#

code language vs. behavior, The Common Type System

code location for, CLR Hosting

common language aspect of, The Different Kinds of Type Members

compilers for, Compiling Source Code into Managed Modules

hosting, CLR Hosting

interoperability with unmanaged code, Interoperability with Unmanaged Code

loading, Loading the Common Language Runtime

namespaces and, Namespaces and Assemblies

nullable type support, The CLR Has Special Support for Nullable Value Types

passing blocks of data to WinRT, Passing Blocks of Data Between the CLR and WinRT

setting host managers, CLR Hosting

shutting down, as garbage collection trigger, Garbage Collection Triggers

type references, resolving, How the Runtime Resolves Type References

type safety, Casting Between Types

WinRT, mapping types to, Defining WinRT Components in C#

CLR projections, Interoperating with WinRT Components, Interoperating with WinRT Components

WinRT component type system rules and, Interoperating with WinRT Components

CLRCreateInstance function, CLR Hosting

CLRVer.exe, Loading the Common Language Runtime

CLS (Common Language Specification), The Common Language Specification, The Common Language Specification, The Common Language Specification

example code using, The Common Language Specification

rules overview, The Common Language Specification

Code Contract Checker (CCCheck.exe), Code Contracts

Code Contract Document Generator Tool (CCDocGen.exe), Code Contracts

Code Contract Reference Assembly Generator (CCRefGen.exe), Code Contracts

code contracts, Trading Reliability for Productivity, Code Contracts, Code Contracts, Code Contracts, Code Contracts, Code Contracts, Code Contracts

checking, Code Contracts

Contract class, Code Contracts

runtime function, Code Contracts

tools for maximizing, Code Contracts

violation of, Code Contracts

code explosion, Instance Constructors and Classes (Reference Types), Code Explosion

code optimization, Executing Your Assembly’s Code, Volatile Constructs, Volatile Constructs

Volatile class and, Volatile Constructs

code pages, specifying, Encodings: Converting Between Characters and Bytes

code, program order, Volatile Constructs

codeBase elements, Combining Modules to Form an Assembly, Advanced Administrative Control (Configuration)

Collect method, Garbage Collection Triggers, Garbage Collection Modes, Forcing Garbage Collections

collection classes, Boxing and Unboxing Value Types, Generics in the Framework Class Library, The Concurrent Collection Classes

generic, Boxing and Unboxing Value Types, Generics in the Framework Class Library

thread-safe, The Concurrent Collection Classes

collection initializers, Object and Collection Initializers

collection objects, serializing/deserializing, Controlling Serialization and Deserialization

collection types, WinRT, WinRT Type System Core Concepts

CollectionCount method, Monitoring Your Application’s Memory Usage

collections, Object and Collection Initializers, All Arrays Implicitly Implement IEnumerable, ICollection, and IList, WinRT Type System Core Concepts, The Concurrent Collection Classes, The Concurrent Collection Classes, The Concurrent Collection Classes

adding items to, Object and Collection Initializers

array implementation of, All Arrays Implicitly Implement IEnumerable, ICollection, and IList

maximum number in, The Concurrent Collection Classes

non-blocking, into blocking, The Concurrent Collection Classes

producer/consumer scenario, The Concurrent Collection Classes

WinRT, WinRT Type System Core Concepts

ColorMatrix class, Parameterful Properties

COM Callable Wrappers (CCWs), Interoperating with WinRT Components

COM components, WinRT components as, Interoperating with WinRT Components

Combine method, Using Delegates to Call Back Many Methods (Chaining)

command-line switches, response files, Building Types into a Module

compacting memory in garbage collection, The Garbage Collection Algorithm, Garbage Collection Modes

Compare method, comparing strings, Comparing Strings

CompareExchange method, Interlocked Constructs, The Interlocked Anything Pattern, The Famous Double-Check Locking Technique

CompareInfo, Comparing Strings, Comparing Strings, Comparing Strings, Comparing Strings

class, methods in, Comparing Strings

object, Comparing Strings, Comparing Strings

property, Comparing Strings

CompareOptions type, Comparing Strings

CompareTo method, Boxing and Unboxing Value Types, Be Careful with Explicit Interface Method Implementations, Characters

comparing strings, Comparing Strings

comparisonType argument, Comparing Strings

CompilationRelaxations attribute, String Interning

CompilerGenerated attribute, Syntactical Shortcut #2: No Need to Define a Callback Method (Lambda Expressions)

compilers, Trading Reliability for Productivity, Exception-Handling Performance Considerations, Volatile Constructs

code optimization by, Volatile Constructs

functions performed by, Trading Reliability for Productivity

managed, exception handling by, Exception-Handling Performance Considerations

compiling source code, The CLR’s Execution Model

CompleteAdding method, The Concurrent Collection Classes

Component Software Processing (CSP), Components, Polymorphism, and Versioning

components, Components, Polymorphism, and Versioning

servicing, Components, Polymorphism, and Versioning

composability of object-oriented programming, Trading Reliability for Productivity

compressing, assemblies, The Global Assembly Cache

compute-bound asynchronous operations, with threads, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation

compute-bound operations, Compute-Bound Asynchronous Operations, Cooperative Cancellation and Timeout, Cooperative Cancellation and Timeout

canceling after set time, Cooperative Cancellation and Timeout

cooperative cancellation, Cooperative Cancellation and Timeout

ComputeResult method, Interlocked Constructs

Concat method, Boxing and Unboxing Value Types, Passing a Variable Number of Arguments to a Method

concatenating strings, Constructing Strings

concurrent classes, The Concurrent Collection Classes

ConcurrentBag class, The Concurrent Collection Classes

ConcurrentDictionary class, The Concurrent Collection Classes

ConcurrentExclusiveSchedulerPair class, Asynchronous Synchronization

ConcurrentQueue class, The Concurrent Collection Classes

ConcurrentStack class, The Concurrent Collection Classes

condition variable pattern, The Condition Variable Pattern

conditional attribute classes, Conditional Attribute Classes

ConditionalWeakTable class, Monitoring and Controlling the Lifetime of Objects Manually

configuration files, Simple Administrative Control (Configuration), Advanced Administrative Control (Configuration), Publisher Policy Control, Publisher Policy Control

as separate assembly files, Publisher Policy Control

publisher policy controls and, Publisher Policy Control

ConfigureAwait method, Applications and Their Threading Models

Console class, Formatting Multiple Objects into a Single String, Class Libraries and Thread Safety

const-ness, unsupported, Const-ness

constants, Type and Member Basics, Constants, Constants, Constants

constraints on, Constants

defined, Type and Member Basics

for non-primitive types, Constants

metadata and, Constants

constrained execution regions (CERs), Trading Reliability for Productivity, Constrained Execution Regions (CERs)

ConstrainedCopy method, Casting Arrays

ConstrainedExecution namespace, Working with Types Requiring Special Cleanup

constraints, Verifiability and Constraints, Verifiability and Constraints, Verifiability and Constraints, Primary Constraints, Secondary Constraints, Constructor Constraints

constructor, Constructor Constraints

generics and, Verifiability and Constraints

on type parameters, Verifiability and Constraints

primary, Verifiability and Constraints

reference types as, Primary Constraints

secondary, Secondary Constraints

constructing type instances, Constructing an Instance of a Type

constructor constraints, Constructor Constraints

constructor method, A Brief Look at Metadata, Instance Constructors and Classes (Reference Types), Instance Constructors and Classes (Reference Types), Instance Constructors and Classes (Reference Types), Instance Constructors and Structures (Value Types), Instance Constructors and Structures (Value Types), Instance Constructors and Structures (Value Types), Instance Constructors and Structures (Value Types), Demystifying Delegates, Demystifying Delegates

calling default, Instance Constructors and Structures (Value Types)

creating types without, Instance Constructors and Classes (Reference Types)

default, Instance Constructors and Classes (Reference Types)

defining on value types, Instance Constructors and Structures (Value Types)

for delegates, Demystifying Delegates

parameterless, Instance Constructors and Structures (Value Types)

virtual methods and, Instance Constructors and Classes (Reference Types)

ConstructorInfo object, Constructing an Instance of a Type

constructors, Object and Collection Initializers, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation, Tasks

parameterless, Object and Collection Initializers

Task objects and, Tasks

thread, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation

context structures, Thread Scheduling and Priorities

context switching, Thread Overhead, Thread Overhead, Thread Overhead, Thread Overhead, Thread Scheduling and Priorities, Asynchronous Synchronization

avoiding, Thread Overhead

in asynchronous synchronization, Asynchronous Synchronization

performance issues, Thread Overhead, Thread Overhead

contexts, thread, Thread Overhead

ContinueWhenAll method, Task Factories

ContinueWith method, Starting a New Task Automatically When Another Task Completes, Starting a New Task Automatically When Another Task Completes, How Windows Performs I/O Operations

contra-variant reference types, Using Delegates to Call Back Static Methods

contra-variant type parameters, Delegate and Interface Contra-variant and Covariant Generic Type Arguments

Contract class, Trading Reliability for Productivity

contract reference assemblies, Code Contracts

ContractFailed event, Code Contracts

ContractInvariantMethod attribute, Code Contracts

convenient syntax, Instance Constructors and Classes (Reference Types)

conversion constructors, Conversion Operator Methods

conversion operator methods, Conversion Operator Methods, Conversion Operator Methods, Conversion Operator Methods, Conversion Operator Methods, Conversion Operator Methods

implicit and explicit, Conversion Operator Methods, Conversion Operator Methods

metadata for, Conversion Operator Methods

support for, Conversion Operator Methods

conversion operators, defined, The Different Kinds of Type Members

Convert class, Controlling the Serialized/Deserialized Data

Convert method, Encodings: Converting Between Characters and Bytes

Convert type, Characters, Base-64 String Encoding and Decoding

ConvertIList method, Secondary Constraints

cooperative cancellation, Cooperative Cancellation and Timeout, Cooperative Cancellation and Timeout

unhandled exceptions and, Cooperative Cancellation and Timeout

Copy method, Other String Operations, Casting Arrays, Casting Arrays, All Arrays Implicitly Implement IEnumerable, ICollection, and IList

Array class, Casting Arrays, All Arrays Implicitly Implement IEnumerable, ICollection, and IList

vs. BlockCopy method, Casting Arrays

copy operation, and unboxing types, Boxing and Unboxing Value Types

copying, Other String Operations, Casting Arrays, All Arrays Implicitly Implement IEnumerable, ICollection, and IList

arrays, Casting Arrays, All Arrays Implicitly Implement IEnumerable, ICollection, and IList

strings, Other String Operations

CopyTo method, Other String Operations, StringBuilder Members, Passing Blocks of Data Between the CLR and WinRT

CoreClr.dll, Microsoft Silverlight Rich Internet Applications

CorFlags.exe, Loading the Common Language Runtime

corrupted, Parameterless Properties, Managed Heap Basics

memory, Managed Heap Basics

object state, avoiding, Parameterless Properties

CountdownEvent class, The CountdownEvent Class

Counter method, A First Look at Delegates, Using Delegates to Call Back Static Methods, Using Delegates to Call Back Many Methods (Chaining)

delegate chaining and, Using Delegates to Call Back Many Methods (Chaining)

country identifiers, Comparing Strings

covariant, Delegate and Interface Contra-variant and Covariant Generic Type Arguments, Delegate and Interface Contra-variant and Covariant Generic Type Arguments, Using Delegates to Call Back Static Methods

in and out keywords, Delegate and Interface Contra-variant and Covariant Generic Type Arguments

reference types, Using Delegates to Call Back Static Methods

type parameters, Delegate and Interface Contra-variant and Covariant Generic Type Arguments

CPU virtualization, Why Does Windows Support Threads?

CPUs, CPU Trends, CPU Trends, CPU Trends, CPU Trends, Reasons to Use Threads, Reasons to Use Threads, Reasons to Use Threads, Thread Scheduling and Priorities, Compute-Bound Asynchronous Operations

aggressive utilization of, Reasons to Use Threads

heat dissipation and, CPU Trends, Reasons to Use Threads

high usage, as good thing, Thread Scheduling and Priorities

hyperthreaded, CPU Trends

low usage of, Compute-Bound Asynchronous Operations

multiple cores, CPU Trends

power utilization, optimal, Reasons to Use Threads

trends for, CPU Trends

CreateDelegate method, Delegates and Reflection

CreateDomain method, AppDomain overloads of, Demo #1: Cross-AppDomain Communication Using Marshal-by-Reference

CreateEvent method, Kernel-Mode Constructs

CreateFile method, synchronous execution of, Some I/O Operations Must Be Done Synchronously

CreateInstance method, Creating Non-Zero Lower Bound Arrays, Constructing an Instance of a Type, Constructing an Instance of a Type

AppDomain class, Constructing an Instance of a Type

Array class, Constructing an Instance of a Type

CreateInstanceAndUnwrap method, Demo #1: Cross-AppDomain Communication Using Marshal-by-Reference

CreateInstanceFrom method, Constructing an Instance of a Type

CreateMutex method, Kernel-Mode Constructs

CreateProcess function, AppDomains

CreateSemaphore method, Kernel-Mode Constructs

critical regions, Writing a Robust Host Application

CriticalFinalizer object, Working with Types Requiring Special Cleanup

CriticalHandle class, Working with Types Requiring Special Cleanup

CSC.exe, Building Types into a Module

CSC.rsp, Response Files

CSP containers for public/private keys, Delayed Signing

CTS (Common Type System), The Common Type System

CUI (Console User Interface) applications, Building Types into a Module

culture setting in assemblies, Culture

CultureInfo class, Characters

CultureInfo type, Comparing Strings

CurrentCulture property, Characters, Comparing Strings

CurrentUICulture property, Comparing Strings

custom attributes, Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Using Custom Attributes, Defining Your Own Attribute Class, Defining Your Own Attribute Class, Defining Your Own Attribute Class, Defining Your Own Attribute Class, Defining Your Own Attribute Class, Defining Your Own Attribute Class, Defining Your Own Attribute Class, Attribute Constructor and Field/Property Data Types, Detecting the Use of a Custom Attribute, Detecting the Use of a Custom Attribute, Detecting the Use of a Custom Attribute, Matching Two Attribute Instances Against Each Other, Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects, Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects

applying multiple times, Defining Your Own Attribute Class

as logical state containers, Defining Your Own Attribute Class

attribute objects, constructing, Detecting the Use of a Custom Attribute

C# syntax for, Using Custom Attributes

class inheritance, Using Custom Attributes, Defining Your Own Attribute Class

data types for, Attribute Constructor and Field/Property Data Types

defining attribute class, Defining Your Own Attribute Class

defining classes for, Defining Your Own Attribute Class

detecting in code, Detecting the Use of a Custom Attribute

detecting in code, without executing, Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects

detecting specific, Detecting the Use of a Custom Attribute

enumerated types, Defining Your Own Attribute Class

examples of, Using Custom Attributes

matching against each other, Matching Two Attribute Instances Against Each Other

multiple, applying, Using Custom Attributes

prefixes, Using Custom Attributes

public constructors, Defining Your Own Attribute Class

security concerns, Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects

suffix, omitting, Using Custom Attributes, Using Custom Attributes

syntax for, Using Custom Attributes

targets for, Using Custom Attributes

Visual Basic .NET syntax for, Using Custom Attributes

CustomAttributeData class, Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects

CustomAttributeExtensions class, Detecting the Use of a Custom Attribute