Index

NOTE: Page references marked with an n are footnotes

! logical negation operator, 118–119

!=, <, <=, ==, >= relational operators, 386

&&, ||, ^ logical Boolean operators, 116–118, 122–126

with flag enums, 365

() (cast/conversion) operators, 61–64,

custom conversion operators, 391–393

%=, *=, /=, +=, -= (compound assignment) operators, 97

overloading compound assignment operators, 387–389

%, *, +, -, / (arithmetic) operators, 87

+ (string) operator, 90–91

%, *, +, -, / operator overloading 387–389

++/-- (increment/decrement) operators, 97–102

+, - (unary plus/minus) operators, 86–87

+, +=, -, -= delegate operators, 540–542

= assignment operators, 15

?: (conditional) operators, 119–120

?? (null coalescing) operators, 120–121

@ characters, 8, 47

[ ] (square brackets), 67–75

attributes, 687–692

indexers, 655–657

(escape sequence), 44

(newline) characters, 46, 50

^ (exclusive OR) operators, 118, 122

{} (curly braces), 2, 10, 110–114

|| (OR) operators, 116, 117, 122

constraints, 473–474

with flag enums, 365

~ (bitwise complement) operators, 127, 64

Abort() method, 740

aborting threads, 741–743

abstract classes

inheritance, 302–308

compared to interfaces, 337

abstract members, 302, 303–304, 305

access modifiers, 227–229, 397–398

internal, 396–398

private, 227–229, 284–285, 397–398

public, 227–229, 398

protected, 285–286, 397–398

protected internal, 398

on property getters/setters, 239–240

on classes, 397

array accessors, 74

Active Template Library. See ATL

Add() method, 249, 352, 473, 568–569, 641

add/remove event handlers, customizing, 558

aliases qualifiers

addition (+) operators, 87, 387, 541

guidelines, 91

strings, 90–91

overloading, 387–389

delegate operators, 540–542

addresses, 862–872

advanced parameters, methods, 175–184

AggregateException, 547, 757–764, 768, 779, 798–800

aggregation for multiple inheritance, 287–290

algorithms

hill climbing, 798

mark-and-compact, 407

mark-and-sweep-based, 882

work stealing, 798

aliasing with using, 171, 401–402

allocating

data on call stacks, 868

virtual memory, 851

AllocExecutionBlock() method, 855

AllowMultipleAttribute parameter, 700

alternative statements, 107

AND (&&) operator, 117–118, 122–126

with flag enums, 365

anonymous methods, 495, 512–514

internals, 517–518

anonymous types, 56–57, 562–564, 566–568

array initialization, 570–571

constructors, 253–255

projecting to, 583

antecedent tasks, 753

APIs (application programming interfaces), 27

APM (Asynchronous Programming Model), 908–921

AppDomain, 762

application programming interfaces. See APIs

Appointment class, 278

ArgumentException, 424

ArgumentNullException, 424

ArgumentOutOfRangeException, 424

arguments

command-line, passing, 173

methods, 161–162

named, 191

arithmetic (binary) operators, 87–96,

overloading, 387–389

arity, 460–461

ArrayList method, 350, 352

arrays, 67–82

access, 68

applying, 74–79

assigning, 68, 70–74

command-line options, 80

covariance, support, 488–489

declaring, 68, 69–70

errors, 72, 81–82

foreach loops, 571–572

instantiation, 70–74

jagged, 73, 75

length, 75–76

literal values, 71

methods, 77–79

parameters, 181–184

redimensioning, 78

runtime, defining size at, 72

strings, 79–81, 80–81

three-dimensional, 73

two-dimensional, 69, 72, 74–75

as operator, conversions, 310–311

AsParallel() method, 584

assemblies, 4. See also libraries

CLI, 887–890

metadata, viewing, 678. See also reflection

targets, modifying, 394–395

versioning, 889

well-formed types, referencing, 393–398

Assert() method, 95

assigning

arrays, 68

indexers, 657–658

null to strings, 54

pointers, 866–869

text, 42

variables, 13, 15–16

assignment operators

applying, 548

binary operators, combining with, 389

compound, 96–103

events, 541

associating

classes, 259

data types, 57

relationships, 217

XML comments, 403–405

associativity, 88

async keyword, 777–781, 937–942

asynchronous delegate invocation, 921–924

asynchronous programming, 732

high-latency operations, 772–777

lambda expressions, 782–783

methods, customizing, 783–786

models, 908–921

System.Threading.Thread class, 737–739

Task-based Asynchronous Pattern (TAP), 770–794

task-based asynchrony, 848–849

asynchronous tasks, 745–764

ATL (Active Template Library), 287

atomic operation, 734, 745, 829

attributes, 677, 688–714

backward compatibility, 712

constructors, initializing, 694–699

customizing, 692–693, 893

FlagsAttribute class, 367, 701–702

IndexerNameAttribute, 657

interfaces, comparing, 337–338

named parameters, 700–714

naming, 692

predefined, 703

searching, 693–694

serialization, 706–714

System.AttributeUsageAttribute class, 699–700

System.ConditionalAttribute class, 703–705

System.ObsoleteAttribute class, 705–706

System.SerializableAttribute class, 438, 713–714

automatically shimmed interfaces, 848

automatically implemented properties, 232–234

Average() method, 609

await keyword, 741, 777–781, 937–942

background worker patterns, 928–932

backing field declarations, 232, 244

backslash () escape sequence, 44

Base Class Library. See BCL

base classes

base member, 300–301

finalizers in, 412

inheritance, overriding, 290–302

new modifier, 295–299

refactoring, 279

sealed modifiers, 299–301

virtual modifiers, 290–295

base members, 300–301

base types, 212

BCL (Base Class Library), 25, 34, 743, 885, 892, 894

BeginGetResponse() method, 908

BeginX() method, 908

behaviors

boxing, 349–357

dynamic objects, 716–718

implementation-defined, 101

polymorphism, data types, 310

best practices, thread synchronization design, 827–829

binary floating-point types, 37, 92–96

binary (arithmetic) operators, 87–96, 387–389

BinarySearch() method, 643, 644

BinaryTree<T> class, 462–463, 658

binding

dynamic objects, 719–720

late, 893

methods, 714

runtime, XML elements, 719–720

bits, 121–122

bitwise

complement () operators, 127, 644

compound assignment operators, 126

operators, 121–127, 140

blocks

catch, 199–200, 203, 204, 428–432

code blocks ({}), 110–114

finally, 199–200

try, 197

unsafe, 863, 864

Boolean

expressions, 107, 114–121

number conversions, 64

types, 43

boxing

avoiding, 356–357

value types, 349–357

Break() method, 803

break statements, 139–141

breaking parallel loops, 803–804

brittle base classes, 295

BubbleSort() method, 496–497

buffers, overrun, 76, 883

bugs, runtime performance, 885–886

building custom collections, 635. See also collections, customizing

bytes, 121–122

C language, 1

pointers, declaring, 865

C++ language, 1, 890

arrays, declaring, 69

buffer overrun, 76

delete operator, 216

deterministic destruction, 418, 882

evaluation order of operands, 90

global methods, 164

global variables/functions, 256

header files, 168

implementation-defined behavior, 101

implicit overriding, 292

implicitly typed variables, 565

local variable scope, 114

Main method, 10

methods, calling, 295

multiple inheritance, 287

operator errors, 115

operator-only statements, 87

pointers, declaring, 865

preprocessors, 145

pure virtual functions, 305

short data types, 35

