P

packaging assemblies, Simple Application Deployment (Privately Deployed Assemblies)

Parallel class, Parallel’s Static For, ForEach, and Invoke Methods, Parallel’s Static For, ForEach, and Invoke Methods

performance issues, Parallel’s Static For, ForEach, and Invoke Methods

when to use, Parallel’s Static For, ForEach, and Invoke Methods

Parallel LINQ, Parallel Language Integrated Query, Parallel Language Integrated Query, Parallel Language Integrated Query, Parallel Language Integrated Query

parallel processing queries, Parallel Language Integrated Query

partitions across CPU cores, Parallel Language Integrated Query

sequential and parallel queries, Parallel Language Integrated Query

parallel queries, Parallel Language Integrated Query

ParallelEnumerable class, Parallel Language Integrated Query, Parallel Language Integrated Query

ParallelLoopResult instance, Parallel’s Static For, ForEach, and Invoke Methods

ParallelLoopState object, Parallel’s Static For, ForEach, and Invoke Methods

ParallelOptions object, Parallel’s Static For, ForEach, and Invoke Methods

ParamArray attribute, Passing a Variable Number of Arguments to a Method

ParamDef table, A Brief Look at Metadata

parameterful properties, Properties, Parameterful Properties, Parameterful Properties, Parameterful Properties

accessing from unsupported languages, Parameterful Properties

selecting, Parameterful Properties

ParameterInfo object, Discovering a Type’s Members

parameterless constructors, Instance Constructors and Structures (Value Types), Object and Collection Initializers

parameterless properties, Properties

parameters, Optional and Named Arguments, Optional and Named Arguments, Rules and Guidelines, Rules and Guidelines, Rules and Guidelines, Rules and Guidelines, Implicitly Typed Local Variables, Implicitly Typed Local Variables, Passing Parameters by Reference to a Method, Passing Parameters by Reference to a Method, Passing Parameters by Reference to a Method, Parameter and Return Type Guidelines, Parameter and Return Type Guidelines, Generics and Interface Constraints, Enumerated Types

declaring types, Implicitly Typed Local Variables, Parameter and Return Type Guidelines

default values, Rules and Guidelines, Rules and Guidelines

default values, changing, Rules and Guidelines

named, Optional and Named Arguments

optional, Optional and Named Arguments

out keyword vs. ref keyword, Passing Parameters by Reference to a Method

passing by reference, Passing Parameters by Reference to a Method

passing via method, Passing Parameters by Reference to a Method

types, in methods, Implicitly Typed Local Variables

types, interfaces as, Generics and Interface Constraints

validation, Enumerated Types

variables, Rules and Guidelines

weak vs. strong, Parameter and Return Type Guidelines

params keyword, Passing a Variable Number of Arguments to a Method

Parse method, Parsing a String to Obtain an Object: Parse, Parsing a String to Obtain an Object: Parse, Parsing a String to Obtain an Object: Parse, Parsing a String to Obtain an Object: Parse, Enumerated Types, Exception-Handling Performance Considerations

exception handling for, Exception-Handling Performance Considerations

parameters, Parsing a String to Obtain an Object: Parse

performance and, Parsing a String to Obtain an Object: Parse

skipping leading space, Parsing a String to Obtain an Object: Parse

ParseCombiningCharacters method, Examining a String’s Characters and Text Elements

ParseExact method, Parsing a String to Obtain an Object: Parse

parsing, Parsing a String to Obtain an Object: Parse, Parsing a String to Obtain an Object: Parse

dates and times, Parsing a String to Obtain an Object: Parse

strings, Parsing a String to Obtain an Object: Parse

partial keyword, Partial Classes, Structures, and Interfaces

partial methods, Partial Methods, Partial Methods, Partial Methods, Partial Methods, Partial Methods, Partial Methods, Rules and Guidelines, Rules and Guidelines, Rules and Guidelines

efficiency of, Partial Methods

in Visual Studio, Partial Methods

overriding types with, Partial Methods

private keyword and, Rules and Guidelines

return type for, Rules and Guidelines

rules and guidelines, Rules and Guidelines

runtime performance and, Partial Methods

sealed classes and, Partial Methods

passing arrays, Passing and Returning Arrays

passing parameters, via reference, Passing Parameters by Reference to a Method

path names, loading assemblies with, Assembly Loading

pbytes local variable, Monitoring and Controlling the Lifetime of Objects Manually

PDB (Program Database) files, Executing Your Assembly’s Code

PE (portable executable) files, Combining Modules to Form an Assembly, Combining Modules to Form an Assembly, Adding Resource Files to an Assembly

