E

early binding, Using Reflection to Build a Dynamically Extensible Application

encoding, Encodings: Converting Between Characters and Bytes, Encodings: Converting Between Characters and Bytes

explicitly constructing types, Encodings: Converting Between Characters and Bytes

methods, Encodings: Converting Between Characters and Bytes

Encoding class, Encodings: Converting Between Characters and Bytes, Encodings: Converting Between Characters and Bytes

properties, Encodings: Converting Between Characters and Bytes

encodings, Encodings: Converting Between Characters and Bytes, Encodings: Converting Between Characters and Bytes

property values, Encodings: Converting Between Characters and Bytes

EndBackgroundProcessing, I/O Request Priorities

EndsWith method, comparing strings, Comparing Strings

EndWaitForConnection method, Async Functions in the Framework Class Library

EndXxx method, Don’t Catch Everything

EnsureInitialized method, The Famous Double-Check Locking Technique

Enter method, Trading Reliability for Productivity, A Simple Hybrid Lock, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks

Monitor class, The Monitor Class and Sync Blocks, The Monitor Class and Sync Blocks

overloading, discouraged, Trading Reliability for Productivity

Enum class, Enumerated Types

Enum type, Enumerated Types

enumerated type, Extending Various Types with Extension Methods, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Enumerated Types, Bit Flags, Bit Flags, Bit Flags, Adding Methods to Enumerated Types, Making a Type Serializable

as primitive types, Enumerated Types

bit flags, defining with, Bit Flags

classes derived from, Enumerated Types

converting symbols into, Enumerated Types

defined symbols in, Bit Flags

displaying all values for, Enumerated Types

extension methods for, Extending Various Types with Extension Methods

formatting, Enumerated Types

IsDefined method and, Bit Flags

methods, adding, Adding Methods to Enumerated Types

parameter validation, Enumerated Types

serializing, Making a Type Serializable

structure of, Enumerated Types

symbols as constant fields, Enumerated Types, Enumerated Types

underlying types for, Enumerated Types

user interface display of, Enumerated Types

with multiple symbols, Enumerated Types

enumerating types, Using Reflection to Build a Dynamically Extensible Application

enumeration types, in WinRT, WinRT Type System Core Concepts

epilogue code, How Things Relate at Run Time

equality operators, nullable types and, C#’s Support for Nullable Value Types

Equals method, All Types Are Derived from System.Object, Object Equality and Identity, Object Equality and Identity, Object Equality and Identity, Anonymous Types, String Interning

overriding, Object Equality and Identity

properties of, Object Equality and Identity

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

error messages, Member Accessibility

escalation policy, Writing a Robust Host Application

event handlers, Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification, Step #2: Define the event member, Code Contracts, Async Function Extensibility, Async Functions and Event Handlers

asynchronous functions and, Async Functions and Event Handlers

class naming convention, Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification

code contract violations and, Code Contracts

method signatures, Async Function Extensibility

void return type, Step #2: Define the event member

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

event log, viewing unhandled exceptions in, Unhandled Exceptions

EventArgs class, Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification

EventAwaiter class, Async Function Extensibility

EventDef table, A Brief Look at Metadata

EventHandler delegate type (WinRT), WinRT Type System Core Concepts

EventHandlersStore type, Explicitly Implementing an Event

EventInfo type, Invoking a Type’s Members

events, The Common Type System, Events, Events, Designing a Type That Exposes an Event, Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification, Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification, Step #2: Define the event member, Step #2: Define the event member, Step #3: Define a method responsible for raising the event to notify registered objects that the event has occurred, How the Compiler Implements an Event, How the Compiler Implements an Event, Designing a Type That Listens for an Event, Explicitly Implementing an Event, Invoking a Type’s Members, WinRT Type System Core Concepts, Kernel-Mode Constructs, Event Constructs, Semaphore Constructs

as primitive kernel-mode thread synchronization constructs, Kernel-Mode Constructs

auto-reset, Semaphore Constructs

compiler implementation of, How the Compiler Implements an Event

defined, The Common Type System

delegates, Events

designing types to expose, Designing a Type That Exposes an Event

explicitly implementing, Explicitly Implementing an Event

members, defining, Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification

metadata on, Invoking a Type’s Members

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

notifications, unregistering, Designing a Type That Listens for an Event

Object type, Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification

typing the return parameter, Step #2: Define the event member

typing the sender parameter, Step #2: Define the event member

unregistering interest from objects, How the Compiler Implements an Event

WinRT, WinRT Type System Core Concepts

EventSet class, Explicitly Implementing an Event

EventWaitHandle class, Kernel-Mode Constructs

exception handling, Defining “Exception”, Exception-Handling Mechanics, The try Block, The catch Block, The finally Block, The System.Exception Class, The System.Exception Class, The System.Exception Class, Throwing an Exception, Trading Reliability for Productivity, Trading Reliability for Productivity, Trading Reliability for Productivity, Trading Reliability for Productivity, Trading Reliability for Productivity, Guidelines and Best Practices, Guidelines and Best Practices, Guidelines and Best Practices, Use finally Blocks Liberally, Don’t Catch Everything, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State, Hiding an Implementation Detail to Maintain a “Contract”, Unhandled Exceptions, Exception-Handling Performance Considerations, Exception-Handling Performance Considerations, Exception-Handling Performance Considerations, Exception-Handling Performance Considerations, Exception-Handling Performance Considerations

assuming exceptions will occur, Trading Reliability for Productivity

backing out of partial operations, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State

best practices, Guidelines and Best Practices

catch blocks, Don’t Catch Everything

differing implementations of, Exception-Handling Performance Considerations

example code for, Defining “Exception”

finally blocks, Use finally Blocks Liberally

for class library developers vs. application developers, Guidelines and Best Practices

