T

TakeFromAny methods, The Concurrent Collection Classes

Task class, Asynchronous Synchronization, Asynchronous Synchronization

vs. Barrier class, Asynchronous Synchronization

vs. thread synchronization, Asynchronous Synchronization

Task Manager, Thread Overhead, Stop the Madness, Stop the Madness

monitoring performance with, Stop the Madness

Task objects, Tasks, Tasks, Starting a New Task Automatically When Another Task Completes, Inside a Task, Inside a Task, Inside a Task, Inside a Task, Inside a Task, Inside a Task, Inside a Task, Task Factories

Boolean properties for, Inside a Task

ContinueWith task collections, Starting a New Task Automatically When Another Task Completes

creation flags for, Tasks

CurrentId property, Inside a Task

factory for, Task Factories

fields in, Inside a Task

Int32 fields in, Inside a Task

Status property, querying, Inside a Task

supplementary state, Inside a Task

WaitingForActivation state, Inside a Task

TaskFactory type, Task Factories, Task Factories

TaskLogger class, Async Function Extensibility

tasks, Tasks, Tasks, Waiting for a Task to Complete and Getting Its Result, Waiting for a Task to Complete and Getting Its Result, Waiting for a Task to Complete and Getting Its Result, Canceling a Task, Canceling a Task, Starting a New Task Automatically When Another Task Completes, A Task May Start Child Tasks, Inside a Task, Inside a Task, Inside a Task, Inside a Task, Task Factories, Task Schedulers, Task Schedulers, Parallel’s Static For, ForEach, and Invoke Methods, Thread Synchronization Construct Summary, Asynchronous Synchronization

CancellationToken objects, associating with, Canceling a Task

child tasks, A Task May Start Child Tasks

delegates, passing, Parallel’s Static For, ForEach, and Invoke Methods

exceptions thrown by, Canceling a Task

exceptions, detecting, Waiting for a Task to Complete and Getting Its Result

reader/writer semantics, Asynchronous Synchronization

returning void with, Task Factories

scheduling to run, Tasks

starting automatically on other task completion, Starting a New Task Automatically When Another Task Completes

state, Inside a Task

supplementary state, Inside a Task

task factories, Inside a Task

task schedulers, Task Schedulers, Task Schedulers

unhandled exceptions thrown by, Waiting for a Task to Complete and Getting Its Result

unique IDs for, Inside a Task

vs. thread synchronization, Thread Synchronization Construct Summary

waiting for completion, Waiting for a Task to Complete and Getting Its Result

Tasks namespace, Calling Asynchronous WinRT APIs from .NET Code, Tasks, Inside a Task

TaskScheduler objects, Task Schedulers

TaskScheduler type, defining classes derived from, Task Schedulers

TEB (thread environment block), Thread Overhead

temporary variables, Verifiability and Constraints

terminated applications, viewing in Reliability Monitor, Unhandled Exceptions

terminating process, Trading Reliability for Productivity, Executable Applications

thread blocking, I/O operations and, How Windows Performs I/O Operations

Thread class, CLR Threads and Windows Threads

thread environment block (TEB), Thread Overhead

thread kernel objects, Thread Overhead

thread locks, asynchronous functions and, C#’s Asynchronous Functions

thread pools, Compute-Bound Asynchronous Operations, Introducing the CLR’s Thread Pool, Introducing the CLR’s Thread Pool, Performing a Simple Compute-Bound Operation, Performing a Simple Compute-Bound Operation, Execution Contexts, Starting a New Task Automatically When Another Task Completes, A Task May Start Child Tasks, A Task May Start Child Tasks, Task Schedulers, Parallel’s Static For, ForEach, and Invoke Methods, Parallel’s Static For, ForEach, and Invoke Methods, Parallel’s Static For, ForEach, and Invoke Methods, Parallel’s Static For, ForEach, and Invoke Methods, Performing a Periodic Compute-Bound Operation, So Many Timers, So Little Time, Setting Thread Pool Limits, How Worker Threads Are Managed, How Worker Threads Are Managed, How Worker Threads Are Managed, How Worker Threads Are Managed