command-line switches for compiling, Combining Modules to Form an Assembly

embedding resource files into, Adding Resource Files to an Assembly

manifest, Combining Modules to Form an Assembly

PE32, Compiling Source Code into Managed Modules, Combining Managed Modules into Assemblies, Loading the Common Language Runtime, A Brief Look at Metadata

(+) files, Combining Managed Modules into Assemblies

(+) headers, A Brief Look at Metadata

PE32 headers, Compiling Source Code into Managed Modules

platform version and, Loading the Common Language Runtime

PerfMon.exe, Monitoring Your Application’s Memory Usage

performance concerns, Executing Your Assembly’s Code

performance counters, Monitoring Your Application’s Memory Usage

performance issues, Exception-Handling Performance Considerations, Using Reflection to Build a Dynamically Extensible Application, Using Binding Handles to Reduce Your Process’s Memory Consumption, Why Does Windows Support Threads?, Thread Overhead, Thread Overhead, Thread Overhead, Thread Overhead, Stop the Madness, Reasons to Use Threads, Compute-Bound Asynchronous Operations, Execution Contexts, Inside a Task, Primitive Thread Synchronization Constructs, A Simple Hybrid Lock, The Famous Double-Check Locking Technique

binding handles and, Using Binding Handles to Reduce Your Process’s Memory Consumption

context switching and, Thread Overhead, Thread Overhead

DLLs and, Thread Overhead

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

exception handling and, Exception-Handling Performance Considerations

execution contexts and, Execution Contexts

monitoring with Task Manager, Stop the Madness

reflection and, Using Reflection to Build a Dynamically Extensible Application

tasks and, Inside a Task

thread pools and, Compute-Bound Asynchronous Operations

thread synchronization and, Primitive Thread Synchronization Constructs

thread synchronization locks and, A Simple Hybrid Lock

threads and, Why Does Windows Support Threads?, Thread Overhead, Reasons to Use Threads

Performance Monitor, testing exception handling with, Exception-Handling Performance Considerations

PerfView, Monitoring Your Application’s Memory Usage

periodic compute-bound operations, Performing a Periodic Compute-Bound Operation

PEVerify.exe, Unsafe Code

Pinned flag, Monitoring and Controlling the Lifetime of Objects Manually

pinning objects, Monitoring and Controlling the Lifetime of Objects Manually

platform command-line switch, Loading the Common Language Runtime, Loading the Common Language Runtime

points of failure, sources of, Trading Reliability for Productivity

policy controls, Publisher Policy Control

polygons, arrays of, Arrays

polymorphism, WinRT components and, WinRT Type System Core Concepts

pooling strings, String Pooling

positional parameters, Using Custom Attributes

PostAsync method, Async Functions in the Framework Class Library

postconditions, Code Contracts, Code Contracts

Power Threading library, The OneManyLock Class

preamble, Encodings: Converting Between Characters and Bytes

preconditions, Code Contracts, Code Contracts, Code Contracts

inheritance of, Code Contracts

preemptive multithreaded operating system, Thread Scheduling and Priorities

PrepareConstrainedRegions method, Constrained Execution Regions (CERs)

primary constraints, Primary Constraints

primitive thread sychronization constructs, Primitive User-Mode and Kernel-Mode Constructs, Primitive User-Mode and Kernel-Mode Constructs, User-Mode Constructs, Volatile Constructs, Interlocked Constructs, Kernel-Mode Constructs, Event Constructs

interlocked, Interlocked Constructs

kernel-mode, Primitive User-Mode and Kernel-Mode Constructs, Kernel-Mode Constructs, Event Constructs

user-mode, User-Mode Constructs

volatile, Volatile Constructs

primitive types, Primitive, Reference, and Value Types, Programming Language Primitive Types, Programming Language Primitive Types, Checked and Unchecked Primitive Type Operations, The dynamic Primitive Type, Constants, Rules and Guidelines, Enumerated Types

as enumerated types, Enumerated Types

checked and unchecked, Checked and Unchecked Primitive Type Operations

defining constants with, Constants

dynamic, The dynamic Primitive Type

parameter default values, Rules and Guidelines

vs. FCL types, Programming Language Primitive Types

with FCL types, Programming Language Primitive Types

primitive types and, Programming Language Primitive Types

primitives, overflows and, Checked and Unchecked Primitive Type Operations

prioritizing 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, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Thread Scheduling and Priorities, Thread Scheduling and Priorities, I/O Request Priorities, Implementing a Simple Spin Lock

by application, Thread Scheduling and Priorities