for high error rate methods, Exception-Handling Performance Considerations

guidelines, Guidelines and Best Practices

language for, The finally Block

localizing string messages, Throwing an Exception

managed compilers and, Exception-Handling Performance Considerations

mechanics of, Exception-Handling Mechanics

notifications for, The catch Block

performance issues, Exception-Handling Performance Considerations

problems with, Trading Reliability for Productivity

reflection and, Hiding an Implementation Detail to Maintain a “Contract”

Reliability Monitor problem signatures, Unhandled Exceptions

resetting exception starting point, The System.Exception Class

stack tracing, The System.Exception Class, The System.Exception Class

state corruption and, Trading Reliability for Productivity

state corruption, mitigating, Trading Reliability for Productivity

thread synchronization locks and, Trading Reliability for Productivity

TryParse method and, Exception-Handling Performance Considerations

viewing exception objects, The try Block

Exception objects, avoiding throwing, FCL-Defined Exception Classes

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

exceptions, Defining “Exception”, FCL-Defined Exception Classes, FCL-Defined Exception Classes, FCL-Defined Exception Classes, Throwing an Exception, Defining Your Own Exception Class, Defining Your Own Exception Class, Defining Your Own Exception Class, Trading Reliability for Productivity, Trading Reliability for Productivity, Don’t Catch Everything, Don’t Catch Everything, Recovering Gracefully from an Exception, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State, Hiding an Implementation Detail to Maintain a “Contract”, Hiding an Implementation Detail to Maintain a “Contract”, Hiding an Implementation Detail to Maintain a “Contract”, Unhandled Exceptions, Unhandled Exceptions, Debugging Exceptions, Debugging Exceptions, Code Contracts, AppDomain First-Chance Exception Notifications, Writing a Robust Host Application, WinRT Type System Core Concepts

adding types to Visual Studio debugger, Debugging Exceptions

catching all, when to, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State

catching specific, when to, Hiding an Implementation Detail to Maintain a “Contract”

class derivation of, Defining Your Own Exception Class

debugging, Debugging Exceptions

defining custom classes for, Defining Your Own Exception Class

designing for, Defining “Exception”

FCL-defined classes, FCL-Defined Exception Classes

for code contract violations, Code Contracts

in critical regions, Writing a Robust Host Application

maintaining method contracts after, Hiding an Implementation Detail to Maintain a “Contract”

potential sources of, Trading Reliability for Productivity

processing, AppDomain First-Chance Exception Notifications

re-throwing, Don’t Catch Everything, Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State

re-throwing different exception, Hiding an Implementation Detail to Maintain a “Contract”

recovering gracefully from, Recovering Gracefully from an Exception

serializable, Defining Your Own Exception Class

types, FCL-Defined Exception Classes, FCL-Defined Exception Classes

unhandled, Trading Reliability for Productivity, Don’t Catch Everything, Unhandled Exceptions, Unhandled Exceptions

versioning issues, Throwing an Exception

WinRT and, WinRT Type System Core Concepts

Exceptions dialog box (Visual Studio), Debugging Exceptions

executable applications, AppDomains and, Executable Applications

executable files, Loading the Common Language Runtime

32-bit vs. 64-bit, Loading the Common Language Runtime

ExecuteCodeWithGuaranteedCleanup method, Constrained Execution Regions (CERs)

ExecuteDbDataReaderAsync method, Async Functions in the Framework Class Library

ExecuteNonQueryAsync method, Async Functions in the Framework Class Library

ExecuteReaderAsync method, Async Functions in the Framework Class Library

ExecuteScalarAsync method, Async Functions in the Framework Class Library

ExecuteXmlReaderAsync method, Async Functions in the Framework Class Library

executing assembly code, Executing Your Assembly’s Code

execution context, Execution Contexts, Execution Contexts, Execution Contexts, Execution Contexts, Execution Contexts

ExecutionContext class, Execution Contexts

helper threads and, Execution Contexts

performance issues and, Execution Contexts

suppressing, Execution Contexts

Exit method, Executable Applications, The Condition Variable Pattern

Monitor class, The Condition Variable Pattern

expanding characters, Comparing Strings

ExpandoObject class, The System.Tuple Type

explicit interface method implementations (EIMIs), Implicit and Explicit Interface Method Implementations (What’s Happening Behind the Scenes), Improving Compile-Time Type Safety with Explicit Interface Method Implementations, Be Careful with Explicit Interface Method Implementations

explicit methods, state corruption and, Trading Reliability for Productivity

explicit type casts, Programming Language Primitive Types

explicitly implementing events, Explicitly Implementing an Event

ExportedTypesDef table, Combining Modules to Form an Assembly

exposing events, designing types for, Events

exposing state, Using Type Visibility and Member Accessibility Intelligently

expressions, casting to dynamic, The dynamic Primitive Type

Extensible Storage Engine, Trading Reliability for Productivity

extension attribute, The Extension Attribute

extension methods, Extension Methods, Extension Methods, Rules and Guidelines, Rules and Guidelines, Rules and Guidelines, Rules and Guidelines, Rules and Guidelines, Extending Various Types with Extension Methods, Extending Various Types with Extension Methods, Extending Various Types with Extension Methods, Enumerated Types, Passing Blocks of Data Between the CLR and WinRT

displaying list of, Extension Methods

for delegate types, Extending Various Types with Extension Methods

for enumerated types, Extending Various Types with Extension Methods

for interface types, Extending Various Types with Extension Methods

multiple, avoiding, Rules and Guidelines

performance issues, Rules and Guidelines

rules and guidelines for, Rules and Guidelines

versioning and, Rules and Guidelines

WinRT, Passing Blocks of Data Between the CLR and WinRT

ExtensionAttribute class, The Extension Attribute