calling methods asynchronously, Performing a Simple Compute-Bound Operation

child tasks, A Task May Start Child Tasks

continuing tasks in, Starting a New Task Automatically When Another Task Completes, A Task May Start Child Tasks

deadlock situations, Setting Thread Pool Limits

heuristic nature of, Introducing the CLR’s Thread Pool

limiting number of threads in, How Worker Threads Are Managed

loop state management, Parallel’s Static For, ForEach, and Invoke Methods

parallel performance of, Parallel’s Static For, ForEach, and Invoke Methods

parallel processing, exceptions thrown when, Parallel’s Static For, ForEach, and Invoke Methods

performance and, Introducing the CLR’s Thread Pool

processing order, How Worker Threads Are Managed

queuing in, Performing a Simple Compute-Bound Operation

scheduling method calls, Performing a Periodic Compute-Bound Operation

scheduling tasks in, Task Schedulers

security settings and, Execution Contexts

sequential method execution, Parallel’s Static For, ForEach, and Invoke Methods

thread management in, So Many Timers, So Little Time

thread synchronization locks and, How Worker Threads Are Managed

worker thread management, How Worker Threads Are Managed

thread prioritization, I/O Request Priorities

thread safety, Class Libraries and Thread Safety

thread synchronization, Type Constructors, Defining Properties Intelligently, Trading Reliability for Productivity, Primitive Thread Synchronization Constructs, Class Libraries and Thread Safety, Primitive User-Mode and Kernel-Mode Constructs, Interlocked Constructs, Implementing a Simple Spin Lock, Implementing a Simple Spin Lock, Implementing a Simple Spin Lock, Event Constructs, Mutex Constructs, Mutex Constructs, A Simple Hybrid Lock, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks, The OneManyLock Class, The Barrier Class, Thread Synchronization Construct Summary, The Famous Double-Check Locking Technique, The Famous Double-Check Locking Technique, Asynchronous Synchronization

async functions and, Primitive Thread Synchronization Constructs

auto-reset events and, Event Constructs

class libraries and, Class Libraries and Thread Safety

double-check locking, The Famous Double-Check Locking Technique

exception handling and, Trading Reliability for Productivity

hybrid, A Simple Hybrid Lock

lock, Type Constructors, The Monitor Class and Sync Blocks

lock scalability issues, Asynchronous Synchronization

Mutex objects, Mutex Constructs

m_opCount field, Interlocked Constructs

parallel execution, The Barrier Class

primitive constructs, Primitive User-Mode and Kernel-Mode Constructs

priority boosting, disabling, Implementing a Simple Spin Lock

private locks, The Monitor Class and Sync Blocks

properties and, Defining Properties Intelligently

reader-writer locks, The OneManyLock Class

recursive locks, Mutex Constructs

specifying synchronization object, The Famous Double-Check Locking Technique

spin lock addition logic, Implementing a Simple Spin Lock

tasks vs., Thread Synchronization Construct Summary

yielding threads when, Implementing a Simple Spin Lock

thread-safe, The Concurrent Collection Classes

collection classes, The Concurrent Collection Classes

ThreadAbortException exception, How a Host Gets Its Thread Back

ThreadException event, Unhandled Exceptions

threading models, Applications and Their Threading Models

Threading namespace, Execution Contexts, So Many Timers, So Little Time, So Many Timers, So Little Time, Kernel-Mode Constructs

DispatcherTimer class, So Many Timers, So Little Time

Timer class, So Many Timers, So Little Time

ThreadPerTaskScheduler, Task Schedulers

ThreadPool class, Performing a Simple Compute-Bound Operation, Execution Contexts

for Windows Store apps, Execution Contexts