string concatenation at compile time, 48

struct, defining with public members, 348

switch statements, 138

templates, 466

void, 55

C# without generics, 444–449

caches, avoiding repeated, 590

calculating

compound assignment operators, 96–103

financial, 36

operators, 86. See also operators

pi, 794–795

values, bytes, 122

callers, 157

variables, matching with parameter names, 176

calling

APM methods, 915–921

constructors, 245

methods, 11, 156–163, 295

avoiding boxing, 356–357

statements, 163

P/Invoke

APIs, 861–86–

external functions, 858–861

SelectMany() method, 604–606

sites, 175

stacks, 175, 868

Task.ContinueWith method, 752, 789

camelCase, 7, 15

Cancel() method, 766

CancellationToken class, 764, 767

CancellationTokenSource class, 767

cancelling

parallel loops, 800

PLINQ queries, 807

tasks, 764–770

Capacity() method, 639

capitalizing variables, 15

capturing

loop variables, 521–522

variables, 518

Cartesian products, 598, 631

CAS (code access security), 884

permissions, 686

case-sensitivity, 2

multiple strings, 43

cast (()) operators, 61, 391–392

casting

inheritance, chaining, 282–283

multicast delegates, 533

operators, defining, 283

types, 65–66, 281–282

catch blocks, 199–200, 203, 204, 428–432

catch clause, 779

catching exceptions, 196–197, 426–427

categories of types, 57–60, 340

centralizing initialization, 252–253

chaining

constructors, 251–253

inheritance

casting, 282–283

exceptions, 437

multicast delegates, 544

change() method, 942

char data types, 92

characteristics of parameter arrays, 183

characters

@, 47

escape, 45

newline ( ), 46, 50

operators, applying, 91–92

Unicode, 43–46, 98

checking

conversions, 62–64, 440

for null, 538–539

types, 883

child collections, formatting, 602

Church, Alonzo, 513

CIL (Common Intermediate Language), 24, 876, 877, 894

boxing, 350

CLI, 890. See also CLI

dynamic objects, 718–719

empty catch blocks, 432

events, 556–557

extension methods, 266

generics, 490–491

best practices, 452–453

HelloWorld output, 29–30

ILDASM, 28–29

indexers, 657

iterators, defining, 661

machine code, compilation to, 879–880

objects

deriving, 309

initializers, 248

outer variables, implementing, 520–521

properties, 243–244

runtime, 881–886

Stack<T> class, 490

System.SerializableAttribute class, 713–714

circumventing encapsulation, 883

class keyword constraints, 468–469

classes, 209–210

abstract, 302–308, 337

access modifiers, 227–229, 397

associating, 259

base. See also base classes

base member, 300–301

new modifier, 295–299

overriding, 290–302

refactoring, 279

sealed modifiers, 299–301

constructors, 244–255

anonymous types, 253–255

chaining, 251–253

common initializers, 249

declaring, 245–246

defaults, 247

finalizers, 249–250

object initializers, 247–248

overloading, 250–251

declaring, 8, 213–216

definitions, 214

encapsulation, 215, 267–269

extension methods, 265–266

finalizers, 416

generics, 450–452

hierarchies, 212, 324

inheritance, 277. See also inheritance

initializers, 247–248

instances

fields, 217–219

methods, 219–220

instantiation, 213–216

interfaces

comparing, 336–337

conversions, 326

Java inner classes, 272

locations, 408

members, 216

memory, garbage collection, 408

methods, 157. See also methods

naming, 4, 8

nested, 269–272

object-oriented programming, 210–213

partial, 272–273, 272–276

properties, 229–244

access modifiers on getters/setters, 239–240

guidelines, 234–235

parameter values, 242–244

read-only/write-only, 237–239

validation, 236–237

virtual fields, 240–242

sealed, inheritance, 290

static members, 255–265

this keyword, 220–227

types, constraints, 467–468

cleanup

collection interfaces after iteration, 575

resources

APM, 914

using statements, 575

well-formed types, 410–419

CLI (Common Language Infrastructure), 1, 24–26, 894, xxvii

application domains, 887

assemblies, 887–890

BCL, 892

CIL, 890

CLS, 891–892

CTS, 891

manifests, 887–890

metadata, 892–893

modules, 887–890

closed over variables, 518

CLR (Common Language Runtime), 881, 894

CLS (Common Language Specification), 25, 877, 891–892, 895

CLU language, 660

COBOL, 890

code, xxiii

access security, 25, 884

blocks, 110–114

machine, 24, 876, 879–880

managed, 24, 881

native, 24

preprocessor directives, excluding/including, 146–147

reuse, 394

runtime performance, 885–886

unsafe, 845–846, 863–864, 867, 872–873

whitespace, formatting, 13

collections

child, formatting, 602

classes, 638–655

concurrency, 835–837

customizing, 635

dictionaries, 636, 646–650, 696

empty, 659–660

filtering, 614

generics, 637

indexers, 655–659

initializers, 568–571

interfaces, 249, 561–562, 636–638

iterators, 660–674

compiling, 671–672

creating multiple in single classes, 673–674

defining, 661

examples of, 666–667

recursive, 669

state, 664–666

syntax, 661–662

yield break statements, 670–671

yield return statements, 674

yielding values, 662–664

linked lists, 654–655

lists, 639–641, 643–644

multiple items, searching, 645

projecting, 614

queues, 654

sorting, 641, 652

stacks, 652–654

total ordering, 643

yield return statements, placing in loops, 667–669

collisions, type names, 158

COM (Component Object Model)

DLL registration, 890

STAThreadAttribute class, 842–843

combining assignment operators with binary operators, 389

command-line

arguments, passing, 173

array options, 80

CommandLine class, 270

CommandLineAliasAttribute class, 694

CommandLineInfo class, 681, 684, 688, 689

CommandLineSwitchRequired-Attribute class, 692, 694

commands

preprocessor directives, 145

xcopy, 889

commas (,), 165

comments

code, 21–23

well-formed types, 402–407

XML, 678

Common Intermediate Language. See CIL

Common Language Infrastructure. See CLI

Common Language Runtime. See CLR

Common Language Specification. See CLS

Common Type System. See CTS

Compare() method, 495

CompareTo() method, 323, 641

generics, 463

comparison operators, 386–387

ComparisonHandler delegate, 499

comparisons

equality, requirements of, 651

interfaces

attributes, 337–338

classes, 336–337

compilers, 878

installing, 897–899

paths, configuring, 898

compiling

applications, 3–4

checked/unchecked conversions, 63

just-in-time compilation, 24, 466, 879

keywords, 4. See also keywords

machine code, 879–880

static compilation versus dynamic programming, 720–721

components, 1

composite formatting, 20

compound assignment operators, 96–103

Concat() method, 608

concatenation, strings

addition (+) operators, 90–91

at compile time, 48

concrete classes, 302, 305

concurrency, 732, 835–837

conditional logical operators, 389

conditional (?:) operators, 119–120

consequence statements, 107

consistency, integers, 35

console executable assemblies, 394

ConsoleListControl class, 316–317, 320

consoles

input, 17–19

output, 19–21

synchronization, 920–921

Console.WriteLine() method, 340, 352, 871

const values, 267

constants

expressions, 102–103

fields, declaring, 267

math, 112

public, 268

constraints, 462–476

class keyword, 468–469

class types, 467–468

constructors, 470

defaults, 474–476

inheritance, 471–472

interfaces, 465–467

limitations, 472–473

multiple, 469

specifying, 479–480