classes for, Thread Scheduling and Priorities

for Windows Store apps, Thread Scheduling and Priorities

Idle priority level, Thread Scheduling and Priorities

mapping priority levels, Thread Scheduling and Priorities

priority boosting, Implementing a Simple Spin Lock

process priority class, Thread Scheduling and Priorities

raising and lowering priority, Thread Scheduling and Priorities

Realtime class, Thread Scheduling and Priorities

relative priority classes, Thread Scheduling and Priorities

Time-Critical priority level, Thread Scheduling and Priorities

PrioritizingTaskScheduler, Task Schedulers

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

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

private assemblies, Two Kinds of Assemblies, Two Kinds of Deployment, Privately Deploying Strongly Named Assemblies

strongly named, Privately Deploying Strongly Named Assemblies

private fields, Using Type Visibility and Member Accessibility Intelligently, Parameterless Properties, Automatically Implemented Properties

private methods, Type Constructors, Rules and Guidelines

partial methods as, Rules and Guidelines

type constructors, Type Constructors

private thread locks, The Monitor Class and Sync Blocks

privately deployed assemblies, Simple Application Deployment (Privately Deployed Assemblies)

problem signatures, Unhandled Exceptions

Process class, Thread Scheduling and Priorities

processes, Trading Reliability for Productivity, AppDomains, AppDomains, Stop the Madness, Stop the Madness, Stop the Madness, Stop the Madness, Thread Scheduling and Priorities

creating, expensive nature of, Stop the Madness

creating, vs. creating threads, Stop the Madness

example of, AppDomains

isolation, AppDomains

process priority class, Thread Scheduling and Priorities

terminating, Trading Reliability for Productivity

threads per, Stop the Madness

wasteful, identifying, Stop the Madness

processor architecture, loading assemblies for, Assembly Loading

ProcessThread class, Thread Scheduling and Priorities

productivity vs. reliability in error handling, Trading Reliability for Productivity

program order, Volatile Constructs

Program type, A Brief Look at Metadata

prologue code, How Things Relate at Run Time

properties, The Common Type System, Properties, Properties, Parameterless Properties, Parameterless Properties, Parameterless Properties, Automatically Implemented Properties, Defining Properties Intelligently, Defining Properties Intelligently, Defining Properties Intelligently, Defining Properties Intelligently, Defining Properties Intelligently, Defining Properties Intelligently, The System.Tuple Type, Parameterful Properties, Parameterful Properties, Parameterful Properties, Defining Your Own Attribute Class, Invoking a Type’s Members

accessor methods, Parameterless Properties

automatically implemented, Automatically Implemented Properties

C# support for, Parameterless Properties

compiler results, Parameterful Properties

confusion caused by, Defining Properties Intelligently

defined, The Common Type System

defining intelligently, Defining Properties Intelligently

in metadata, Parameterless Properties

in Tuple types, The System.Tuple Type

metadata on, Invoking a Type’s Members

parameterful, Properties, Parameterful Properties, Parameterful Properties

parameterless, Properties

returning different values, Defining Properties Intelligently

thread synchronization and, Defining Properties Intelligently

Visual Studio debugger and, Defining Properties Intelligently

vs. public fields, Defining Your Own Attribute Class

when to use, Defining Properties Intelligently

PropertyDef table, A Brief Look at Metadata

PropertyInfo type, Invoking a Type’s Members

public, The Common Type System, Friend Assemblies, Conversion Operator Methods, Inheriting an Interface, Defining Your Own Attribute Class

constructors, defining, Conversion Operator Methods

fields, vs. properties, Defining Your Own Attribute Class

methods, interfaces and, Inheriting an Interface

types, The Common Type System, Friend Assemblies

public and private keys, Two Kinds of Assemblies, Two Kinds of Deployment, Giving an Assembly a Strong Name, Giving an Assembly a Strong Name, Delayed Signing, Delayed Signing, Delayed Signing, Publisher Policy Control

creating, Giving an Assembly a Strong Name

delayed signing, Delayed Signing

for assemblies, Two Kinds of Assemblies, Two Kinds of Deployment

for publisher policy assemblies, Publisher Policy Control

hashing to reduce space, Giving an Assembly a Strong Name

in CSP containers, Delayed Signing

in hardware devices, securing, Delayed Signing

publisher policy controls, Publisher Policy Control

publisherPolicy elements, Advanced Administrative Control (Configuration)

publishing values, The Famous Double-Check Locking Technique

Pulse method, The Condition Variable Pattern

PulseAll method, The Condition Variable Pattern

PutAsync method, Async Functions in the Framework Class Library