threads, How Things Relate at Run Time, How Things Relate at Run Time, Writing a Robust Host Application, Why Does Windows Support Threads?, Why Does Windows Support Threads?, Thread Overhead, Thread Overhead, Thread Overhead, Thread Overhead, Thread Overhead, Stop the Madness, Stop the Madness, Stop the Madness, CLR Threads and Windows Threads, CLR Threads and Windows Threads, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation, Reasons to Use Threads, Reasons to Use Threads, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Foreground Threads vs. Background Threads, Execution Contexts

allocating local variables, How Things Relate at Run Time

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

CLR and Windows interoperability, CLR Threads and Windows Threads

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

creating, vs. creating processes, Stop the Madness

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

DLL thread-attach/thread-detach notifications, Thread Overhead

early implementation of, Why Does Windows Support Threads?

execution contexts, Execution Contexts

forcibly killing, Thread Overhead

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

foreground vs. background, Foreground Threads vs. Background Threads

garbage collection and, Thread Overhead

gracefully aborting, Writing a Robust Host Application

Idle priority level, Thread Scheduling and Priorities

in 16-bit Windows, Why Does Windows Support Threads?

inefficient memory allocation and, Stop the Madness

number per process, Stop the Madness

overhead, Thread Overhead

priority levels, mapping, Thread Scheduling and Priorities

priority, non-normal, Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation

properties, viewing, Thread Scheduling and Priorities

Realtime priority class, Thread Scheduling and Priorities

reasons for using, Reasons to Use Threads

relative priorities, Thread Scheduling and Priorities

responsiveness of, Reasons to Use Threads

scalability, Thread Overhead

starvation, Thread Scheduling and Priorities

Time-Critical priority level, Thread Scheduling and Priorities

Windows Store apps, APIs removed for, CLR Threads and Windows Threads

ThreadsSharingData class, Volatile Constructs

ThrowIfCancellationRequested method, Canceling a Task

throwing exceptions, Throwing an Exception

Time-Critical thread priority level, Thread Scheduling and Priorities

Timer class, Performing a Periodic Compute-Bound Operation, So Many Timers, So Little Time

Timer objects, garbage collection of, Performing a Periodic Compute-Bound Operation

Timers namespace, Timer class, So Many Timers, So Little Time

ToArray method, Passing Blocks of Data Between the CLR and WinRT

ToLowerInvariant method, Characters

ToObject method, Enumerated Types

torn reads, User-Mode Constructs

ToSingle method, Be Careful with Explicit Interface Method Implementations

ToString method, All Types Are Derived from System.Object, Boxing and Unboxing Value Types, Anonymous Types, Characters, StringBuilder Members, Specific Formats and Cultures, Specific Formats and Cultures, Enumerated Types, Enumerated Types, Enumerated Types, Bit Flags, Demo #2: Cross-AppDomain Communication Using Marshal-by-Value

output formatting, Bit Flags

output of, Enumerated Types

parameterless, Specific Formats and Cultures

parameters, Specific Formats and Cultures

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

vs. Format method, Enumerated Types

ToString, null for format string, Specific Formats and Cultures

ToUpperInvariant method, Characters

Transaction class, The Monitor Class and Sync Blocks

TransactionScope class, Trading Reliability for Productivity

triggering garbage collections, Garbage Collection Triggers

try blocks, Exception-Handling Mechanics, The finally Block, Constrained Execution Regions (CERs)

as callback methods, Constrained Execution Regions (CERs)

finally blocks and, The finally Block

TryParse method, Enumerated Types, Exception-Handling Performance Considerations, Exception-Handling Performance Considerations

exception handling and, Exception-Handling Performance Considerations

Tuple, Anonymous Types, Anonymous Types, The System.Tuple Type, The System.Tuple Type

class, The System.Tuple Type

properties and, The System.Tuple Type

types, Anonymous Types, Anonymous Types

type arguments, Generics

type constructors, Type and Member Basics, Type Constructors, Type Constructors, Type Constructors, Type Constructors, Type Constructors, Type Constructors, Type Constructors, Type Constructors, Type Constructors

calling, Type Constructors

calling in order, avoiding, Type Constructors

default, Type Constructors