struct keyword, 468–469

constructors

attributes, initializing, 694–699

base, specifying base, 301–302

classes, 244–255

anonymous types, 253–255

chaining, 251–253

common initializers, 249

declaring, 245–246

defaults, 247

finalizers, 249–250

object initializers, 247–248

overloading, 250–251

constraints, 470, 474–476

exceptions, 418, 437

generics, defining, 457

static, 261–262

Contains() method, 643

context

switches, 732

synchronization, 788–790

contextual keywords, 6, 672–673

continuation

passing style. See CPS

query expressions, 629–630

tasks, 789

continue statement, 141–143

ContinueWith() method, 753, 775, 919–920

contravariance

enabling, 485–488

generics, 481–489

control flow

asynchronous tasks, 751

await keyword, 792–794

statements, 85, 103–110, 127–139

do/while loops, 127–129

exception-handling, 198

foreach loops, 133–136

if statements, 107–110

for loops, 120–133

switch statements, 135–139

while loops, 127–129

tasks, 780

conversions

as operator, 310–311

Boolean types, numbers, 64

boxing, 349–357

checked, 62–64, 440

CIL, 879

classes, interfaces, 326

covariant, 482. See also covariance

customizing, 283–283

data types, 60–67

enums, strings, 362–364

exception handling without, 207

explicit, 392

implicit, 64, 392

objects, deriving, 282

operators, 391, 393

strings, 65

types

checking, 883

without casting, 65–66

unchecked, 62–64, 440

cooperative cancellation, 764

coordinates, 388–389, 395

CopyTo() method, 638

cores, 730n2

Count() method, 585–586, 609, 622

Count property, 638

CountdownEvent class, 835

counting items, 585–586

CountLines() method, 157

covariance

enabling, 483–485

generics, 481–489

support, 488–489

CPS (continuation passing style), 911–913, 915

CPUs (central processing units), 730

LINQ queries, running in parallel, 584

CTS (Common Type System), 25, 877, 891, 895

curly braces ({}), 2, 10

code blocks, 110–114

customizing

add/remove handlers, 558

attributes, 692–693, 893

collections, 635. See also collections

classes, 638–655

dictionaries, 646–650

empty, 659–660

indexers, 655–659

interfaces, 636–638

iterators, 660–674

linked lists, 654–655

List<T> class, 639–641

queues, 654

searching items, 645

searching List<T> class, 643–644

sorting, 641, 652

stacks, 652–654

total ordering, 643

conversions, 283–283

dictionaries, equality, 649–650

dynamic objects, 721–724

events, implementing, 558–559

exceptions, defining, 435–438

LINQ, providers, 609

methods, asynchronous, 783–786

serialization, 708–710

synchronization contexts, 790

cycles, processors, 728, 741

data

managed, 881

persistence to files, 224

retrieval from files, 225

types, 14, 33–34

DataStorage class, 403

de-allocating objects, 882. See also allocating

deadlocks, 736, 745, 827–828

decimal types, 36–37

declaration spaces, 112–114

decrement (--) operators, 97–102

default

keyword, 68

operator, 348, 458

default constructors, 247

default constructor constraints, 474–476

deferred execution

implementing, 623

query expressions, 619

standard query operators, 586–590

#define preprocessor directive, 147–148

delegate keyword, 542

delegates, 495

asynchronous delegate invocation, 921–924

data types, 498–500

events, 554–555

operators, 540–542

sequential invocation, 542

expression trees, 527–528

generics, declaring types, 552

instances, returning, 539

instantiation, 500–502

internals, 503–506

invoking

events, 537–538

pass-by references, 547–548

returning methods, 547–548

thread-safe, 539–540

multicast, 533

internals, 542–544

observer patterns, 534–548

overview of, 496–506

P/Invoke, 862

passing, 510

sequence diagrams, 545

synchronous, 747

syntax, 502

System.Func/System.Action, 514–530

types, declaring, 500

unsafe code, executing via, 872–873

delete (C++) operator, 216

delimited comments, 22

denominators, 35

deployment, xcopy, 889

Dequeue() method, 654

dereferencing pointers, 869–871

deriving

inheritance, 278–290

casting between types, 281–282

customizing conversions, 283–283

private access modifiers, 284–285

protected access modifiers, 285–286

System.Object class, 308–309

types, 212

deserialization, 711. See also serialization

deterministic destruction (C++), 418, 882

deterministic finalization, 412–415

device drivers, 886

dictionaries

collections, 636, 646–650, 696

equality, customizing, 649–650

Dictionary<T> class, 646–650

directives. See also commands

preprocessor, 145–152

code editors, 151–152

errors/warnings, 148–150

#pragma preprocessor directive, 149

specifying line numbers, 150

symbols, 147–148

using, 168–172

DirectoryCountLines() method, 185, 187, 191

Directory.GetFiles() method, 617

DirectoryInfoExtension.Copy() methods, 260

DirectoryInfo.GetFiles() method, 597

disabling parallelism, 802

disambiguating multiple Main() methods, 174

Dispose() method, 6n6, 413, 416, 575

tasks, 770

distinct members, 631–632

Distinct() method, 608, 613

distribution, APM parameters, 911

division (/) operators, 87

DLL (Dynamic Link Library), 4

COM registration, 890

do/while loops, control flow statements, 127–129

documents

saving, 706–708

XML, 402–407, 678

domains, applications, 887

dot (.) operator, 871

DotGNU, 878

dotPeek, 30

double quotes ("), 47

double.TryParse() method, 207

downloading .NET (Microsoft), 897–899

drivers, devices, 886

duck typing, 576

Dump() method, 325

Dynamic Link Library. See DLL

dynamic objects

behaviors/principles, 716–718

binding, 719–720

CIL, 718–719

customizing, 721–724

programming, 714–724

reflection, invoking, 714–716

static compilation versus, 720–721

dynamic programming, 677

EAP (Event-based Asynchronous Pattern), 924–927

editors, code, 151–152

elements

deleting, 641

indexes, retrieving, 640

XML, runtime binding, 719–720

#elif preprocessor directive, 146–147

else clauses, 107

#else preprocessor directive, 146–147

empty catch blocks, 432. See also catch blocks

empty collections, 659–660

empty memory, retrieving, 246

Empty<T> method, 659

encapsulation, 211, 215

APIs, 859–860

circumventing, 883

classes, 267–269

publishers, 549–550

subscribers, 548–549

of types, 396

encryption. See also security

serialization, 708

strings, 804

EndGetResponse() method, 908

#endif preprocessor directive, 146–147

#endregion preprocessor directive, 151–152

EndX() method, 908

Enqueue() method, 654

Enter() method, 353

EntityBase, EntityBase<T> class, 468, 471

EntityDictionary, EntityDic-tionary<T> class, 469, 476

enumeration, values, 702

enums, 358–368

Enum.Parse() method, 363, 680

flags, 364–368

string conversions, 362–364

type compatibility, 361–362

equality, 93. See also inequality

dictionaries, customizing, 649–650

operators, 115–116

structural, delegates, 516–517

Equals() method, 349, 651

overriding, 376–385

equals (==) operator, 386

#error preprocessor directive, 148–150

errors

arrays, 72, 81–82

buffer overrun, 76

handling

platform interoperability/unsafe code, 854–856

sequential notification, 544–547

using statements, 575

infinite recursion, 186

methods, 194–208

namespace alias qualifiers, 401

operators, 115

preprocessor directives, 148–150

reporting, 204–207

rounding, 37

trapping, 195–201

Windows Error Reporting, 425

escape sequences, 44

verbatim string literals, 47

Etch A Sketch, 444

evaluation, 89

order of operands, 90

Event-based Asynchronous Pattern. See EAP

event keyword, 550, 551

events, 533–534

CIL code, 556–557

code conventions, 552–554

declaring, 550–551

delegates, 554–555

invoking, 537–538

operators, 540–542

sequential invocation, 542

generics, 554–555

handlers

adding, 846–848

removing, 846–848

implementing, customizing, 558–559

internals, 556–558

multicast delegates, 534–548

notifications

firing, 553

multiple threads, 826–827

null, checking for, 538–539

publishers

connecting subscribers and, 536–537

defining, 536

resetting, 831–837

WinRT, 846–848

examples of iterators, 666–667

exceptions

AggregateException, 547, 757–764, 768

parallel loop exception handling, 798–800

ArgumentException, 424

ArgumentNullException, 424

ArgumentOutOfRangeException, 424

asynchronous high-latency operations, 775–776

catching, 196–197, 426–427

classes, inheritance, 201

common exception types, 202

constructors, 418, 437

defining custom exceptions, 435–438

handling, 423

general catch blocks, 428–432

guidelines, 432–435

multiple exception types, 424–425

hiding, 432

InnerExceptions property, 760

InvalidAddressException, 435

InvalidCastException, 353, 464

InvalidOperationException, 427, 439

NotImplementedException, 321

NullReferenceException, 424, 538, 551, 659, 826

OperationCanceledException, 807

OutOfMemoryException, 433

reporting, 433

rethrowing, 206, 438–442

sequences, diagrams, 545

serializable, 438

specifiers, 427

SqlException, 437

StackOverflowException, 433

suffixes, 437

System.ComponentModel.Win32Exception, 854

System.FormatException, 198, 199

System.InvalidCastException, 393

System.Runtime.Serialization.Serialization-Exception, 710

TaskCancelledException, 767, 768

ThreadAbortException, 741, 742

throwing, 195, 204–205, 321

arrays, 75

checked/unchecked conversions, 63

deserialization, 711

UnauthorizedAccessException, 438

unhandled, 195, 761–764

wrapping, 438–442

excluding code, preprocessor directives, 146–147

exclusive OR (^) operator, 118, 122

execution

agents, 881

deferred

implementing, 623

query expressions, 619

standard query operators, 586–590

delegates, unsafe code, 872–873

managed, 881

managing, 24–26

Exit() method, 353

explicit conversions, 392

explicit deterministic resource cleanup, 216

explicit member implementation, 322–323

exponential notation, 40

expressions

Boolean, 107, 114–121

constants, 102–103

generics, 6n6

lambda, 495, 506–512

asynchronous programming, 782–783

expression trees, 524

internals, 517–518

lazy loading, 420

statements, 507–510

queries

continuation, 629–630

filtering, 623–624

flattening sequences, 630–622

grouping, 626–629

invoking methods, 632–634

let clause, 625–626

LINQ, 561, 613

overview of, 614–632

projecting, 616–619

sorting, 624–625

trees, 496, 523–530

Extensible Markup Language. See XML

extensions

methods, 265–266

IEnumerable<T> interface, 562

inheritance, 287

interfaces, 330–331

Reactive Extensions library, 729

external functions

declaring, 849–850

P/Invoke, calling, 858–861

f-reachable queues, 416

factory interfaces, 475

factory methods, 461

FCL (Framework Class Library), 892, 895

features, adding, 278. See also inheritance

Fibonacci numbers/series, 128, 351

fields, 51

backing, declaring, 232, 244

constants, declaring, 267

guidelines, 234–235

instances, 217–219

readonly modifiers, declaring, 268, 269

static, 256–258

virtual, properties, 240–242

volatile, declaring as, 823–824

FileInfo object, 625–626

files

data

persistence to, 224

retrieval from, 225

headers, 168

loading, 224

metadata, 892–893

references, assemblies, 889

storing, 224

XML, 23, 402–407. See also XML

FileSettingsProvider, 329

FileStream property, 419

filtering

collections, 614

query expressions, 623–624

System.Linq.Enumerable.Where(), 568–569

WHERE clause, 623–624

finalizers, 249–250, 347, 410–412

finally blocks, 199–200

FindAll() method, 645

firing events, 548, 553

first in, first out (FIFO), collections, 654

fixed statements, 867, 868

flags

enums, 364–368

values, 702

FlagsAttribute class, 367, 701–702

flattening sequences, 630–622

floating-point types, 35–36, 92–96, 351

flow control, 730. See also control flow statements

for loops, 120–133

foreach loops, 133–136

arrays, 571–572

IEnumerable<T> interface, 572–577

ForEach() method, 801

foreground threads, 739

formal declaration, methods, 165–166

format items, 20

Format() method, 48

format strings, 20

formatting

comments, 21–23

if/else statement sequences, 109

indentation, code blocks, 111

numbers as hexadecimal, 41

round-trip, 42–43

string length, 51

variables, 15

whitespace, 12–13

forms, Windows Forms, 932–934

FORTRAN, 890

fractions, 35

fragile base classes, 295

frames, removing activation, 175

Framework (Microsoft .NET), 878

Framework Class Library. See FCL

frameworks, 877

FROM clause, 615

from clause, flattening sequences, 630–632

FromCurrentSynchronizationContext() method, 788

full outer joins, 594

functionality, CLI, 888n5

functions

external

declaring, 849–850

P/Invoke, 858–861

global, 256

pointers, 862

fundamental numeric types, 34–43

garbage collection, 25, 215

.NET (Microsoft), 882–883

resource cleanup, 415–418

runtime, 881–882

value types, 347

well-formed types, 407–410

gating parallelism, 802

GC.ReRegisterFinalize() method, 419

general catch blocks, 203, 428–432

general-purpose delegates, System.Func/System.Action, 514–530

generating

anonymous types, 568

XML documentation files, 405–407

generics, 443

arity, 460–461

benefits of, 452–453

C# without, 444–449

CIL, 490–491

classes, 450–452

collections, interface hierarchies, 637

constraints, 462–476

constructors, defining, 457

contravariance, 481–489

covariance, 481–489

default values, specifying, 458–459

delegates, declaring types, 552

events, 554–555

expressions, 6n6

finalizers, defining, 457

instantiation

reference types, 492–493

value types, 491–492

interfaces, 454–455, 456–457

internals, 489–493

Java, 493

lazy loading, 420

methods, 476–481

casting inside, 480–481

type inference, 478–479

multiple type parameters, 459–460

nested types, 461–462

structs, 454–455

types, 449–462, 686–688

GetCustomAttributes() method, 694

GetDynamicMemberNames() method, 724

GetEnumerator() method, 576, 577, 610, 661, 662, 664, 787n8

GetFiles() method, 157

GetFirstName() method, 232

GetFullName() method, 166

GetGenericArguments() method, 687

GetHashCode() method, 349, 373–376, 651

GetInvocationList() method, 547, 548

GetLength() method, 79

GetName() method, 219

GetResponse() method, 772

GetResponseAsync() method, 779

GetReverseEnumerator() method, 673

GetSetting() method, 327

GetSummary() method, 305

GetSwitches() method, 696

getters, 51

access modifiers, 239–240

accessibility, modifying, 237–239

declaring, 230

GetType() method, 679–680

GetUserInput() method, 166

GetValue() method, 685

GhostDoc, 406n3

global functions, 256

global methods, 164

global variables, 256

goto statements, 143–145

graphs, expression trees, 525–527

GreaterThan method, 507

groupby clause, 627

GroupBy() method, grouping results, 600–601

grouping

encapsulation, 215

methods, 502

namespaces, 158

query expressions, 626–629

results, 600–601

statements into methods, 156–157

types, defining namespaces, 398–402

GroupJoin() method, 613

guest computers, 872

guidelines

addition (+) operators, 91

anonymous methods, 513

attributes

assemblies, 692

AttributeUsageAttribute class, 700

constructors, 699

custom, 693

catch blocks, 204

classes

access modifiers, 240

naming, 8, 214

collections, 649

comments, 23

constants, fields, 267

constructors

defaults, 248

naming, 251

conversion operators, 393

Count() method, 586

covariance, 489

curly braces ({}), 112

custom collections, 643

delegates, types, 515

empty collections, 660

Equals() method, 385

events, declaring, 554

exceptions

customizing, 437

handling, 207, 432–435

multiple exception types, 425

reporting, 435

throwing, 106, 201

wrapping, 439

extension methods, 266

fields, 234–235

finalizers, 417

floating-point types, 93, 95

generics

implementing multiple interfaces, 457

methods, 481

type parameters, 462

goto statements, 145

identifiers, 7

if/else statements, 120

increment/decrement operators, 101

integers, 35

interfaces

adding members, 335

attributes, 338

comparing to classes, 337

explicit/implicit implementations, 324–325

implementations, 326

multiple inheritance, 333

naming, 315

lambda parameters, 509

literal suffixes, 40

local variables, 15

locking, avoiding, 823

long-running tasks, 770

for loops, 132, 133

managed wrappers/unmanaged methods, 856

methods, naming, 157

multiple type parameters, 460

multithreading, 733, 736

aborting threads, 743

thread pools, 745

Thread.Sleep() method, 741

unhandled exceptions, 764

namespaces, 161, 401

nested classes, 272

.NET (Microsoft), 6

null, invoking delegates, 539

OrderBy()/ThenBy() methods, 592

P/Invoke, 862

parallel loops, 797

parameters, 166, 191, 192

parentheses (()), 90

properties, 234–235

get-only, 239

validating, 237

query expressions, 634

static initialization, 262

switch statements, 137

synchronization, avoiding, 823

System.EventHandler<T> class, 555

thread synchronization, 811–841

best practices, 827–829

Monitor, 817–819

ToString() method, 373

types, naming parameters, 453–454

value types

avoiding mutable types, 355

creating enums, 361

defaults, 347

defining structs, 369

direct enum/string conversions, 365

enum underlying types, 360

flag enums, 366

immutable, 345

memory, 341

overloading equality operators, 349

XML comments, 407

Handle() method, 760

handlers, events

adding, 846–848

removing, 846–848

handling

aliasing, 697–699

errors

platform interoperability/unsafe code, 854–856

sequential notification, 544–547

using statements, 575

exceptions, 423

asynchronous high-latency operations, 775–776

avoiding, 206–207

background worker patterns, 931–932

catching, 426–427

defining custom exceptions, 435–438

general catch blocks, 428–432

guidelines, 432–435

multiple exception types, 424–425

rethrowing, 438–442

wrapping, 438–442

exceptions, parallel loops, 798–800

hard coding values, 38–40

hash codes, 651

headers, files, 168

heaps

memory, 349

reference types, 59, 342

Heater objects, 534–535

HelloWorld program, 1, 2–4

output, 29–30

static keyword, 255

Help property, 689

hexadecimal notation, 40–41

hiding exceptions, 432

hierarchies

classes, 212, 324

interfaces, generic collections, 637

organizing, 161

high-latency operations, invoking, 771–772, 772–777

hill climbing, 798

hot tasks, 748. See also tasks

Hyper-Threading, 730

I/O-bound latency, 728, 732

IAngle.MoveTo interface, 354

IAsyncAction<T> interface, 848, 849

ICollection<T> interface, 638

IComparable interface, 323, 324

IComparable<T> interface, constraints, 465

IComparer<T> class, 495

identifiers, 6–7

keywords as, 8

namespaces, nesting, 400

IDictionary<T> interface, 636–638

IDisposable interface

finalization, 415–418

resource cleanup with, 413

tasks, 770

IDispose() method, 915

IDistributedSettingsProvider interface, 335

IEnumable<T> interface, 571–577

IEnumerable interface, 331

IEnumerable<T> interface, 616n1

extension methods, 562

query expressions, 616

standard query operators, 577–610

if/else statements, guidelines, 120

#if preprocessor directive, 146–147

if statements, 80, 107–110

Boolean expressions, 114–121

IFileCompression interface, 314, 315

IFormattable interface, 357

ILDASM, CIL, 28–29

IListable interface, 331

IList<T> interface, 636–638

ILMerge utility, 889

ILSpy, 30

immutable strings, 17, 51, 52

modifying, 869–870

implementation-defined behavior, 101

implementing

CIL, outer variables, 520–521

CLI, 877–878

conversion operators, 392

deferred execution, 623

dynamic objects, 714

Equals() method, 382

events, customizing, 558–559

GetHashCode() method, 375–376

interfaces, 313–315, 316–319, 320–326, 456–457

members

explicit, 322–323

implicit, 323–326

multiple inheritance, interfaces, 331–334

new operator, 246

object-oriented programming, 210–213

one-to-many relationships, 601–604

outer joins, 603–604

properties, automating, 232–234

System.Runtime.Serialization.ISerializable class, 709–710

implicit base type casting, 281

implicit conversions, 64, 392

implicit deterministic resource cleanup, 216

implicit local variables, 562–568

implicit members, implementing, 323–326

implicit nondeterministic resource cleanup, 216

implicit overriding, Java, 292

implicitly typed local variables, 55–57

in type parameter, 485–488

including code, preprocessor directives, 146–147

Increment() method, 825

increment (++) operators, 97–102

indenting

code blocks, 111

whitespace, 12

IndexerNameAttribute, 657

indexers

assigning, 657–658

collections, 655–659

indexes, retrieving elements, 640

IndexOf() method, 643

inequality, floating-point types, 93–96

inferences, types, 478–479

infinity

negative, 96

recursion errors, 186

infrastructure, CLI, 875–877. See also CLI

inheritance, 211–212, 277, 310–311

abstract classes, 302–308

aggregation, 289

base classes

base member, 300–301

new modifier, 295–299

overriding, 290–302

sealed modifiers, 299–301

chaining

casting, 282–283

exceptions, 437

classes, exceptions, 201

constraints, 471–472

definitions, 277–278

derivation, 278–290

casting between types, 281–282

customizing conversions, 283–283

private access modifiers, 284–285

protected access modifiers, 285–286

extension methods, 287

interfaces, 326–329

multiple, 329–330, 331–334

value types, 348–349

is operator, verifying underlying type, 309–310

multiple, 287

polymorphism, 306

sealed classes, 290

single, 287–289

System.object, deriving classes, 308–309

virtual modifiers, 290–295

initialization

anonymous types, arrays, 570–571

centralizing, 252–253

clauses, 132

collection initializers, 568–571

lazy, 419–421

NextId, 261

static, 262

static fields, 257

structs, 346–347

Initialize() methods, 236

initializers

common, 249

constructors, 251

objects, 247–248

initializing attributes, constructors, 694–699

inner classes, Java, 272

inner joins, 593

Join() method, 597–600

InnerExceptions property, 437, 439, 760

input, consoles, 17–19

inserting newline ( ) characters, 46

installing .NET (Microsoft), 897–899

instances

applications, formatting single, 829–830

delegates, returning, 539

fields, 217–219. See also static fields

methods, 48, 78–79, 219–220

polymorphism, 321

instantiation, 10

arrays, 70–74

classes, 213–216

delegates, 500–502

generics

reference types, 492–493

value types, 491–492

integers, 34–35

42 as, 195

adding, 351

values, overflowing, 62, 440

integral types, 91

IntelliSense, enabling, 615

interfaces, 313–315

APIs, 27, 438, 439

attributes, comparing, 337–338

automatically shimmed, 848

classes

comparing, 336–337

conversions, 326

collection, 561–562, 636–638

anonymous types, 562–564

implicit local variables, 564–565, 566–568

constraints, 465–467

diagrams, 333–334

extension methods, 330–331

factory, 475

generics, 454–455, 456–457

hierarchies, generic collections, 637

IAngle.MoveTo, 354

IAsyncAction<T>, 848, 849

ICollection<T>, 638

IComparable, 323, 324

IComparable<T>, 465

IDictionary<T>, 636–638

IDisposable

finalization, 415–418

resource cleanup with, 413

tasks, 770

IEnumable<T>, 571–577

IEnumerable, 331

IEnumerable<T>

extension methods, 562

query expressions, 616

standard query operators, 577–610

IFileCompression, 314, 315

IFormattable, 357

IList<T>, 636–638

implementing, 316–319, 320–326

inheritance, 326–329

multiple, 329–330, 331–334

value types, 348–349

IObsolete, 338

IOrderedEnumerable<T>, 592

IQueryable<T>, 609–610

IReadOnlyPair<T>, 484

ISerializable, 709

ITrace, 325

multithreading, prior to TPL and C# 5.0, 907–936

naming, 315

PairInitializer<T>, 487

parameters, 192

polymorphism, 315–320

versioning, 334–336

Windows UIs, 790–792, 932–936

internal access modifier, 397

internals

anonymous methods, 517–518

delegates, 503–506

events, 556–558

generics, 489–493

lambda expressions, 517–518

multicast delegates, 542–544

interoperability, 25

CIL, 890. See also CIL

languages, 25

platforms, 845–846, 862–872

Intersect() method, 608

into keyword, 629–630

InvalidAddressException, 435

InvalidCastException, 353, 464

InvalidOperationException, 427, 439

Invoke() method, 685, 932

InvokeRequired property, 932

invoking

asynchronous delegate invocation, 921–924

asynchronous tasks, 747–748

delegates

events, 537–538

exception sequence diagrams, 545

pass-by references, 547–548

returning methods, 547–548

sequences, 542

thread-safe, 539–540

finalizers, 412

high-latency operations, 771–777

members, reflection, 681–686

methods, query expressions, 632–634

reflection, dynamic objects, 714–716

type members, 678. See also reflection

IObsolete interface, 338

IOrderedEnumerable<T> interface, 592

IProducerConsumer-Collection<T> class, 835

IQueryable<T> interface, 609–610

IReadableSettingsProvider interface, 327

IReadOnlyPair<T> interface, 484

is operator, verifying underlying types, 309–310

IsAlive property, 740

IsBackground property, 739

IsCancellationRequested property, 766, 767, 801

IsCompleted property, 750, 804

ISerializable interface, 709

ISettingsProvider interface, 327

IsKeyword() method, 620

items

collections, searching, 645

counting, 585–586

format, 20

grouping, 600–601

Items property, 456

iterations

collection interfaces, 573

continue statements, 141

long-running loops, 802

loops, 129, 794–804

iterators

collections, 660–674

compiling, 671–672

contextual keywords, 672–673

creating multiple in single classes, 673–674

defining, 661

examples of, 666–667

state, 664–666

struct versus class, 670

syntax, 661–662

yield break statements, 670–671

yield return statements, 674

yielding values, 662–664

recursive, 669

ITrace interface, 325

IWriteableSettingsProvider interface, 329

jagged arrays, 73, 75

Java, 1

arrays, declaring, 69

classes, naming, 4

exceptions, specifiers, 427

generics, 493

implicit overriding, 292

inner classes, 272

Main method, 10

virtual methods, 291

JavaScript, implicitly typed variables, 565

jitting, 879

Join() method, 739, 748

inner joins, 597–600

joining

collections, 593

data types, 57

jump statements, 139–145

break statements, 139–141

continue statement, 141–143

goto statement, 143–145

just-in-time compilation, 24, 466, 879

JustDecompile, 30

keys, 637

keywords, 2, 4–6

into, 629–630

async, 777–781, 937–942

await, 741, 777–781, 937–942

class, constraints, 468

contextual, iterators, 672–673

default, 68

delegate, 542

event, 550, 551

as identifiers, 8

integers, 34

lock

applying, 819–821

selecting objects, 821–822

new, 71, 205

null, 53–54

operator, 392

override, 292, 323

private, 229

properties, defining, 232

static, 264

string, avoiding locking, 822–823

struct, 343, 468

this, 220–227

avoiding locking, 822–823

chaining constructors, 251–253

try, 197

typeof, 363, 822–823

unchecked, 442

void, 53, 54–55

where, 465

lambda expressions, 495, 506–512

asynchronous programming, 782–783

expression trees, 524

internals, 517–518

lazy loading, 420

statements, 507–510

tables, 511–512

languages

CIL, 876

CLI. See CLI

CLR, 881

CLS, 25, 891–892

CLU, 660

COBOL, 890

FORTRAN, 890

overview of, 1–2

Pascal, 7

source, 890

XML, 23–24. See also XML

last in, first out (LIFO), 444, 652

LastIndexOf() method, 643

late binding, 893

latency, 728

invoking high-latency operations, 771–777

lazy initialization, 419–421

left outer joins, 593

length

arrays, 75–76

strings, 51

let clause, 625–626

libraries

assemblies, 394

ATL, 287

BCL, 25, 26, 34, 885, 892, 894

classes, 394

code, creating, 4

DLL, 4

FCL, 892, 895

Reactive Extensions library, 729

Task Parallel Library (TPL), 729, 790. See also TPL

WinRT, 846–849

limitations, constraints, 472–473

line-based statements (Visual Basic), 11

#line preprocessor directive, 150

lines, specifying numbers, 150

linked lists, collections, 654–655

LinkedListNode<T> class, 655

LinkedList<T> class, 654–655

links, DLL, 4

LINQ

expression trees, 527

providers, customizing, 609

queries. See also queries

expressions, 561, 613

running in parallel, 584–585, 804–808

support, 27

Linux, installing platforms, 898

Liskov, Barbara, 660

listings

anonymous methods, passing, 512

APM patterns

accessing user interfaces, 933–934

asynchronous delegate invocation, 922–923

background worker patterns, 928–929

ContinueWith() method, 919

EAP, 926–927

invoking user interface objects, 935–936

invoking with callback/state, 911–912

passing state, 913–914

System.Net.WebRequest class, 908–909

using TPL to call, 915–918

arrays

accessing, 74

assigning, 70

command-line options, 80

declaring, 69

defining size at runtime, 72

errors, 72

initializing two-dimensional arrays of integers, 72

jagged, 73, 75

length, 75, 76

literal values, 71

methods, 77

new keyword, 71

retrieving dimension size, 79

reversing strings, 80–81

swapping data, 74

three-dimensional, 73

throwing exceptions, 75

two-dimensional arrays, 69, 72, 74–75

attributes

applying named parameters, 700

assembles within AssemblyInfo.cs, 690–691

AttributeUsageAttribute, 699–700

backward compatibility, 712

constructors, 695

decorating properties with, 689, 690

defining custom, 693

FlagsAttribute class, 701–702

implementing System.Runtime.Serialization.ISerializable class, 709–710

restricting constructs, 699

retrieving custom, 693–694

retrieving specific attributes, 695–696

saving documents, 706–708

specifying return attributes, 691

System.AttributeUsage-Attribute class, 699–700

System.ConditionalAttribute class, 703–705

System.ObsoleteAttribute class, 705–706

System.SerializableAttribute class, 713

updating CommandLineHandler.TryParse(), 697–699

break statements, 139–140

case-sensitivity of multiple strings, 43

checked blocks, 62–63

classes

access modifiers, 229

accessing fields, 218, 219–220

accessing static fields, 257–258

assigning static fields at declaration, 257

automatically implemented properties, 233–234

avoiding ambiguity, 221–222

calling constructors, 245–246, 251–252

calling object initializers, 248, 249

CIL code from properties, 243–244

data persistence to files, 224

data retrieval from files, 225

declaring, 8

declaring constant fields, 267

declaring fields, 217

declaring getter/setter methods, 230

declaring static classes, 263–264

declaring static constructors, 261

declaring static fields, 256

declaring static properties, 262

declaring variables of class types, 214

defining, 213

defining constructors, 245

defining nested classes, 270–271, 273, 274–275

defining partial classes, 272–273

defining properties, 231, 240–242

defining read-only properties, 238

defining static methods, 259–260

explicit construct properties, 244

implicit local variables, 254

initialization methods, 253

instantiation, 215

overloading constructors, 250

passing this keyword in method calls, 223

placing access modifiers on setters, 239–240

readonly modifiers, 268, 269

setting initial values of fields, 217

this keyword, 220–221, 222

validating properties, 236

code blocks

if statements, 110

indentation, 111

collection interfaces

filtering with System.Linq.Enumerable.Where(), 568–569

foreach with arrays, 572

implicit local variables with anonymous types, 562–563

initializing anonymous type arrays, 570–571

iterating, 573

resource cleanup with using statements, 575

results of foreach, 575–576

separate enumerators during iteration, 574–575

type safety, 566–567

comments, 21

continue statement, 141–143

control flow statements

do/while loops, 129

foreach loops, 134

if/else formatted sequentially, 109

if/else statements, 107

if statements, 135

multiple expressions (for loops), 132

nested if statements, 108

while loops, 127

custom collections

adding items to Diction-ary<T> class, 647

applying Pair<T>.Get-Enumeator() method, 667

applying yield statements, 666

bitwise complement () operator, 644

compiling iterators, 671–672

defining index operators, 658–659

defining indexers, 655–657

FindAll() method, 645

implementing IComparer<T> interface, 642

implementing IEquality-Comparer<T> interface, 650

inserting items to Dictionary<T> class using index operators, 647

iterating over Dictionary<T> class with foreach, 648–649

iterator interface patterns, 661–662

List<T> class, 640

modifying indexer default names, 658

yield break statements, 670–671

yield return statements, 673

yielding C# keywords sequentially, 663–664

delegates

applying method names as arguments, 501–502

applying variance, 516–517

BubbleSort() method, 496–497

BubbleSort() method, ascending/descending, 497–498

BubbleSort() method, parameters, 498–499

capturing loop variables, 521–522, 523

CIL code for outer variables, 520

CIL for lambda expressions, 517–518

declaring Comparison-Handler, 501

declaring Func/Action, 514–515

declaring nested types, 500

declaring types, 500

expression trees, 525

outer variables, 518–519

passing as parameters, 502

viewing expression trees, 528–530

dynamic objects

customizing, 721–723

overriding members, 723–724

runtime binding, 719–720

equality operators, overriding, 376–380

Equals() method, overriding, 383–384

escape sequences, 44

events

applying assignment operators, 548

CIL code, 556–557

connecting publishers/subscribers, 536–537

custom add/remove handlers, 558

custom delegate types, 554–555

declaring generic delegate types, 552

declaring OnTemperature-Change event, 556

defining Heater/Cooler objects, 534–535

defining publishers, 536

delegate operators, 540, 541

event keyword, 550–551

firing, 549

firing notifications, 553

handling exceptions from subscribers, 546–547

invoking delegates, 537–538

OnTemperatureChanged() method, 544

exceptions

catching, 426, 428–431

checked blocks, 440–441

customizing, 436

defining serializable, 438

overflowing integer values, 440

throwing, 424

unchecked blocks, 441–442

explicit casts, 61

generics

arity, 460

BinaryTree<T> class, 462–463, 480

CIL code for Stack<T> class, 490

CIL with Exclamation Point Notation, 491

combining constraints, 473–474

combining covariance and contravariance, 487

ComparisonHandler, 504–505

compile errors, 458

compiler validation of variance, 488

constraint expressions, 473

contravariance, 486

converting generics, 482

covariance, 482, 483–484

covariance using out type parameter modifier, 484

Create() method, 461

declaring class type constraints, 467

declaring constructors, 457

declaring generic classes, Stack<T>, 452

declaring interface constraints, 465

declaring interfaces, 454

declaring nullable types, 449

declaring variables of type scatter<T>, 491

declaring versions of value types, 448

default constructor constraints, 470, 475

default operator, 458

defining methods, 477

defining specialized stack classes, 447

duplicating interface implementations, 456

EntityDictionary<T> class, 476

factory interfaces, 475

implementing interfaces, 455

implementing Undo with Stack class, 450–451

inferring type arguments, 478

inheritance constraints, 474

inheritance constraints, specified explicitly, 471

interface support, 463

multiple constraints, 469

multiple type parameters, 459, 460

nested types, 462

repeating inherited constraints, 472

specifying constraints, 479–480

specifying type parameters, 478

struct/class keywords, 468

supporting Undo, 444–445

System.Collections.Stack method signatures, 444

System.Delegate class, 504

type parameter support, 464

GetHashCode() method, overriding, 375

goto statements, 143–144

HelloWorld, 2

breaking apart, 9

output, 29–30

hexadecimal notation, 41

implicit conversions, 64

implicit local variables, 56–57

inheritance

accessing base members, 300

accessing private members, 284

accessing protected members, 285–286

applying methods, 280

applying polymorphism, 306–307

defining abstract classes, 303

defining abstract members, 303–304

defining cast operators, 283

deriving classes, 279, 280

implicit base type casting, 281

is operator determining underlying type, 309

new modifier, 297–298

as operator conversions, 310–311

overriding properties, 291

preventing derivation, 290

Run() method, 294

sealing members, 299

single using aggregation, 288

specifying base constructors, 301–302

System.Object derivation, 309

virtual methods, 292, 293

integers, overflowing values, 62

interfaces

applying base interfaces in class declarations, 328

calling explicit member implementations, 322

declaring explicit members, 327

defining, 315

deriving, 326–327, 335

explicit interface implementation, 322–323

implementing, 316–319, 320–321

multiple inheritance, 329

single inheritance using aggregation, 331–332

lambda expressions

omitting parameter types, 508

parameterless statements, 509

passing delegates, 510

single input parameters, 509

statements, 507

literal values, 38, 39

for loops, 130

Main() method, 10

methods

aliasing, 171–172

calling, 158

catching exceptions, 196–197

converting a string to an int, 194

counting lines, 184–185, 187–189

declaring, 163–164

finally blocks without catch blocks, 199–200

general catch blocks, 203

grouping statements, 156–157

optional parameters, 189–191

passing command-line arguments, 173

passing return values, 162

passing variable parameter lists, 181–182

passing variables by reference, 177–178

passing variables by values, 175–176

passing variables out only, 179–180

rethrowing exceptions, 206

return statements, 167

specifying parameters by names, 191–192

throwing exceptions, 204–205

using directive, 170–171

multiple statements on one line, 12

multithreading

applying Task.Factory.StartNew() method, 769

asynchronous Web requests, 773–774, 777–778

await keyword, 787–788

calling Task.ContinueWith method, 752, 789

cancelling parallel loops, 800–801

cancelling PLINQ queries, 807–808

cancelling tasks, 765–766

customizing asynchronous methods, 784–785, 785–786

handling tasks, unhandled exceptions, 758–759

invoking asynchronous tasks, 747–748

iterating over await operations, 792–793

lambda expressions, 782–783

LINQ Select() method, 804

long-running tasks, 769–770

for loops, 794–795, 796

observing unhandled exceptions, 760–761

parallel execution of foreach loops, 797

PLINQ Select() method, 805

PLINQ with query expressions, 806

polling Task<T> classes, 749

registering for notifications, 756

registering for unhandled exceptions, 762–763

starting methods, 737–738

synchronous high-latency invocation with WPF, 791–792

synchronous Web requests, 772–773

ThreadPool, 743–744

unhandled exception handling, parallel iterations, 799

character, 46

no indentation formatting, 12

nullable modifiers, 60

operators, 86

AND (&&), 118

binary, 87–88

bitwise, 124

char data types, 92

character differences, 92

common increment calculations, 97

conditional, 119

constants, 103

decrement (- -), 98

dividing a float by zero, 95

equality, 116

examples of assignment, 97

increment (++), 97

inequality with floating-point types, 94–95

logical assignment, 126

negative values, 87

non-numeric types, 91

NOT, 118

null coalescing, 120

overflowing bounds of float, 96

post-increment, 99

pre-increment, 99

prefix/postfix, 100

relational, 116

Unicode values in descending order, 98

Parse() method, 65

placeholders, 20

platform interoperability/unsafe code

accessing referent type members, 871–872

allocating data on call stacks, 868

applying ref/out rather than pointers, 852

declaring external methods, 849–850

declaring types, 853

designating unsafe code, 863, 872–873

encapsulating APIs, 859–860

fixed statements, 867, 868

invalid referent types, 866

managed resources, 857–858

modifying immutable strings, 869–870

SafeHandle, 856–857

Win32 error handling, 854–855

WinRT patterns, 847–848

wrapping APIs, 861

#pragma preprocessor directive, 149

preprocessor directives, 147

#define, 147

excluding/including code, 147

#region/#endregion, 151

#warning, 148

query expressions, 614–615, 632–633

anonymous types, 618

continuation, 630

deferred execution, 619–622

distinct members, 631–632

filtering, 623–624

grouping, 626–627

multiple selection, 630

ordering results, 616

projection using, 617

selecting anonymous types, 628–629

sorting, 624

sorting by file size, 625

standard query operator syntax, 633

reflection

declaring Stack<T> class, 686

dynamic programming using, 715

dynamically invoking members, 681–684

generics, 687, 688

using Type.GetProperties() method, 679–680

using typeof() method, 680

round-trip formatting, 42

single statements, splitting, 12

standard query operators

calling SelectMany() method, 604–605

classes, 578–580

counting items, 585

creating child collections, 602

executing LINQ queries in parallel, 584

filtering with System.Linq.Enumerable.Where() method, 581, 586–587

grouping items, 600–601

inner joins, 597–598, 599

ordering, 590–591

outer joins, 603–604

projection to anonymous types, 583

projection with System.Linq.Enumerable.Select() method, 582

sample employee/department data, 594–596

System.Linq.Enumerable() method calls, 606–607

strings

applying, 52–53

assigning null to, 54

binary displays, 125

immutable, 52

implicitly typed local variables, 55–56

length, 51

switch statements, 137–138

System.Console.ReadLine() method, 17–18

System.Console.WriteLine() method, 19–20

System.Convert class, 65

System.Threading.Timer class, 941–942

System.Timers.Timer class, 939–940

thread synchronization, 811–841

best practices, 827–829

creating single instance applications, 829–830

firing event notifications, 826

lock keyword, 820

ManualResetEventSlim, 832–833

Monitor class, 817–818

System.Threading.Interlocked class, 824–825

Task.Delay() method, 842

thread-safe event notification, 826

ThreadLocal<T> class, 838

ThreadStaticAttribute class, 839–840

unsynchronized local variables, 815–816

unsynchronized state, 813

Tic-Tac-Toe source code, 901–905

timers, 939–942

ToString() method, 65, 372–373

unchecked blocks, 63

Unicode characters (smiley faces), 45–46

value types

accessing properties, 346

avoiding copying/unboxing, 357

boxing idiosyncrasies, 353

boxing/unboxing instructions, 351

casting between arrays/enums, 362

comparing integer switches/enum switches, 358

converting strings to enums, 363

declaring enums, 359

declaring structs, 344–345

default operator, 348

defining enum values, 366

defining enums, 359

enums as flags, 364

FlagsAttribute, 367

initializing structs, 346

OR/AND operators with flag enums, 365

referencing Equals() method, 381

unboxing to underlying types, 353

variables

assigning, 16

declaring, 13

modifying values, 15

one statement, declaring with, 15

scopes, 113

verbatim string literals, 47

well-formed types

adding operators, 387–388

applying alias directives, 402

calling binary operators, 388

comparison operators, 386

conversion operators, 392

defining finalizers, 411

defining namespaces, 399

invoking using statements, 415

lazy loading properties, 419, 420

making types available, 396

nesting namespaces, 400

overloading unary operators, 390, 391

resource cleanup, 413

weak references, 409

XML comments, 403–406

whitespace, removing, 12

lists

collections, 640

formal parameters, 165

linked, collections, 654–655

type parameters, 165

List<T> class, 482, 639–641

searching, 643–644

literals

strings, 46–48

values, 37–38

arrays, 71

readonly fields, 269

loading

files, 224

lazy. See lazy initialization

local negation (!) operator, 118–119

local storage, threads, 837–841

local variables, 14

anonymous types, 562–563

declaring, 165–166

implicit, 564–565, 566–568

implicitly typed, 55–57

multiple threads, 815–816

scope, 114

locations

keywords, 4

objects, 408

reference types, 341–345

lock keyword

applying, 819–821

objects, selecting, 821–822

lock statements, 736

value types, 353–255

locking, 828–829

avoiding, 822–823

consoles, synchronization, 920–921

multithreading, 736

lockTaken parameter, 819

logical Boolean operators, 116–121, 122–126

Logon() method, 228

long-running

loops, 802

tasks, 769–770

loops

for, 120–133

decrement (--) operators, 98

do/while, control flow statements, 127–129

executing, iterations in parallel, 794–804

foreach, 133–136

arrays, 571–572

IEnumerable<T> interface, 572–577

iterations, 129

parallel

breaking, 803–804

executing iterations in, 794–804

options, 802–803

variables, capturing, 521–522

while, control flow statements, 127–129

yield return statements, placing in, 667–669

LowestBreakIteration property, 804