defined, Type and Member Basics

initializing singleton objects with, Type Constructors

mutual references in, Type Constructors

private, Type Constructors

thread synchronization lock, Type Constructors

unhandled exceptions, Type Constructors

type definitions, example of, The Different Kinds of Type Members

type inference, Generic Methods and Type Inference

generic methods and, Generic Methods and Type Inference

type object pointer, How Things Relate at Run Time

Type objects, Open and Closed Types, Open and Closed Types, Discovering Types Defined in an Assembly, What Exactly Is a Type Object?, The Monitor Class and Sync Blocks

for generic types, Open and Closed Types

obtaining from type names at compile time, What Exactly Is a Type Object?

open, creating, Open and Closed Types

sync blocks and, The Monitor Class and Sync Blocks

type parameters, Generics, Delegate and Interface Contra-variant and Covariant Generic Type Arguments, Delegate and Interface Contra-variant and Covariant Generic Type Arguments, Verifiability and Constraints, Verifiability and Constraints, Secondary Constraints, Constructor Constraints, Generics and Interface Constraints

constraining to interfaces, Generics and Interface Constraints

constraints, Verifiability and Constraints, Secondary Constraints

constructor constraints for, Constructor Constraints

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

generic, Delegate and Interface Contra-variant and Covariant Generic Type Arguments

overriding methods and, Verifiability and Constraints

type safety, Passing Parameters by Reference to a Method, Generics, Improving Compile-Time Type Safety with Explicit Interface Method Implementations, Improving Compile-Time Type Safety with Explicit Interface Method Implementations

interfaces and, Improving Compile-Time Type Safety with Explicit Interface Method Implementations, Improving Compile-Time Type Safety with Explicit Interface Method Implementations

type variables, generic, Constructor Constraints, Casting a Generic Type Variable, Comparing Two Generic Type Variables with Each Other

type-safe languages, The dynamic Primitive Type

TypeDef table, A Brief Look at Metadata

TypeInfo class, Discovering a Type’s Members

TypeInfo object, What Exactly Is a Type Object?

TypeInfo objects, What Exactly Is a Type Object?

typeless instructions, IL and Verification

typeof operator, Attribute Constructor and Field/Property Data Types, What Exactly Is a Type Object?

TypeRef table, A Brief Look at Metadata

types, The Common Type System, The Common Type System, The Common Type System, The Common Type System, The Common Type System, The Common Language Specification, Building Types into a Module, Building Types into a Module, How the Runtime Resolves Type References, How the Runtime Resolves Type References, All Types Are Derived from System.Object, Casting Between Types, Casting with the C# is and as Operators, Namespaces and Assemblies, Namespaces and Assemblies, Namespaces and Assemblies, Namespaces and Assemblies, Namespaces and Assemblies, How Things Relate at Run Time, Primitive, Reference, and Value Types, Programming Language Primitive Types, Checked and Unchecked Primitive Type Operations, Checked and Unchecked Primitive Type Operations, Reference Types and Value Types, Type and Member Basics, Type Visibility, Type Visibility, Member Accessibility, Partial Classes, Structures, and Interfaces, Using Type Visibility and Member Accessibility Intelligently, Instance Constructors and Classes (Reference Types), Type Constructors, Type Constructors, Implicitly Typed Local Variables, Implicitly Typed Local Variables, Implicitly Typed Local Variables, Anonymous Types, Anonymous Types, Anonymous Types, Anonymous Types, Anonymous Types, Generics, Generics, Generics, Open and Closed Types, Open and Closed Types, Generic Type Identity, Generic Type Identity, Code Explosion, Generic Interfaces, More About Calling Interface Methods, Be Careful with Explicit Interface Method Implementations, Obtaining a String Representation of an Object: ToString, Specific Formats and Cultures, Enumerated Types and Bit Flags, Nullable Value Types, Nullable Value Types, C#’s Support for Nullable Value Types, The catch Block, FCL-Defined Exception Classes, Throwing an Exception, Using Reflection to Build a Dynamically Extensible Application, Using Reflection to Build a Dynamically Extensible Application, Reflection Performance, What Exactly Is a Type Object?, What Exactly Is a Type Object?, Building a Hierarchy of Exception-Derived Types, Constructing an Instance of a Type, Constructing an Instance of a Type, Designing an Application That Supports Add-Ins, Designing an Application That Supports Add-Ins, Using Reflection to Discover a Type’s Members, Discovering a Type’s Members, Discovering a Type’s Members, Invoking a Type’s Members, Invoking a Type’s Members, Using Binding Handles to Reduce Your Process’s Memory Consumption, Making a Type Serializable, Serializing a Type As a Different Type and Deserializing an Object As a Different Object, Serialization Surrogates, WinRT Type System Core Concepts

across assemblies, Designing an Application That Supports Add-Ins

ambiguous references, Namespaces and Assemblies

anonymous, Anonymous Types, Anonymous Types, Anonymous Types

arity, Open and Closed Types

as add-ins, Designing an Application That Supports Add-Ins

assembly, The Common Type System

Backus-Naur Form grammar for, What Exactly Is a Type Object?

building into modules, Building Types into a Module

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

catch, The catch Block

common properties and methods, Discovering a Type’s Members

constructing instance of, Constructing an Instance of a Type

data fields in, How Things Relate at Run Time

declaring, Implicitly Typed Local Variables

discovering members, Using Reflection to Discover a Type’s Members, Invoking a Type’s Members

dynamically constructing, Reflection Performance

enumerated, Enumerated Types and Bit Flags

example definition of, The Common Language Specification

exception, FCL-Defined Exception Classes, Throwing an Exception

exception-derived, hierarchy of, Building a Hierarchy of Exception-Derived Types

external, Building Types into a Module

for runtime handles, Using Binding Handles to Reduce Your Process’s Memory Consumption

general format, Specific Formats and Cultures

generic, Generics, Generics, Generics, Open and Closed Types, Generic Type Identity, Constructing an Instance of a Type

generic identity, Generic Type Identity

generic interfaces and, Generic Interfaces

help documentation for, Be Careful with Explicit Interface Method Implementations

helper, Using Type Visibility and Member Accessibility Intelligently

inferring from initializing expression, Implicitly Typed Local Variables

initializing static fields, Type Constructors

invoking members, Invoking a Type’s Members

literal, Programming Language Primitive Types

member accessibility, Member Accessibility

members of, The Common Type System, Type and Member Basics

method tables, More About Calling Interface Methods

moving between assemblies, How the Runtime Resolves Type References

namespaces, Namespaces and Assemblies, Namespaces and Assemblies

nullable, Nullable Value Types, Nullable Value Types, C#’s Support for Nullable Value Types

partial, Partial Classes, Structures, and Interfaces

primitive, Primitive, Reference, and Value Types

properties, obtaining, What Exactly Is a Type Object?

public, The Common Type System, Type Visibility

reference, Reference Types and Value Types

referenced assemblies, Namespaces and Assemblies

reflection, Using Reflection to Build a Dynamically Extensible Application, Using Reflection to Build a Dynamically Extensible Application, Discovering a Type’s Members

resolving references, How the Runtime Resolves Type References

restricting access to, The Common Type System

returning name of, Obtaining a String Representation of an Object: ToString

safety, Casting Between Types

serializing, Making a Type Serializable

signed, Checked and Unchecked Primitive Type Operations

singleton, Serializing a Type As a Different Type and Deserializing an Object As a Different Object

surrogate, for serialization, Serialization Surrogates

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

Tuple, Anonymous Types, Anonymous Types

unique names, Namespaces and Assemblies

unloaded, Type Constructors

value, Checked and Unchecked Primitive Type Operations, Code Explosion

visibility, Type Visibility

Visual Studio tooltips for, Implicitly Typed Local Variables

WinRT, WinRT Type System Core Concepts

without instance constructors, Instance Constructors and Classes (Reference Types)